services4/srvkm/bridged/bridged_pvr_bridge.c \
services4/srvkm/bridged/bridged_support.c \
services4/srvkm/bridged/sgx/bridged_sgx_bridge.c \
-services4/system/$(TI_PLATFORM)/sysutils_linux.c \
+services4/system/$(TI_PLATFORM)/sysutils.c \
services4/system/$(TI_PLATFORM)/sysconfig.c \
EXTRA_CFLAGS += -I$(src)/include4
EXTRA_CFLAGS += $(ALL_CFLAGS)
pvrsrvkm-y := $(FILES:.c=.o)
-ifeq ($(TI_PLATFORM),ti8168)
-obj-y := services4/3rdparty/dc_ti8168_linux/
+
+ifeq ($(TI_PLATFORM),ti81xx)
+obj-y := services4/3rdparty/dc_ti81xx_linux/
else
-obj-y := services4/3rdparty/dc_omap3_linux/
+obj-y := services4/3rdparty/dc_omap3430_linux/
endif
obj-y += services4/3rdparty/bufferclass_ti/
-ifeq ($(VERSION), 3)
-export EXTRA_CFLAGS += -DAUTOCONF_INCLUDED
-endif
-
-#export KERNELDIR = /opt/oe/stuff/build/tmp/work/beagleboard-angstrom-linux-gnueabi/linux-omap-2.6.29-r44/git/
-export TI_PLATFORM ?= omap3
-SUPPORT_ANDROID_PLATFORM ?= 1
+export KERNELDIR = /opt/oe/stuff/build/tmp/work/beagleboard-angstrom-linux-gnueabi/linux-omap-2.6.29-r44/git/
export KERNEL_PATH=$(KERNELDIR)
export KERNEL_SRC=$(KERNELDIR)
export KBUILD_EXTRA_SYMBOLS = `pwd`/services4/srvkm/env/linux/kbuild/Module.symvers
+OMAP_KERNEL_VER := $(shell grep "^VERSION = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_REL := $(shell grep "^PATCHLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_SUBREL := $(shell grep "^SUBLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+
+OMAP_KERNEL_AT_LEAST_2_6_29 := $(shell test $(OMAP_KERNEL_VER) -ge 2 -a \
+ $(OMAP_KERNEL_REL) -ge 6 -a \
+ $(OMAP_KERNEL_SUBREL) -ge 29 && echo 1 || echo 0)
+
+ifeq ($(OMAP_KERNEL_AT_LEAST_2_6_29),1)
+SUPPORT_OMAP3430_OMAPFB3 = 1
+SUPPORT_LINUX_USING_WORKQUEUES = 1
+SYS_CFLAGS += -DPVR_HAS_BROKEN_OMAPFB_H
+endif
+OPTIM = -Os
+
+
SGXCORE = 530
-ifeq ($(TI_PLATFORM),ti8168)
-CORE = -DPLAT_TI8168 -DSGX530 -DSUPPORT_SGX530 -DSGX_CORE_REV=125
+ifeq ($(TI_PLATFORM),ti81xx)
+CORE = -DPLAT_TI81xx -DSGX530 -DSUPPORT_SGX530 -DSGX_CORE_REV=125
else
ifeq ($(TI_PLATFORM),omap3630)
CORE = -DSGX530 -DSUPPORT_SGX530 -DSGX_CORE_REV=125
else
+ifeq ($(TI_PLATFORM),omap3)
+ifeq ($(OMAPES),3.x)
CORE = -DSGX530 -DSUPPORT_SGX530 -DSGX_CORE_REV=121
+else
+CORE = -DSGX530 -DSUPPORT_SGX530 -DSGX_CORE_REV=103
+endif
+endif
endif
endif
+
SUPPORT_SGX = 1
SUPPORT_HW_RECOVERY = 1
SUPPORT_SGX_HWPERF = 1
# passive power management isn't enabled, the driver won't see the
# system suspend/resume events, and so won't take appropriate action.
ifeq ($(LDM_PLATFORM),1)
-SUPPORT_ACTIVE_POWER_MANAGEMENT ?= 1
+ifeq ($(TI_PLATFORM),ti81xx)
+SUPPORT_ACTIVE_POWER_MANAGEMENT ?= 0
+else
+SUPPORT_ACTIVE_POWER_MANAGEMENT = 1
+endif
else
SUPPORT_ACTIVE_POWER_MANAGEMENT = 0
endif
+
+PVRSRV_MODNAME ?= pvrsrvkm
+
+SYS_CFLAGS += -DPVRSRV_MODNAME="\"$(PVRSRV_MODNAME)"\"
+
+
+
export PVR_BUILD_DIR := $(shell pwd)
DATE := $(shell date "+%a %B %d %Z %Y" )
CFLAGS.release = $(OPTIM) -g
CFLAGS = $(CFLAGS.$(BUILD))
+ifeq ($(EXTRA_EXTRA_WARNINGS),1)
+EXTRA_WARNINGS=1
+endif
+ifeq ($(EXTRA_WARNINGS),1)
+CCFLAGS_KERNEL +=
+ifeq ($(EXTRA_EXTRA_WARNINGS),1)
+CCFLAGS_KERNEL += -Wwrite-strings
+endif
+endif
+
+CCFLAGS_KERNEL += -Wall -Wdeclaration-after-statement -Wpointer-arith
+CCFLAGS_KERNEL += -Wmissing-format-attribute -Wno-format-zero-length
+CCFLAGS_KERNEL += -Wmissing-prototypes -Wstrict-prototypes
+
+
+CCFLAGS := $(CCFLAGS_KERNEL) -Wunused-parameter
+
+
+CCFLAGS_HOST := $(CCFLAGS)
+CCFLAGS += -W -Wno-missing-field-initializers
+CCFLAGS_KERNEL += -Wno-unused-parameter -Wno-sign-compare
+
+ifneq ($(SUPPORT_DRI_DRM_EXT),1)
+ifeq ($(EXTRA_WARNINGS),1)
+SYS_CFLAGS += -Wno-error
+else
+CCFLAGS_KERNEL += -Werror
+endif
+endif
+
+CPPFLAGS = -W -Wall -Wmissing-format-attribute -Wpointer-arith
+CPPFLAGS += -Wno-missing-field-initializers
+
+
+
ifeq ("$(BUILD)", "debug")
DEBUG_LINUX_MEMORY_ALLOCATIONS ?= 1
PVRSRV_DEBUG_OS_MEMORY ?= 0
endif
-SUPPORT_SECURE_FD_EXPORT = 1
-ifeq ($(SUPPORT_DRI_DRM),1)
-SUPPORT_SECURE_FD_EXPORT = 0
+SUPPORT_XORG ?= 0
+ifneq ($(SUPPORT_XORG),1)
+SUPPORT_XWS ?= 1
+XWS_SERVER_ONLY ?= 0
+else
+SUPPORT_XWS = 0
+XWS_SERVER_ONLY = 0
+SUPPORT_EWS = 0
endif
-PVR_PROC_USE_SEQ_FILE ?= 1
-TRANSFER_QUEUE ?= 1
-SUPPORT_SGX_EVENT_OBJECT ?=1
-SUPPORT_SECURE_HANDLES = 1
-SUPPORT_SRVINIT = 1
-SUPPORT_PERCONTEXT_PB = 1
-SUPPORT_LINUX_X86_PAT ?=1
-SUPPORT_LINUX_X86_WRITECOMBINE ?=1
-SUPPORT_SGX_LOW_LATENCY_SCHEDULING ?=1
+SUPPORT_DRI_DRM ?= $(SUPPORT_XORG)
+SUPPORT_SECURE_DRM_AUTH_EXPORT ?= $(SUPPORT_XORG)
+SUPPORT_DRI_DRM_EXT ?= 0
+SUPPORT_LIBDRM_LITE ?= 0
-SUPPORT_CPU_CACHED_BUFFERS ?= 0
+ifeq ($(SUPPORT_EWS),1)
+SUPPORT_SECURE_FD_EXPORT ?= 1
+else
+SUPPORT_SECURE_FD_EXPORT ?= 0
+endif
+
+
+
+
+TRANSFER_QUEUE ?= 1
+SUPPORT_SGX_EVENT_OBJECT ?= 1
+SUPPORT_SECURE_HANDLES = 1
+SUPPORT_SECURE_FD_EXPORT = 1
+SUPPORT_SRVINIT = 1
+SUPPORT_PERCONTEXT_PB = 1
+DISABLE_SGX_PB_GROW_SHRINK ?= 1
+SUPPORT_LINUX_X86_PAT ?=1
+SUPPORT_LINUX_X86_WRITECOMBINE ?=1
+SUPPORT_SGX_LOW_LATENCY_SCHEDULING ?=1
+
+SUPPORT_OMAP3430_SGXFCLK_96M ?= 0
+SUPPORT_OMAP3430_OMAPFB3 ?= 0
-SUPPORT_CACHEFLUSH_ON_ALLOC ?= 0
SUPPORT_MEMINFO_IDS ?= 0
+SUPPORT_PVR_PDP_LINUX_FB ?= $(SUPPORT_XWS)
+
SUPPORT_LINUX_USING_WORKQUEUES ?= 1
+ifeq ($(SUPPORT_OMAP3430_OMAPFB3),1)
+SUPPORT_LINUX_USING_WORKQUEUES = 1
+endif
+
+SUPPORT_SGX_NEW_STATUS_VALS ?= 1
+
+DC_NOHW_WIDTH ?= 640
+DC_NOHW_HEIGHT ?= 480
+
+DISPLAY_CONTROLLER ?=
+SYS_CFLAGS += -DSERVICES4 -D_XOPEN_SOURCE=600 -D_POSIX_C_SOURCE=199309 -DPVR2D_VALIDATE_INPUT_PARAMS
-SYS_CFLAGS += -DSERVICES4 -D_XOPEN_SOURCE=600 -DPVR2D_VALIDATE_INPUT_PARAMS
+#SYS_CFLAGS += -DSERVICES4 -D_XOPEN_SOURCE=600 -DPVR2D_VALIDATE_INPUT_PARAMS
# Thread support
USE_PTHREADS ?= 1
# Automatically define C compiler macros for features possible (or not) in use.
SYS_CFLAGS.$(SUPPORT_SRVINIT) += -DSUPPORT_SRVINIT
-
+SYS_CFLAGS.$(SUPPORT_VGX) += -DSUPPORT_VGX
SYS_CFLAGS.$(SUPPORT_SGX) += -DSUPPORT_SGX
SYS_CFLAGS.$(SUPPORT_XWS) += -DSUPPORT_XWS
SYS_CFLAGS.$(PDUMP) += -DPDUMP
+SYS_CFLAGS.$(VGX_PDUMP_FROM_FIRMWARE) += -DVGX_PDUMP_FROM_FIRMWARE
+SYS_CFLAGS.$(OVG_ALWAYS_CONVERT_DATA) += -DOVG_ALWAYS_CONVERT_DATA
+
SYS_CFLAGS.$(SUPPORT_POWER_MANAGEMENT) += -DSUPPORT_POWER_MANAGEMENT
SYS_CFLAGS.$(SUPPORT_BUFFER_CLASS) += -DSUPPORT_BUFFER_CLASS
SYS_CFLAGS.$(SUPPORT_PERCONTEXT_PB) += -DSUPPORT_PERCONTEXT_PB
SYS_CFLAGS.$(SUPPORT_DYNAMIC_PBRESIZE) += -DSUPPORT_DYNAMIC_PBRESIZE
+SYS_CFLAGS.$(DISABLE_SGX_PB_GROW_SHRINK) += -DDISABLE_SGX_PB_GROW_SHRINK
SYS_CFLAGS.$(USE_FBDEV) += -DUSE_FBDEV
SYS_CFLAGS.$(USE_FBDEV) += -DFBDEV_NAME="\"$(FBDEV_NAME)\""
SYS_CFLAGS.$(DEBUG_BRIDGE_KM) += -DDEBUG_BRIDGE_KM
SYS_CFLAGS.$(DEBUG_TRACE_BRIDGE_KM) += -DDEBUG_TRACE_BRIDGE_KM
SYS_CFLAGS.$(DEBUG_BRIDGE_KM_DISPATCH_TABLE) += -DDEBUG_BRIDGE_KM_DISPATCH_TABLE
-SYS_CFLAGS.$(PVRSRV_LOG_MEMORY_ALLOCS) += -DPVRSRV_LOG_MEMORY_ALLOCS
-SYS_CFLAGS.$(PVRSRV_DEBUG_OS_MEMORY) += -DPVRSRV_DEBUG_OS_MEMORY
-SYS_CFLAGS.$(DEBUG_MESA_OGL_TRACE) += -DDEBUG_MESA_OGL_TRACE
+
+SYS_CFLAGS.$(PVRSRV_LOG_MEMORY_ALLOCS) += -DPVRSRV_LOG_MEMORY_ALLOCS
+SYS_CFLAGS.$(PVRSRV_DEBUG_OS_MEMORY) += -DPVRSRV_DEBUG_OS_MEMORY
+SYS_CFLAGS.$(DEBUG_MESA_OGL_TRACE) += -DDEBUG_MESA_OGL_TRACE
+
SYS_CFLAGS.$(SUPPORT_LINUX_X86_WRITECOMBINE) += -DSUPPORT_LINUX_X86_WRITECOMBINE
SYS_CFLAGS.$(TRANSFER_QUEUE) += -DTRANSFER_QUEUE
SYS_CFLAGS.$(SUPPORT_SGX_MMU_DUMMY_PAGE) += -DSUPPORT_SGX_MMU_DUMMY_PAGE
-SYS_CFLAGS.$(PVRSRV_DUMP_MK_TRACE) += -DPVRSRV_DUMP_MK_TRACE
+SYS_CFLAGS.$(PVRSRV_DUMP_MK_TRACE) += -DPVRSRV_DUMP_MK_TRACE
+SYS_CFLAGS.$(PVRSRV_DUMP_KERNEL_CCB) += -DPVRSRV_DUMP_KERNEL_CCB
+SYS_CFLAGS.$(EDM_USSE_HWDEBUG) += -DEDM_USSE_HWDEBUG
+
+
SYS_CFLAGS.$(PVRSRV_USSE_EDM_STATUS_DEBUG) += -DPVRSRV_USSE_EDM_STATUS_DEBUG
-SYS_CFLAGS.$(USE_SUPPORT_STATUSVALS_DEBUG) += -DUSE_SUPPORT_STATUSVALS_DEBUG
-SYS_CFLAGS.$(SGX_FAST_DPM_INIT) += -DSGX_FAST_DPM_INIT
-SYS_CFLAGS.$(SGX_DISABLE_UKERNEL_SECONDARY_STATE) += -DSGX_DISABLE_UKERNEL_SECONDARY_STATE
-SYS_CFLAGS.$(DBGBREAK_ON_SPM) += -DDBGBREAK_ON_SPM
-SYS_CFLAGS.$(PVR_DBG_BREAK_ASSERT_FAIL) += -DPVR_DBG_BREAK_ASSERT_FAIL
+SYS_CFLAGS.$(USE_SUPPORT_STATUSVALS_DEBUG) += -DUSE_SUPPORT_STATUSVALS_DEBUG
+SYS_CFLAGS.$(SGX_FAST_DPM_INIT) += -DSGX_FAST_DPM_INIT
+SYS_CFLAGS.$(SGX_DISABLE_UKERNEL_SECONDARY_STATE) += -DSGX_DISABLE_UKERNEL_SECONDARY_STATE
+SYS_CFLAGS.$(DBGBREAK_ON_SPM) += -DDBGBREAK_ON_SPM
+SYS_CFLAGS.$(PVR_DBG_BREAK_ASSERT_FAIL) += -DPVR_DBG_BREAK_ASSERT_FAIL
+
+SYS_CFLAGS.$(PVRSRV_RESET_ON_HWTIMEOUT) += -DPVRSRV_RESET_ON_HWTIMEOUT
+SYS_CFLAGS.$(PVRSRV_CLIENT_RESET_ON_HWTIMEOUT) += -DPVRSRV_CLIENT_RESET_ON_HWTIMEOUT
+SYS_CFLAGS.$(NO_HARDWARE) += -DNO_HARDWARE
+
+
-SYS_CFLAGS.$(NO_HARDWARE) += -DNO_HARDWARE
SYS_CFLAGS.$(SUPPORT_DRI_DRM) += -DSUPPORT_DRI_DRM
-SYS_CFLAGS.$(SUPPORT_DRI_DRM_EXT) += -DSUPPORT_DRI_DRM_EXT
-SYS_CFLAGS.$(USE_PRIMARY_SURFACE_IN_FLIP_CHAIN) += -DUSE_PRIMARY_SURFACE_IN_FLIP_CHAIN
+SYS_CFLAGS.$(SUPPORT_DRI_DRM_EXT) += -DSUPPORT_DRI_DRM_EXT
+SYS_CFLAGS.$(SUPPORT_LIBDRM_LITE) += -DSUPPORT_LIBDRM_LITE
-SYS_CFLAGS.$(SYS_USING_INTERRUPTS) += -DSYS_USING_INTERRUPTS
-SYS_CFLAGS.$(SUPPORT_HW_RECOVERY) += -DSUPPORT_HW_RECOVERY
-SYS_CFLAGS.$(SUPPORT_ACTIVE_POWER_MANAGEMENT) += -DSUPPORT_ACTIVE_POWER_MANAGEMENT
+ifneq ("$(NO_HARDWARE)", "1")
+SYS_CFLAGS.$(SYS_USING_INTERRUPTS) += -DSYS_USING_INTERRUPTS
+SYS_CFLAGS.$(SUPPORT_HW_RECOVERY) += -DSUPPORT_HW_RECOVERY
+SYS_CFLAGS.$(SUPPORT_ACTIVE_POWER_MANAGEMENT) += -DSUPPORT_ACTIVE_POWER_MANAGEMENT
+endif
ifeq ("$(PDUMP)", "1")
SUPPORT_DBGDRV_EVENT_OBJECTS ?=1
-SYS_CFLAGS.$(SUPPORT_DBGDRV_EVENT_OBJECTS) += -DSUPPORT_DBGDRV_EVENT_OBJECTS
+SYS_CFLAGS.$(SUPPORT_DBGDRV_EVENT_OBJECTS) += -DSUPPORT_DBGDRV_EVENT_OBJECTS
+SYS_CFLAGS.$(PDUMP_DEBUG_OUTFILES) += -DPDUMP_DEBUG_OUTFILES
endif
+
+
+SYS_CFLAGS.$(SYS_USING_INTERRUPTS) += -DSYS_USING_INTERRUPTS
+SYS_CFLAGS.$(SUPPORT_HW_RECOVERY) += -DSUPPORT_HW_RECOVERY
+SYS_CFLAGS.$(SUPPORT_ACTIVE_POWER_MANAGEMENT) += -DSUPPORT_ACTIVE_POWER_MANAGEMENT
+
SYS_CFLAGS.$(SUPPORT_SECURE_HANDLES) += -DPVR_SECURE_HANDLES
SYS_CFLAGS.$(SUPPORT_SECURE_FD_EXPORT) += -DPVR_SECURE_FD_EXPORT
+SYS_CFLAGS.$(SUPPORT_SECURE_DRM_AUTH_EXPORT) += -DPVR_SECURE_DRM_AUTH_EXPORT
SYS_CFLAGS.$(USE_PTHREADS) += -DUSE_PTHREADS
SYS_CFLAGS.$(USE_GCC__thread_KEYWORD) += -DUSE_GCC__thread_KEYWORD
SYS_CFLAGS.$(SUPPORT_SGX_LOW_LATENCY_SCHEDULING) += -DSUPPORT_SGX_LOW_LATENCY_SCHEDULING
+SYS_CFLAGS.$(SUPPORT_SLC) += -DSGX_FEATURE_SYSTEM_CACHE
+SYS_CFLAGS.$(BYPASS_SLC) += -DSGX_BYPASS_SYSTEM_CACHE
+SYS_CFLAGS.$(BYPASS_DCU) += -DSGX_BYPASS_DCU
+SYS_CFLAGS.$(SUPPORT_SGX_LOW_LATENCY_SCHEDULING) += -DSUPPORT_SGX_LOW_LATENCY_SCHEDULING
+SYS_CFLAGS.$(SGX_SUPPORT_VDM_TIMER_BASED_SWITCHING) += -DSGX_SUPPORT_VDM_TIMER_BASED_SWITCHING
+SYS_CFLAGS.$(SGX_SUPPORT_ISP_TIMER_BASED_SWITCHING) += -DSGX_SUPPORT_ISP_TIMER_BASED_SWITCHING
+
+
SYS_CFLAGS.$(SUPPORT_LINUX_X86_PAT) += -DSUPPORT_LINUX_X86_PAT
-SYS_CFLAGS.$(SUPPORT_CPU_CACHED_BUFFERS) += -DSUPPORT_CPU_CACHED_BUFFERS
-SYS_CFLAGS.$(SUPPORT_CACHE_LINE_FLUSH) += -DSUPPORT_CACHE_LINE_FLUSH
+SYS_CFLAGS.$(SUPPORT_TI_PM) += -DSUPPORT_TI_PM
-SYS_CFLAGS.$(SUPPORT_CACHEFLUSH_ON_ALLOC) += -DSUPPORT_CACHEFLUSH_ON_ALLOC
-SYS_CFLAGS.$(SUPPORT_MEMINFO_IDS) += -DSUPPORT_MEMINFO_IDS
+SYS_CFLAGS.$(SUPPORT_OMAP3430_SGXFCLK_96M) += -DSUPPORT_OMAP3430_SGXFCLK_96M
+SYS_CFLAGS.$(SUPPORT_OMAP3430_OMAPFB3) += -DSUPPORT_OMAP3430_OMAPFB3
-SYS_CFLAGS.$(SUPPORT_SGX_EDM_MEMORY_DEBUG) += -DSUPPORT_SGX_EDM_MEMORY_DEBUG
+SYS_CFLAGS.$(SUPPORT_CACHEFLUSH_ON_ALLOC) += -DSUPPORT_CACHEFLUSH_ON_ALLOC
+SYS_CFLAGS.$(SUPPORT_MEMINFO_IDS) += -DSUPPORT_MEMINFO_IDS
-SYS_CFLAGS.$(SUPPORT_ANDROID_PLATFORM) += -DSUPPORT_ANDROID_PLATFORM -DANDROID
-SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DSUPPORT_GRAPHICS_HAL
-SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DGRALLOC_VARIANT="\"$(GRALLOC_VARIANT)\""
+SYS_CFLAGS.$(SUPPORT_SGX_EDM_MEMORY_DEBUG) += -DSUPPORT_SGX_EDM_MEMORY_DEBUG
-SYS_CFLAGS += -DDEBUG_LOG_PATH_TRUNCATE=\"$(EURASIAROOT)\"
-SYS_CFLAGS.$(PVR_PROC_USE_SEQ_FILE) += -DPVR_PROC_USE_SEQ_FILE
+SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DSUPPORT_GRAPHICS_HAL
+SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DGRALLOC_VARIANT="\"$(GRALLOC_VARIANT)\""
-SYS_CFLAGS.$(SUPPORT_LINUX_USING_WORKQUEUES) += -DPVR_LINUX_USING_WORKQUEUES \
+SYS_CFLAGS.$(SUPPORT_EGL_IMAGE_SYNC_DEPENDENCY) += -DSUPPORT_EGL_IMAGE_SYNC_DEPENDENCY
+SYS_CFLAGS.$(SUPPORT_PVR_PDP_LINUX_FB) += -DPVR_PDP_LINUX_FB
+
+#SYS_CFLAGS.$(SUPPORT_LINUX_USING_WORKQUEUES) += -DPVR_LINUX_USING_WORKQUEUES \
-DPVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE
+SYS_CFLAGS.$(SUPPORT_LINUX_USING_WORKQUEUES) += -DPVR_LINUX_USING_WORKQUEUES \
+ -DPVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE \
+ -DPVR_LINUX_TIMERS_USING_WORKQUEUES \
+ -DSYS_CUSTOM_POWERLOCK_WRAP
+
+
+
+SYS_CFLAGS.$(SUPPORT_SGX_NEW_STATUS_VALS) += -DSUPPORT_SGX_NEW_STATUS_VALS
+
+ifneq ("$(DISPLAY_CONTROLLER)", "")
+SYS_CFLAGS += -DDISPLAY_CONTROLLER=$(DISPLAY_CONTROLLER)
+endif
+
+ifeq ("$(PVR_SYSTEM)", "sgx_nohw")
+ifndef RTSIM
+SYS_CFLAGS += -DNO_HARDWARE
+endif
+SYS_CFLAGS += -DDC_NOHW_BUFFER_WIDTH=$(DC_NOHW_WIDTH) -DDC_NOHW_BUFFER_HEIGHT=$(DC_NOHW_HEIGHT)
+endif
+
+ifeq ("$(PVR_SYSTEM)", "vgx_nohw")
+SYS_CFLAGS += -DNO_HARDWARE -DDC_NOHW_BUFFER_WIDTH=$(DC_NOHW_WIDTH) -DDC_NOHW_BUFFER_HEIGHT=$(DC_NOHW_HEIGHT)
+endif
+
+SYS_CFLAGS += -DDEBUG_LOG_PATH_TRUNCATE=\"$(EURASIAROOT)\"
+
+SYS_INCLUDES = -I$(EURASIAROOT)/include4 \
+ -I$(EURASIAROOT)/eurasiacon/includeext \
+ -I$(SYSBIN) \
+ -isystem $(KERNELDIR)/include
+
-SYS_CFLAGS.$(SUPPORT_TI_PM) += -DSUPPORT_TI_PM
export ALL_CFLAGS = -DLINUX \
$(CBUILD) $(CBUILD.$(BUILD)) \
$(SYS_CFLAGS) $(SYS_CFLAGS.1) \
$(MODULE_CFLAGS) $(MODULE_CFLAGS.$(BUILD)) \
- $(CORE) \
+ $(CORE) -fno-strict-aliasing -Wno-pointer-arith \
$(CFLAGS)
all:
$(MAKE) -C $(KERNELDIR) M=`pwd` $*
clean:
- $(MAKE) -C $(KERNELDIR) M=`pwd` clean
+ @find . -name "*.o" -exec rm -r {} \;
+ @find . -name "*.ko" -exec rm -r {} \;
+
--- /dev/null
+/*
+ * EGL 1.0 FUNCTIONS
+ */
+eglChooseConfig
+eglCopyBuffers
+eglCreateContext
+eglCreatePbufferSurface
+eglCreatePixmapSurface
+eglCreateWindowSurface
+eglDestroyContext
+eglDestroySurface
+eglGetConfigAttrib
+eglGetConfigs
+eglGetCurrentContext
+eglGetCurrentDisplay
+eglGetCurrentSurface
+eglGetDisplay
+eglGetError
+eglGetProcAddress
+eglInitialize
+eglMakeCurrent
+eglQueryContext
+eglQueryString
+eglQuerySurface
+eglSwapBuffers
+eglTerminate
+eglWaitGL
+eglWaitNative
+
+/*
+ * EGL 1.1 FUNCTIONS
+ */
+eglBindTexImage
+eglSwapInterval
+eglReleaseTexImage
+eglSurfaceAttrib
--- /dev/null
+^_init
+^_fini
+^__data_start
+^__aeabi_f2ulz
--- /dev/null
+#include "egl.txt"
+
+/*
+ * EGL 1.2/1.3 FUNCTIONS
+ */
+eglCreatePbufferFromClientBuffer
+eglBindAPI
+eglQueryAPI
+eglWaitClient
+eglReleaseThread
--- /dev/null
+#include "egl.txt"
+#include "libGLESv1_CM.so.txt"
--- /dev/null
+/*
+ * OPENGLES 1.0 COMMON LITE FUNCTIONS
+ */
+glActiveTexture
+glAlphaFuncx
+glBindTexture
+glBlendFunc
+glClear
+glClearColorx
+glClearDepthx
+glClearStencil
+glClientActiveTexture
+glColor4x
+glColorMask
+glColorPointer
+glCompressedTexImage2D
+glCompressedTexSubImage2D
+glCopyTexImage2D
+glCopyTexSubImage2D
+glCullFace
+glDeleteTextures
+glDepthFunc
+glDepthMask
+glDepthRangex
+glDisable
+glDisableClientState
+glDrawArrays
+glDrawElements
+glEnable
+glEnableClientState
+glFinish
+glFlush
+glFogx
+glFogxv
+glFrontFace
+glFrustumx
+glGenTextures
+glGetError
+glGetIntegerv
+glGetString
+glHint
+glLightModelx
+glLightModelxv
+glLightx
+glLightxv
+glLineWidthx
+glLoadIdentity
+glLoadMatrixx
+glLogicOp
+glMaterialx
+glMaterialxv
+glMatrixMode
+glMultMatrixx
+glMultiTexCoord4x
+glNormal3x
+glNormalPointer
+glOrthox
+glPixelStorei
+glPointSizex
+glPolygonOffsetx
+glPopMatrix
+glPushMatrix
+glReadPixels
+glRotatex
+glSampleCoveragex
+glScalex
+glScissor
+glShadeModel
+glStencilFunc
+glStencilMask
+glStencilOp
+glTexCoordPointer
+glTexEnvx
+glTexEnvxv
+glTexImage2D
+glTexParameterx
+glTexSubImage2D
+glTranslatex
+glVertexPointer
+glViewport
+
+/*
+ * OPENGLES 1.1 COMMON LITE FUNCTIONS
+ */
+glBindBuffer
+glBufferData
+glBufferSubData
+glClipPlanex
+glColor4ub
+glDeleteBuffers
+glGetBooleanv
+glGetBufferParameteriv
+glGetClipPlanex
+glGenBuffers
+glGetFixedv
+glGetLightxv
+glGetMaterialxv
+glGetPointerv
+glGetTexEnviv
+glGetTexEnvxv
+glGetTexParameteriv
+glGetTexParameterxv
+glIsBuffer
+glIsEnabled
+glIsTexture
+glPointParameterx
+glPointParameterxv
+glPointSizePointerOES
+glTexEnvi
+glTexParameteri
+glTexParameteriv
+glTexParameterxv
+glTexEnviv
--- /dev/null
+#include "libGLESv1_CL.so.txt"
+
+/*
+ * OPENGLES 1.0 COMMON FUNCTIONS
+ */
+glAlphaFunc
+glClearColor
+glClearDepthf
+glColor4f
+glDepthRangef
+glFogf
+glFogfv
+glFrustumf
+glLightModelf
+glLightModelfv
+glLightf
+glLightfv
+glLineWidth
+glLoadMatrixf
+glMaterialf
+glMaterialfv
+glMultMatrixf
+glMultiTexCoord4f
+glNormal3f
+glOrthof
+glPointSize
+glPolygonOffset
+glRotatef
+glSampleCoverage
+glScalef
+glTexEnvf
+glTexEnvfv
+glTexParameterf
+glTranslatef
+
+/*
+ * OPENGLES 1.1 COMMON FUNCTIONS
+ */
+glClipPlanef
+glGetClipPlanef
+glGetFloatv
+glGetLightfv
+glGetMaterialfv
+glGetTexEnvfv
+glGetTexParameterfv
+glPointParameterf
+glPointParameterfv
+glTexParameterfv
--- /dev/null
+/*
+ * OGLES 2.0 core functions
+ */
+glActiveTexture
+glAttachShader
+glBindAttribLocation
+glBindBuffer
+glBindFramebuffer
+glBindRenderbuffer
+glBindTexture
+glBlendColor
+glBlendEquation
+glBlendEquationSeparate
+glBlendFunc
+glBlendFuncSeparate
+glBufferData
+glBufferSubData
+glCheckFramebufferStatus
+glClear
+glClearColor
+glClearDepthf
+glClearStencil
+glColorMask
+glCompileShader
+glCompressedTexImage2D
+glCompressedTexSubImage2D
+glCopyTexImage2D
+glCopyTexSubImage2D
+glCreateProgram
+glCreateShader
+glCullFace
+glDeleteBuffers
+glDeleteTextures
+glDeleteProgram
+glDeleteFramebuffers
+glDeleteRenderbuffers
+glDeleteShader
+glDetachShader
+glDepthFunc
+glDepthMask
+glDepthRangef
+glDisable
+glDisableVertexAttribArray
+glDrawArrays
+glDrawElements
+glEnable
+glEnableVertexAttribArray
+glFinish
+glFlush
+glFramebufferTexture2D
+glFramebufferRenderbuffer
+glFrontFace
+glGetActiveAttrib
+glGetActiveUniform
+glGetAttachedShaders
+glGetAttribLocation
+glGetBooleanv
+glGetBufferParameteriv
+glGenBuffers
+glGenerateMipmap
+glGenFramebuffers
+glGenRenderbuffers
+glGenTextures
+glGetError
+glGetFloatv
+glGetFramebufferAttachmentParameteriv
+glGetIntegerv
+glGetProgramiv
+glGetProgramInfoLog
+glGetRenderbufferParameteriv
+glGetShaderiv
+glGetShaderInfoLog
+glGetShaderPrecisionFormat
+glGetShaderSource
+glGetString
+glGetTexParameteriv
+glGetTexParameterfv
+glGetUniformfv
+glGetUniformiv
+glGetUniformLocation
+glGetVertexAttribfv
+glGetVertexAttribiv
+glGetVertexAttribPointerv
+glHint
+glIsBuffer
+glIsEnabled
+glIsFramebuffer
+glIsProgram
+glIsRenderbuffer
+glIsShader
+glIsTexture
+glLineWidth
+glLinkProgram
+glPixelStorei
+glPolygonOffset
+glReadPixels
+glReleaseShaderCompiler
+glRenderbufferStorage
+glSampleCoverage
+glScissor
+glShaderBinary
+glShaderSource
+glStencilFunc
+glStencilFuncSeparate
+glStencilMask
+glStencilMaskSeparate
+glStencilOp
+glStencilOpSeparate
+glTexImage2D
+glTexParameteri
+glTexParameterf
+glTexParameteriv
+glTexParameterfv
+glTexSubImage2D
+glUniform1i
+glUniform2i
+glUniform3i
+glUniform4i
+glUniform1f
+glUniform2f
+glUniform3f
+glUniform4f
+glUniform1iv
+glUniform2iv
+glUniform3iv
+glUniform4iv
+glUniform1fv
+glUniform2fv
+glUniform3fv
+glUniform4fv
+glUniformMatrix2fv
+glUniformMatrix3fv
+glUniformMatrix4fv
+glUseProgram
+glValidateProgram
+glVertexAttrib1f
+glVertexAttrib2f
+glVertexAttrib3f
+glVertexAttrib4f
+glVertexAttrib1fv
+glVertexAttrib2fv
+glVertexAttrib3fv
+glVertexAttrib4fv
+glVertexAttribPointer
+glViewport
--- /dev/null
+/*
+ * IMGEGL FUNCTIONS
+ */
+IMGeglBindAPI
+IMGeglBindTexImage
+IMGeglChooseConfig
+IMGeglCopyBuffers
+IMGeglCreateContext
+IMGeglCreatePbufferFromClientBuffer
+IMGeglCreatePbufferSurface
+IMGeglCreatePixmapSurface
+IMGeglCreateWindowSurface
+IMGeglDestroyContext
+IMGeglDestroySurface
+IMGeglGetConfigAttrib
+IMGeglGetConfigs
+IMGeglGetCurrentContext
+IMGeglGetCurrentDisplay
+IMGeglGetCurrentSurface
+IMGeglGetDisplay
+IMGeglGetError
+IMGeglGetProcAddress
+IMGeglInitialize
+IMGeglMakeCurrent
+IMGeglQueryAPI
+IMGeglQueryContext
+IMGeglQueryString
+IMGeglQuerySurface
+IMGeglReleaseTexImage
+IMGeglReleaseThread
+IMGeglSurfaceAttrib
+IMGeglSwapBuffers
+IMGeglSwapInterval
+IMGeglTerminate
+IMGeglWaitClient
+IMGeglWaitGL
+IMGeglWaitNative
+
+KEGLBindImage
+KEGLCreateRenderSurface
+KEGLDestroyRenderSurface
+KEGLGetDrawableParameters
+KEGLGetImageSource
+KEGLResizeRenderSurface
+KEGLSurfaceBind
+KEGLSurfaceUnbind
+KEGLUnbindImage
+
+#if defined(DEBUG)
+KEGLAllocDeviceMemTrack
+KEGLFreeDeviceMemTrack
+#endif /* defined(DEBUG) */
+
--- /dev/null
+/*
+ * OpenVG core functions
+ */
+vgAppendPath
+vgAppendPathData
+vgChildImage
+vgClear
+vgClearGlyph
+vgClearImage
+vgClearPath
+vgColorMatrix
+vgConvolve
+vgCopyImage
+vgCopyMask
+vgCopyPixels
+vgCreateFont
+vgCreateImage
+vgCreateMaskLayer
+vgCreatePaint
+vgCreatePath
+vgDestroyFont
+vgDestroyImage
+vgDestroyMaskLayer
+vgDestroyPaint
+vgDestroyPath
+vgDrawGlyph
+vgDrawGlyphs
+vgDrawImage
+vgDrawPath
+vgFillMaskLayer
+vgFinish
+vgFlush
+vgGaussianBlur
+vgGetColor
+vgGetError
+vgGetImageSubData
+vgGetMatrix
+vgGetPaint
+vgGetParameterVectorSize
+vgGetParameterf
+vgGetParameterfv
+vgGetParameteri
+vgGetParameteriv
+vgGetParent
+vgGetPathCapabilities
+vgGetPixels
+vgGetString
+vgGetVectorSize
+vgGetf
+vgGetfv
+vgGeti
+vgGetiv
+vgHardwareQuery
+vgImageSubData
+vgInterpolatePath
+vgLoadIdentity
+vgLoadMatrix
+vgLookup
+vgLookupSingle
+vgMask
+vgModifyPathCoords
+vgMultMatrix
+vgPaintPattern
+vgPathBounds
+vgPathLength
+vgPathTransformedBounds
+vgPointAlongPath
+vgReadPixels
+vgRemovePathCapabilities
+vgRenderToMask
+vgRotate
+vgScale
+vgSeparableConvolve
+vgSetColor
+vgSetGlyphToImage
+vgSetGlyphToPath
+vgSetPaint
+vgSetParameterf
+vgSetParameterfv
+vgSetParameteri
+vgSetParameteriv
+vgSetPixels
+vgSetf
+vgSetfv
+vgSeti
+vgSetiv
+vgShear
+vgTransformPath
+vgTranslate
+vgWritePixels
--- /dev/null
+/*
+ * OpenVG utility functions
+ */
+vguArc
+vguComputeWarpQuadToQuad
+vguComputeWarpQuadToSquare
+vguComputeWarpSquareToQuad
+vguEllipse
+vguLine
+vguPolygon
+vguRect
+vguRoundRect
--- /dev/null
+/*
+ * PVRSCOPESERVICES FUNCTIONS
+ */
+pvrssGetProcAddress
--- /dev/null
+/* $Revision: 1.5 $ */
+EWSAtomName
+EWSBlitWindow
+EWSClearEventQueue
+EWSCloseDisplay
+EWSCreateWindow
+EWSDefaultErrorHandler
+EWSDestroyWindow
+EWSEventsQueued
+EWSFrameComplete
+EWSGetProperty
+EWSGetPropertyEx
+EWSGetRestrictedProperty
+EWSGetSurfaceInfo
+EWSInternAtom
+EWSListProperties
+EWSListPropertiesEx
+EWSListRestrictedProperties
+EWSListWindows
+EWSLockBuffer
+EWSNextEvent
+EWSNextEventIfAvailable
+EWSNextQueuedEvent
+EWSNoOp
+EWSOpenDisplay
+EWSPackCoord
+EWSPackPixelFormat
+EWSPackSize
+EWSPackZOrder
+EWSPeekEvent
+EWSPeekEventIfAvailable
+EWSPropertyLength
+EWSPropertyLengthEx
+EWSRegisterEventHandler
+EWSRestrictedPropertyLength
+EWSServerRunning
+EWSSetErrorHandler
+EWSSetProperty
+EWSSetPropertyEx
+EWSSetRestrictedProperty
+EWSUnlockBuffer
+EWSUnpackCoord
+EWSUnpackPixelFormat
+EWSUnpackSize
+EWSUnpackZOrder
+EWSUnregisterEventHandler
+EWSValidDisplay
+EWSWriteProperty
+EWSWritePropertyEx
+EWSWriteRestrictedProperty
--- /dev/null
+/*
+ * GLSL compiler functions
+ */
+GLSLCompileToUniflex
+GLSLFreeCompiledUniflexProgram
+GLSLInitCompiler
+GLSLDisplayMetrics
+GLSLShutDownCompiler
+SGXBS_CreateBinaryProgram
--- /dev/null
+/*
+ * PVR2D FUNCTIONS
+ */
+PVR2DBlt
+PVR2DBlt3D
+PVR2DBlt3DExt
+PVR2DBltClipped
+PVR2DCreateDeviceContext
+PVR2DCreateFlipChain
+PVR2DDestroyDeviceContext
+PVR2DDestroyFlipChain
+PVR2DEnumerateDevices
+PVR2DFreeUseCode
+PVR2DGetAPIRev
+PVR2DGetDeviceInfo
+PVR2DGetFlipChainBuffers
+PVR2DGetFrameBuffer
+PVR2DGetScreenMode
+PVR2DLoadUseCode
+PVR2DMemAlloc
+PVR2DMemFree
+PVR2DMemWrap
+PVR2DMemExport
+PVR2DPresentBlt
+PVR2DPresentFlip
+PVR2DQueryBlitsComplete
+PVR2DSetPresentBltProperties
+PVR2DSetPresentFlipProperties
+PVR2DMemMap
+PVR2DSet1555Alpha
+PVR2DGetMiscDisplayInfo
--- /dev/null
+/* $Revision: 1.1 $ */
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+#include "wsegl.txt"
--- /dev/null
+/*
+ * SERVICES_UM FUNCTIONS
+ */
+PVRSRVAcquireDeviceData
+PVRSRVAllocDeviceMem
+PVRSRVAllocUserModeMem
+PVRSRVCallocUserModeMem
+PVRSRVClientEvent
+PVRSRVClockus
+PVRSRVCloseBCDevice
+PVRSRVCloseDCDevice
+PVRSRVConnect
+PVRSRVCreateAppHintState
+PVRSRVCreateDCSwapChain
+PVRSRVCreateDeviceMemContext
+PVRSRVCreateMutex
+PVRSRVDestroyDCSwapChain
+PVRSRVDestroyDeviceMemContext
+PVRSRVDestroyMutex
+PVRSRVDisconnect
+PVRSRVEnumDCDims
+PVRSRVEnumDCFormats
+PVRSRVEnumerateDeviceClass
+PVRSRVEnumerateDevices
+PVRSRVEventObjectWait
+PVRSRVFreeAppHintState
+PVRSRVFreeDeviceMem
+PVRSRVFreeUserModeMem
+PVRSRVGetAppHint
+PVRSRVGetBCBuffer
+PVRSRVGetBCBufferInfo
+PVRSRVGetDCBuffers
+PVRSRVGetDCInfo
+PVRSRVGetDCSystemBuffer
+PVRSRVGetLibFuncAddr
+PVRSRVGetMiscInfo
+PVRSRVInitSrvConnect
+PVRSRVInitSrvDisconnect
+PVRSRVLoadLibrary
+PVRSRVLockMutex
+PVRSRVMapDeviceClassMemory
+PVRSRVMapPhysToUserSpace
+PVRSRVMemCopy
+PVRSRVMemSet
+PVRSRVCreateSyncInfoModObj
+PVRSRVDestroySyncInfoModObj
+PVRSRVModifyCompleteSyncOps
+PVRSRVModifyPendingSyncOps
+PVRSRVSyncOpsFlushToModObj
+PVRSRVSyncOpsFlushToDelta
+PVRSRVAllocSyncInfo
+PVRSRVFreeSyncInfo
+PVRSRVOpenBCDevice
+PVRSRVOpenDCDevice
+PVRSRVReallocUserModeMem
+PVRSRVReleaseMiscInfo
+PVRSRVReleaseThreadQuanta
+PVRSRVSetDCDstColourKey
+PVRSRVSetDCDstRect
+PVRSRVSetDCSrcColourKey
+PVRSRVSetDCSrcRect
+PVRSRVSwapToDCBuffer
+PVRSRVSwapToDCSystem
+PVRSRVUnloadLibrary
+PVRSRVUnlockMutex
+PVRSRVUnmapDeviceClassMemory
+PVRSRVUnmapPhysToUserSpace
+PVRSRVUnwrapExtMemory
+PVRSRVWaitus
+PVRSRVWrapExtMemory
+PVRSRVPollForValue
+PVRSRVGetErrorString
+PVRSRVGetCurrentProcessID
+PVRSRVMapDeviceMemory
+PVRSRVUnmapDeviceMemory
+PVRSRVExportDeviceMem
+PVRSRVSetLocale
+
+#if defined(PDUMP)
+
+PVRSRVPDumpBitmap
+PVRSRVPDumpComment
+PVRSRVPDumpCommentf
+PVRSRVPDumpCommentWithFlagsf
+PVRSRVPDumpCycleCountRegRead
+PVRSRVPDumpDriverInfo
+PVRSRVPDumpInit
+PVRSRVPDumpIsCapturing
+PVRSRVPDumpIsCapturingTest
+PVRSRVPDumpMem
+PVRSRVPDumpMemPol
+PVRSRVPDumpPDDevPAddr
+PVRSRVPDumpReg
+PVRSRVPDumpRegPol
+PVRSRVPDumpRegPolWithFlags
+PVRSRVPDumpRegRead
+PVRSRVPDumpSetFrame
+PVRSRVPDumpStartInitPhase
+PVRSRVPDumpStopInitPhase
+PVRSRVPDumpSync
+PVRSRVPDumpSyncPol
+
+#if !defined(SUPPORT_VGX)
+PVRSRVPDumpBufferArray
+#endif
+
+#endif /* PDUMP */
+
+#if defined(DEBUG)
+PVRSRVAllocUserModeMemTracking
+PVRSRVCallocUserModeMemTracking
+PVRSRVReallocUserModeMemTracking
+PVRSRVFreeUserModeMemTracking
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+PVRSRVInitProfileOutput
+PVRSRVDeInitProfileOutput
+PVRSRVMetricsGetCPUFreq
+PVRSRVMetricsTimeNow
+PVRSRVProfileOutput
+PVRSRVGetTimerRegister
+PVRSRVReleaseTimerRegister
+#endif
+
+#if defined(SUPPORT_SGX)
+
+SGX2DQueryBlitsComplete
+SGXAddRenderTarget
+SGXCreateRenderContext
+SGXCreateTransferContext
+SGXDestroyRenderContext
+SGXDestroyTransferContext
+SGXDevInitPart2
+SGXGetClientInfo
+SGXGetInfoForSrvInit
+SGXGetMiscInfo
+SGXKickTA
+SGXQueueTransfer
+SGXReleaseClientInfo
+SGXRemoveRenderTarget
+SGXScheduleProcessQueues
+SGXSetContextPriority
+
+SGXReadHWPerfCB
+
+#endif /* SUPPORT_SGX */
+
+#if defined(SUPPORT_VGX)
+
+VGXActivateFrameContext
+VGXCreateRenderContext
+VGXDestroyRenderContext
+VGXDevInitPart2
+VGXDMAUnitDelete
+#if defined(PDUMP) && defined(VGX_PDUMP_FROM_FIRMWARE)
+VGXDMAUnitDequeueItem
+#endif
+VGXDMAUnitDiscardScene
+VGXDMAUnitEndOfPath
+VGXDMAUnitEndOfScene
+VGXDMAUnitFlush
+VGXDMAUnitNew
+VGXDMAUnitQueueItem
+VGXDMAUnitQueueRawItem
+VGXGetClientInfo
+VGXGetInfoForSrvInit
+VGXGetMiscInfo
+VGXReleaseClientInfo
+VGXCreateRenderTarget
+VGXDestroyRenderTarget
+VGXScheduleProcessQueues
+
+#endif /* SUPPORT_VGX */
+
+#if defined(SUPPORT_DRI_DRM_NO_LIBDRM)
+drmClose
+drmCommandNone
+drmCommandWrite
+drmDropMaster
+drmIoctl
+drmModeAddFB
+drmModeSetCrtc
+drmOpen
+#endif
+
+/* Policy copied from pvr_debug.h
+ *
+ * Horrible to have this here but we can't use the header
+ * because it has some non-preprocessor stuff in it.
+ */
+
+#if !defined(PVRSRV_NEED_PVR_ASSERT) && defined(DEBUG)
+#define PVRSRV_NEED_PVR_ASSERT
+#endif
+
+#if defined(PVRSRV_NEED_PVR_ASSERT) && !defined(PVRSRV_NEED_PVR_DPF)
+#define PVRSRV_NEED_PVR_DPF
+#endif
+
+#if !defined(PVRSRV_NEED_PVR_TRACE) && (defined(DEBUG) || defined(TIMING))
+#define PVRSRV_NEED_PVR_TRACE
+#endif
+
+#if defined(PVRSRV_NEED_PVR_ASSERT)
+PVRSRVDebugAssertFail
+#endif
+
+#if defined(PVRSRV_NEED_PVR_DPF)
+PVRSRVDebugPrintf
+#endif
+
+#if defined(PVRSRV_NEED_PVR_TRACE)
+PVRSRVTrace
+#endif
--- /dev/null
+/*
+ * USC functions
+ */
+PVRUniFlexCreateContext
+PVRUniFlexInitInst
+
+#if defined(OUTPUT_USCHW)
+#if !defined(GPGPU)
+PVRUniFlexCompileToHw
+PVRCleanupUniflexHw
+#else
+GpgpuPVRUniFlexCompileToHw
+#endif /* #if !defined(GPGPU) */
+#endif /* #if defined(OUTPUT_USCHW) */
+
+#if defined(OUTPUT_USPBIN)
+PVRUniFlexCompileToUspBin
+PVRUniFlexDestroyUspBin
+#endif /* #if defined(OUTPUT_USPBIN) */
+
+PVRUniFlexDestroyContext
+
+#if defined(UF_TESTBENCH) || defined(DEBUG) || defined(PDUMP)
+PVRUniFlexDecodeInputInst
+PVRUniFlexDecodeIteration
+#endif /* #if defined(UF_TESTBENCH) || defined(DEBUG) || defined(PDUMP) */
+
+PVRUniFlexGetInputInstDesc
--- /dev/null
+WSEGL_GetFunctionTablePointer
#
include $(EURASIAROOT)/eurasiacon/build/linux/makefile.shared_conf
+KBUILD_SUBDIRS =
+
+ifeq ($(SUPPORT_DRI_DRM_NOT_PCI),1)
+KBUILD_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/linux_drm
+endif
ifeq ($(PDUMP),1)
ifneq ($(SUPPORT_DRI_DRM),1)
-PDUMP_SUBDIRS += $(EURASIAROOT)/tools/intern/debug/dbgdriv/linux
+KBUILD_SUBDIRS += $(EURASIAROOT)/tools/intern/debug/dbgdriv/linux
endif
endif
-KBUILD_SUBDIRS = \
- $(PDUMP_SUBDIRS) \
+KBUILD_SUBDIRS += \
$(EURASIAROOT)/services4/srvkm/env/linux \
$(EXTRA_SUBDIRS)
$(MODULE)-objs = $(SOURCES:.c=.o)
-EXTRA_CFLAGS = $(INCLUDES) \
- $(ALL_CFLAGS_kbuild) \
- -Wall -fno-strict-aliasing
-
-ifneq ($(PVR_KBUILD_IN_KERNEL),1)
-ifneq ($(SUPPORT_DRI_DRM_EXT),1)
- EXTRA_CFLAGS += -Werror
-endif
-endif
+EXTRA_CFLAGS = $(INCLUDES) $(ALL_CFLAGS_kbuild)
ifneq ($(PVR_KBUILD_IN_KERNEL),1)
ifeq ($(SILENT),@)
#
#
#
+# --- Revision Logs Removed ---
+#
##################################################################################
# ENV is used in a few other makefiles instead of the literal 'linux', for
CC= $(CROSS_COMPILE)gcc
ifdef QAC_ANALYSE
-ifneq ("$(CROSS_COMPILE)","")
-CC= perl "$(ANALROOT)/wrapper.pl -wcf $(ANALROOT)/eurasia_linux.cfg $(CROSS_COMPILE)gcc"
-endif
+export QAC_SYS_INC_PATH ?= $(shell $(CROSS_COMPILE)gcc -print-file-name=include)
+
+#ifneq ("$(CROSS_COMPILE)","")
+#CC= perl "$(ANALROOT)/wrapper.pl -wcf $(ANALROOT)/eurasia_linux.cfg $(CROSS_COMPILE)gcc"
+#endif
endif
-CAT ?= cat
-CP ?= cp
+CAT ?= cat
+CP ?= cp
CHMOD ?= chmod
-DOS2UNIX ?= dos2unix
+CUT ?= cut
+DIFF ?= diff
ECHO ?= -@echo
+ENV ?= env
FIND ?= find
GREP ?= grep
-LN ?= ln -s
+LN ?= ln -s
+NM ?= nm
MKDIR ?= mkdir -p
-MV ?= mv
-RM ?= rm -f
-SED ?= sed
-M4 ?= m4
+MV ?= mv
+RM ?= rm -f
+SED ?= sed
+M4 ?= m4
TOUCH ?= touch
PERL ?= perl
SORT ?= sort
FLEX ?= flex
BISON ?= bison
MD5SUM ?= md5sum
-ENV ?= env
-CUT ?= cut
+GAWK ?= gawk
+
+# The `dos2unix' package is missing from Ubuntu 10.04. Additionally,
+# the tofrodos package no longer provides the dos2unix symlink.
+#
+DOS2UNIX ?= \
+ $(shell if [ -z `which fromdos` ]; then echo dos2unix; else echo fromdos -p; fi)
# SILENT=@ causes command text to be omitted during the process. If you want
# to see what's really happening then use "make SILENT= ..."
#
BUILD ?= release
+# Services module name
+PVRSRV_MODNAME ?= pvrsrvkm
+
+SYS_CFLAGS += -DPVRSRV_MODNAME="\"$(PVRSRV_MODNAME)"\"
+
# Services version.
#
SERVICES ?= 4
# so instead we supply pvrversion.h. We produce pvrversion.h if
# if doesn't exist.
#
-DATE := $(shell date "+%a %B %d %Z %Y" )
+DATE := $(shell date +%Y-%m-%d)
EURASIACON_PJ = $(EURASIAROOT)/eurasiacon.pj
PVRVERSION_H = $(EURASIAROOT)/include$(SERVICES)/pvrversion.h
PVRVERSION = $(shell if [ -f $(EURASIACON_PJ) ]; then \
$(KERNELDIR)/Makefile | $(CUT) -f3 -d' ')
KERNEL_SUBREL = $(shell grep "^SUBLEVEL = " \
$(KERNELDIR)/Makefile | $(CUT) -f3 -d' ')
+
+KERNEL_EXTRAVER = $(shell grep "^EXTRAVERSION = " \
+ $(KERNELDIR)/Makefile | $(CUT) -f3 -d' ')
+
+KERNELVERSION = $(KERNEL_VER).$(KERNEL_REL).$(KERNEL_SUBREL)
+
KERNEL_ID ?= $(shell grep -h '\#define UTS_RELEASE' $(KERNELDIR)/include/linux/* | \
$(CUT) -f3 -d' ' | \
$(SED) s/\"//g)
-KERNELVERSION = $(KERNEL_VER).$(KERNEL_REL).$(KERNEL_SUBREL)
+ifeq ("$(KERNEL_ID)", "")
+# For Linux 2.6.33, the above method of finding the KERNEL ID no longer
+# works, as UTS_RELEASE is no longer defined anywhere.
+KERNEL_ID := $(KERNELVERSION)$(KERNEL_EXTRAVER)
+endif
# Get checksum from env variables
#
-DPVR_BUILD_TYPE="\"$(BUILD)\""
# Don't support HW recovery on debug builds
-CBUILD.debug = -DDEBUG_PVR
+CBUILD.debug = -DDEBUG
CBUILD.timing = -DTIMING
CBUILD.release = -DRELEASE
CFLAGS.debug = -g -O0 -DDLL_METRIC=1
CFLAGS.timing = $(OPTIM) -g -DDLL_METRIC=1 -DTIMING
CFLAGS.release = $(OPTIM) -g
+# If either EXTRA_WARNINGS or EXTRA_EXTRA_WARNINGS are enabled,
+# modify the base flags (CCFLAGS_KERNEL).
+#
+ifeq ($(EXTRA_EXTRA_WARNINGS),1)
+EXTRA_WARNINGS=1
+endif
+ifeq ($(EXTRA_WARNINGS),1)
+CCFLAGS_KERNEL +=
+ifeq ($(EXTRA_EXTRA_WARNINGS),1)
+CCFLAGS_KERNEL += -Wwrite-strings
+endif
+endif
+
+# These flags are enabled unconditionally for both UM/KM parts.
+#
+CCFLAGS_KERNEL += -Wall -Wdeclaration-after-statement -Wpointer-arith
+CCFLAGS_KERNEL += -Wmissing-format-attribute -Wno-format-zero-length
+CCFLAGS_KERNEL += -Wmissing-prototypes -Wstrict-prototypes
+
+# These are just for UM builds.
+#
+CCFLAGS := $(CCFLAGS_KERNEL) -Wunused-parameter
+
+# Snapshot host flags without -W -Wno-missing-field-initializers
+# FIXME: Temporary workaround for ancient centos4 toolchain..
+#
+CCFLAGS_HOST := $(CCFLAGS)
+
+# Our platform guides require the use of either GCC 4.2 for x86,
+# or GCC 4.3 for ARM. Both of these compilers support "-W
+# -Wno-missing-field-initializers", and support switching off each
+# of the warnings -W enables.
+#
+# Because earlier GCCs don't support these flags, or don't support
+# them properly, we can't enable them for kernel builds because
+# there may be bugs in kernel headers which we can't work around.
+#
+CCFLAGS += -W -Wno-missing-field-initializers
+
+# These flags are used to work around kernel header bugs.
+#
+CCFLAGS_KERNEL += -Wno-unused-parameter -Wno-sign-compare
+
+# We have no control over errors in external sources, so no
+# additional error checking if SUPPORT_DRI_DRM_EXT is set.
+#
+ifneq ($(SUPPORT_DRI_DRM_EXT),1)
+# If EXTRA_WARNINGS are enabled, we don't want any -Werror
+# to cause the build to fail, so turn it back off again.
+#
+# Otherwise, turn Werror on for all kernel module builds.
+#
+ifeq ($(EXTRA_WARNINGS),1)
+SYS_CFLAGS += -Wno-error
+else
+CCFLAGS_KERNEL += -Werror
+endif
+endif
+
+# CPPFLAGS are default compiler flags for C++ (subset of C flags)
+#
+CPPFLAGS = -W -Wall -Wmissing-format-attribute -Wpointer-arith
+CPPFLAGS += -Wno-missing-field-initializers
+
# Defaults for useful things.
#
PVRSRV_DEBUG_OS_MEMORY ?= 0
endif
+SUPPORT_XORG ?= 0
+ifneq ($(SUPPORT_XORG),1)
+SUPPORT_XWS ?= 1
+XWS_SERVER_ONLY ?= 0
+else
+SUPPORT_XWS = 0
+XWS_SERVER_ONLY = 0
+SUPPORT_EWS = 0
+endif
+
SUPPORT_DRI_DRM ?= $(SUPPORT_XORG)
SUPPORT_DRI_DRM_EXT ?= 0
+SUPPORT_DRI_DRM_NOT_PCI ?= 0
+SUPPORT_DRI_DRM_NO_DROPMASTER ?= 0
+SUPPORT_SECURE_DRM_AUTH_EXPORT ?= $(SUPPORT_XORG)
-SUPPORT_SECURE_FD_EXPORT = 1
+ifeq ($(SUPPORT_EWS),1)
+SUPPORT_SECURE_FD_EXPORT ?= 1
+else
+SUPPORT_SECURE_FD_EXPORT ?= 0
+endif
+
+SUPPORT_DRI_DRM_NO_LIBDRM ?= 0
+ifneq ($(SUPPORT_XORG),1)
ifeq ($(SUPPORT_DRI_DRM),1)
-SUPPORT_SECURE_FD_EXPORT = 0
+SUPPORT_DRI_DRM_NO_LIBDRM = 1
+endif
endif
-PVR_PROC_USE_SEQ_FILE ?= 1
TRANSFER_QUEUE ?= 1
SUPPORT_SGX_EVENT_OBJECT ?=1
SUPPORT_SECURE_HANDLES = 1
SUPPORT_SRVINIT = 1
SUPPORT_PERCONTEXT_PB = 1
+DISABLE_SGX_PB_GROW_SHRINK ?= 0
SUPPORT_LINUX_X86_PAT ?=1
SUPPORT_LINUX_X86_WRITECOMBINE ?=1
SUPPORT_SGX_LOW_LATENCY_SCHEDULING ?=1
-SUPPORT_OMAP3430_SGXFCLK_96M ?= 0
-SUPPORT_OMAP3430_OMAPFB3 ?= 0
+ifeq ($(SUPPORT_XORG),1)
+SUPPORT_PDUMP_MULTI_PROCESS = 1
+endif
-SUPPORT_CPU_CACHED_BUFFERS ?= 0
+SUPPORT_OMAP3430_SGXFCLK_96M ?= 0
-SUPPORT_CACHEFLUSH_ON_ALLOC ?= 0
SUPPORT_MEMINFO_IDS ?= 0
+SUPPORT_PVR_PDP_LINUX_FB ?= $(SUPPORT_XWS)
+
+SUPPORT_LINUX_USING_WORKQUEUES ?= 0
+SUPPORT_LINUX_USING_SHARED_WORKQUEUES ?= 0
+ifeq ($(SUPPORT_LINUX_USING_WORKQUEUES),1)
+SUPPORT_LINUX_USING_SHARED_WORKQUEUES = 0
+endif
+
+SUPPORT_SGX_NEW_STATUS_VALS ?= 1
+
DC_NOHW_WIDTH ?= 640
DC_NOHW_HEIGHT ?= 480
DISPLAY_CONTROLLER ?=
-SYS_CFLAGS += -DSERVICES4 -D_XOPEN_SOURCE=600 -DPVR2D_VALIDATE_INPUT_PARAMS
+SUPPORT_DYNAMIC_GTF_TIMING ?= 0
+SYS_CFLAGS += -DSERVICES4 -D_XOPEN_SOURCE=600 -D_POSIX_C_SOURCE=199309 -DPVR2D_VALIDATE_INPUT_PARAMS
# Thread support
USE_PTHREADS ?= 1
SYS_CFLAGS.$(SUPPORT_EWS) += -DSUPPORT_EWS
SYS_CFLAGS.$(PDUMP) += -DPDUMP
SYS_CFLAGS.$(VGX_PDUMP_FROM_FIRMWARE) += -DVGX_PDUMP_FROM_FIRMWARE
+SYS_CFLAGS.$(OVG_ALWAYS_CONVERT_DATA) += -DOVG_ALWAYS_CONVERT_DATA
SYS_CFLAGS.$(SUPPORT_POWER_MANAGEMENT) += -DSUPPORT_POWER_MANAGEMENT
SYS_CFLAGS.$(SUPPORT_BUFFER_CLASS) += -DSUPPORT_BUFFER_CLASS
SYS_CFLAGS.$(SUPPORT_PERCONTEXT_PB) += -DSUPPORT_PERCONTEXT_PB
-SYS_CFLAGS.$(SUPPORT_DYNAMIC_PBRESIZE) += -DSUPPORT_DYNAMIC_PBRESIZE
+SYS_CFLAGS.$(DISABLE_SGX_PB_GROW_SHRINK) += -DDISABLE_SGX_PB_GROW_SHRINK
SYS_CFLAGS.$(USE_FBDEV) += -DUSE_FBDEV
SYS_CFLAGS.$(USE_FBDEV) += -DFBDEV_NAME="\"$(FBDEV_NAME)\""
SYS_CFLAGS.$(SUPPORT_SGX_MMU_DUMMY_PAGE) += -DSUPPORT_SGX_MMU_DUMMY_PAGE
SYS_CFLAGS.$(PVRSRV_DUMP_MK_TRACE) += -DPVRSRV_DUMP_MK_TRACE
+SYS_CFLAGS.$(PVRSRV_DUMP_KERNEL_CCB) += -DPVRSRV_DUMP_KERNEL_CCB
+SYS_CFLAGS.$(EDM_USSE_HWDEBUG) += -DEDM_USSE_HWDEBUG
SYS_CFLAGS.$(PVRSRV_USSE_EDM_STATUS_DEBUG) += -DPVRSRV_USSE_EDM_STATUS_DEBUG
SYS_CFLAGS.$(USE_SUPPORT_STATUSVALS_DEBUG) += -DUSE_SUPPORT_STATUSVALS_DEBUG
SYS_CFLAGS.$(DBGBREAK_ON_SPM) += -DDBGBREAK_ON_SPM
SYS_CFLAGS.$(PVR_DBG_BREAK_ASSERT_FAIL) += -DPVR_DBG_BREAK_ASSERT_FAIL
+SYS_CFLAGS.$(PVRSRV_RESET_ON_HWTIMEOUT) += -DPVRSRV_RESET_ON_HWTIMEOUT
+SYS_CFLAGS.$(PVRSRV_CLIENT_RESET_ON_HWTIMEOUT) += -DPVRSRV_CLIENT_RESET_ON_HWTIMEOUT
SYS_CFLAGS.$(NO_HARDWARE) += -DNO_HARDWARE
SYS_CFLAGS.$(SUPPORT_DRI_DRM) += -DSUPPORT_DRI_DRM
SYS_CFLAGS.$(SUPPORT_DRI_DRM_EXT) += -DSUPPORT_DRI_DRM_EXT
+SYS_CFLAGS.$(SUPPORT_DRI_DRM_NOT_PCI) += -DPVR_DRI_DRM_NOT_PCI
+SYS_CFLAGS.$(SUPPORT_DRI_DRM_NO_DROPMASTER) += -DSUPPORT_DRI_DRM_NO_DROPMASTER
+SYS_CFLAGS.$(SUPPORT_DRI_DRM_NO_LIBDRM) += -DSUPPORT_DRI_DRM_NO_LIBDRM
+SYS_CFLAGS.$(DRM_PVR_RESERVED_INTEL_ORDER) += -DDRM_PVR_RESERVED_INTEL_ORDER
+SYS_CFLAGS.$(DRM_PVR_USE_INTEL_FB) += -DDRM_PVR_USE_INTEL_FB
+
+
SYS_CFLAGS.$(USE_PRIMARY_SURFACE_IN_FLIP_CHAIN) += -DUSE_PRIMARY_SURFACE_IN_FLIP_CHAIN
ifneq ("$(NO_HARDWARE)", "1")
ifeq ("$(PDUMP)", "1")
SUPPORT_DBGDRV_EVENT_OBJECTS ?=1
SYS_CFLAGS.$(SUPPORT_DBGDRV_EVENT_OBJECTS) += -DSUPPORT_DBGDRV_EVENT_OBJECTS
+SYS_CFLAGS.$(PDUMP_DEBUG_OUTFILES) += -DPDUMP_DEBUG_OUTFILES
+SYS_CFLAGS.$(SUPPORT_PDUMP_MULTI_PROCESS) += -DSUPPORT_PDUMP_MULTI_PROCESS
endif
SYS_CFLAGS.$(SUPPORT_SECURE_HANDLES) += -DPVR_SECURE_HANDLES
SYS_CFLAGS.$(SUPPORT_SECURE_FD_EXPORT) += -DPVR_SECURE_FD_EXPORT
+SYS_CFLAGS.$(SUPPORT_SECURE_DRM_AUTH_EXPORT) += -DPVR_SECURE_DRM_AUTH_EXPORT
SYS_CFLAGS.$(USE_PTHREADS) += -DUSE_PTHREADS
SYS_CFLAGS.$(USE_GCC__thread_KEYWORD) += -DUSE_GCC__thread_KEYWORD
SYS_CFLAGS.$(SUPPORT_SLC) += -DSGX_FEATURE_SYSTEM_CACHE
SYS_CFLAGS.$(BYPASS_SLC) += -DSGX_BYPASS_SYSTEM_CACHE
+SYS_CFLAGS.$(BYPASS_DCU) += -DSGX_BYPASS_DCU
SYS_CFLAGS.$(SUPPORT_SGX_LOW_LATENCY_SCHEDULING) += -DSUPPORT_SGX_LOW_LATENCY_SCHEDULING
-
+SYS_CFLAGS.$(SGX_SUPPORT_VDM_TIMER_BASED_SWITCHING) += -DSGX_SUPPORT_VDM_TIMER_BASED_SWITCHING
+SYS_CFLAGS.$(SGX_SUPPORT_ISP_TIMER_BASED_SWITCHING) += -DSGX_SUPPORT_ISP_TIMER_BASED_SWITCHING
SYS_CFLAGS.$(SUPPORT_LINUX_X86_PAT) += -DSUPPORT_LINUX_X86_PAT
SYS_CFLAGS.$(SUPPORT_OMAP3430_SGXFCLK_96M) += -DSUPPORT_OMAP3430_SGXFCLK_96M
-SYS_CFLAGS.$(SUPPORT_OMAP3430_OMAPFB3) += -DSUPPORT_OMAP3430_OMAPFB3
-
-SYS_CFLAGS.$(SUPPORT_CPU_CACHED_BUFFERS) += -DSUPPORT_CPU_CACHED_BUFFERS
-SYS_CFLAGS.$(SUPPORT_CACHE_LINE_FLUSH) += -DSUPPORT_CACHE_LINE_FLUSH
-
-
SYS_CFLAGS.$(SUPPORT_CACHEFLUSH_ON_ALLOC) += -DSUPPORT_CACHEFLUSH_ON_ALLOC
SYS_CFLAGS.$(SUPPORT_MEMINFO_IDS) += -DSUPPORT_MEMINFO_IDS
SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DSUPPORT_GRAPHICS_HAL
SYS_CFLAGS.$(SUPPORT_GRAPHICS_HAL) += -DGRALLOC_VARIANT="\"$(GRALLOC_VARIANT)\""
+SYS_CFLAGS.$(SUPPORT_EGL_IMAGE_SYNC_DEPENDENCY) += -DSUPPORT_EGL_IMAGE_SYNC_DEPENDENCY
+
+SYS_CFLAGS.$(SUPPORT_PVR_PDP_LINUX_FB) += -DPVR_PDP_LINUX_FB
+
+SYS_CFLAGS.$(SUPPORT_LINUX_USING_WORKQUEUES) += \
+ -DPVR_LINUX_USING_WORKQUEUES \
+ -DPVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE \
+ -DPVR_LINUX_TIMERS_USING_WORKQUEUES \
+ -DSYS_CUSTOM_POWERLOCK_WRAP
+
+SYS_CFLAGS.$(SUPPORT_LINUX_USING_SHARED_WORKQUEUES) += \
+ -DPVR_LINUX_USING_WORKQUEUES \
+ -DPVR_LINUX_MISR_USING_WORKQUEUE \
+ -DPVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE \
+ -DSYS_CUSTOM_POWERLOCK_WRAP
+
+SYS_CFLAGS.$(SUPPORT_SGX_NEW_STATUS_VALS) += -DSUPPORT_SGX_NEW_STATUS_VALS
+
ifneq ("$(DISPLAY_CONTROLLER)", "")
SYS_CFLAGS += -DDISPLAY_CONTROLLER=$(DISPLAY_CONTROLLER)
endif
endif
SYS_CFLAGS += -DDEBUG_LOG_PATH_TRUNCATE=\"$(EURASIAROOT)\"
-SYS_CFLAGS.$(PVR_PROC_USE_SEQ_FILE) += -DPVR_PROC_USE_SEQ_FILE
SYS_INCLUDES = -I$(EURASIAROOT)/include4 \
-I$(EURASIAROOT)/eurasiacon/includeext \
-isystem $(KERNELDIR)/include
-ALL_CFLAGS_kbuild = -DLINUX \
+ALL_CFLAGS_kbuild = $(CCFLAGS_KERNEL) -DLINUX \
$(CBUILD) $(CBUILD.$(BUILD)) \
- $(SYS_CFLAGS) $(SYS_CFLAGS.1) \
$(MODULE_CFLAGS) $(MODULE_CFLAGS.$(BUILD)) \
- $(CORE) \
- -Wall -fno-strict-aliasing \
+ $(SYS_CFLAGS) $(SYS_CFLAGS.1) \
+ $(CORE) -fno-strict-aliasing -Wno-pointer-arith \
$(CFLAGS.$(BUILD))
+ifdef SUPPORT_DRI_DRM_NO_TTM
+export SUPPORT_DRI_DRM_NO_TTM
+endif
+
+ifdef SUPPORT_XORG_SENSOR_FRAMEWORK
+export SUPPORT_XORG_SENSOR_FRAMEWORK
+endif
+
+# If we do not specify direst path to external 3pdd sources, use tarball
+ifeq ($(MRST_DRIVER_SOURCE),)
+EXTERNAL_3PDD_TARBALL_PATH = $(EURASIAROOT)/eurasiacon/external/$(EXTERNAL_3PDD_TARBALL)
+export EXTERNAL_3PDD_TARBALL_PATH
+endif
+
--- /dev/null
+^__aeabi_
+^__exidx_
+^__data_start
+^_init
+^_fini
include ../../kbuild/Makefile.kbuild
-EXTRA_SUBDIRS = $(EURASIAROOT)/services4/3rdparty/dc_omap3430_linux \
- $(EURASIAROOT)/services4/3rdparty/bufferclass_example
+EXTRA_SUBDIRS =
+ifeq ($(SUPPORT_OMAP3430_OMAPFB3),1)
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/dc_omapfb3_linux
+else
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/dc_omap3430_linux
+endif
+
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/bufferclass_example
ifeq ("$(SGXCOREREV)","")
ifeq ("$(SGXCORE)","530")
-CORE += -DSGX_CORE_REV=125
+CORE += -DSGX_CORE_REV=121
else
CORE += -DUSE_SGX_CORE_REV_HEAD
endif
# Cross-compile extra settings.
#
-PVR_SYSTEM = omap3430
+PVR_SYSTEM = omap3
DISPLAY_CONTROLLER = omaplfb
ARCH_CFLAGS = -march=armv7-a
-DSYS_CUSTOM_POWERLOCK_WRAP
# The version of the kernel that is required for compilation
-REQUIREDKERNELVERSION = 2.6.24
+REQUIREDKERNELVERSION = 2.6.34
-#
-# OPTIM contains the optimisation level in timing and release builds
-OPTIM = -Os
-
-SGXCORE = 530
-SUPPORT_SGX = 1
-
-SUPPORT_HW_RECOVERY = 1
-SUPPORT_SGX_HWPERF = 1
-SYS_USING_INTERRUPTS = 1
-
-PVR2D_ALT_2DHW = 1
LDM_PLATFORM ?= 1
# Only enable active power management if passive power management is
else
SUPPORT_ACTIVE_POWER_MANAGEMENT = 0
endif
+
+OMAP_KERNEL_VER := $(shell grep "^VERSION = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_REL := $(shell grep "^PATCHLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_SUBREL := $(shell grep "^SUBLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+
+OMAP_KERNEL_AT_LEAST_2_6_29 := $(shell test $(OMAP_KERNEL_VER) -ge 2 -a \
+ $(OMAP_KERNEL_REL) -ge 6 -a \
+ $(OMAP_KERNEL_SUBREL) -ge 29 && echo 1 || echo 0)
+
+ifeq ($(OMAP_KERNEL_AT_LEAST_2_6_29),1)
+SUPPORT_OMAP3430_OMAPFB3 = 1
+SUPPORT_LINUX_USING_WORKQUEUES = 1
+SYS_CFLAGS += -DPVR_HAS_BROKEN_OMAPFB_H
+endif
+
+#
+# OPTIM contains the optimisation level in timing and release builds
+OPTIM = -Os
+
+SGXCORE = 530
+SUPPORT_SGX = 1
+
+SUPPORT_HW_RECOVERY = 1
+SUPPORT_SGX_HWPERF = 1
+SYS_USING_INTERRUPTS = 1
+
+PVR2D_ALT_2DHW = 1
include ../../kbuild/Makefile.kbuild
-EXTRA_SUBDIRS = $(EURASIAROOT)/services4/3rdparty/dc_omap3430_linux \
- $(EURASIAROOT)/services4/3rdparty/bufferclass_example
+EXTRA_SUBDIRS =
+ifeq ($(SUPPORT_OMAP3430_OMAPFB3),1)
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/dc_omapfb3_linux
+else
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/dc_omap3430_linux
+endif
+
+EXTRA_SUBDIRS += $(EURASIAROOT)/services4/3rdparty/bufferclass_example
-DSYS_CUSTOM_POWERLOCK_WRAP
# The version of the kernel that is required for compilation
-REQUIREDKERNELVERSION = 2.6.32
+REQUIREDKERNELVERSION = 2.6.37
-#
-# OPTIM contains the optimisation level in timing and release builds
-OPTIM = -Os
-
-SGXCORE = 530
-SUPPORT_SGX = 1
-
-SUPPORT_HW_RECOVERY = 1
-SUPPORT_SGX_HWPERF = 1
-SYS_USING_INTERRUPTS = 1
-
-PVR2D_ALT_2DHW = 1
LDM_PLATFORM ?= 1
# Only enable active power management if passive power management is
# passive power management isn't enabled, the driver won't see the
# system suspend/resume events, and so won't take appropriate action.
ifeq ($(LDM_PLATFORM),1)
-SUPPORT_ACTIVE_POWER_MANAGEMENT ?= 1
+SUPPORT_ACTIVE_POWER_MANAGEMENT ?= 0
else
SUPPORT_ACTIVE_POWER_MANAGEMENT = 0
endif
+
+OMAP_KERNEL_VER := $(shell grep "^VERSION = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_REL := $(shell grep "^PATCHLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+OMAP_KERNEL_SUBREL := $(shell grep "^SUBLEVEL = " \
+ $(KERNELDIR)/Makefile | cut -f3 -d' ')
+
+OMAP_KERNEL_AT_LEAST_2_6_29 := $(shell test $(OMAP_KERNEL_VER) -ge 2 -a \
+ $(OMAP_KERNEL_REL) -ge 6 -a \
+ $(OMAP_KERNEL_SUBREL) -ge 29 && echo 1 || echo 0)
+
+ifeq ($(OMAP_KERNEL_AT_LEAST_2_6_29),1)
+SUPPORT_OMAP3430_OMAPFB3 = 1
+SUPPORT_LINUX_USING_WORKQUEUES = 1
+SYS_CFLAGS += -DPVR_HAS_BROKEN_OMAPFB_H
+endif
+
+#
+# OPTIM contains the optimisation level in timing and release builds
+OPTIM = -Os
+
+SGXCORE = 530
+SUPPORT_SGX = 1
+
+SUPPORT_HW_RECOVERY = 1
+SUPPORT_SGX_HWPERF = 1
+SYS_USING_INTERRUPTS = 1
+
+PVR2D_ALT_2DHW = 1
#define DEBUG_FLAGS_USE_NONPAGED_MEM 0x00000001UL
#define DEBUG_FLAGS_NO_BUF_EXPANDSION 0x00000002UL
#define DEBUG_FLAGS_ENABLESAMPLE 0x00000004UL
+#define DEBUG_FLAGS_READONLY 0x00000008UL
+#define DEBUG_FLAGS_WRITEONLY 0x00000010UL
#define DEBUG_FLAGS_TEXTSTREAM 0x80000000UL
#define DEBUG_SERVICE_WRITELF CTL_CODE(FILE_DEVICE_UNKNOWN, DEBUG_SERVICE_IOCTL_BASE + 0x16, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define DEBUG_SERVICE_READLF CTL_CODE(FILE_DEVICE_UNKNOWN, DEBUG_SERVICE_IOCTL_BASE + 0x17, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define DEBUG_SERVICE_WAITFOREVENT CTL_CODE(FILE_DEVICE_UNKNOWN, DEBUG_SERVICE_IOCTL_BASE + 0x18, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define DEBUG_SERVICE_SETCONNNOTIFY CTL_CODE(FILE_DEVICE_UNKNOWN, DEBUG_SERVICE_IOCTL_BASE + 0x19, METHOD_BUFFERED, FILE_ANY_ACCESS)
typedef enum _DBG_EVENT_
DBG_EVENT_STREAM_DATA = 1
} DBG_EVENT;
+
typedef struct _DBG_IN_CREATESTREAM_
{
+ union
+ {
+ IMG_CHAR *pszName;
+ IMG_UINT64 ui64Name;
+ } u;
IMG_UINT32 ui32Pages;
IMG_UINT32 ui32CapMode;
IMG_UINT32 ui32OutMode;
- IMG_CHAR *pszName;
}DBG_IN_CREATESTREAM, *PDBG_IN_CREATESTREAM;
typedef struct _DBG_IN_FINDSTREAM_
{
+ union
+ {
+ IMG_CHAR *pszName;
+ IMG_UINT64 ui64Name;
+ }u;
IMG_BOOL bResetStream;
- IMG_CHAR *pszName;
}DBG_IN_FINDSTREAM, *PDBG_IN_FINDSTREAM;
typedef struct _DBG_IN_WRITESTRING_
{
- IMG_VOID *pvStream;
+ union
+ {
+ IMG_CHAR *pszString;
+ IMG_UINT64 ui64String;
+ } u;
+ IMG_SID hStream;
IMG_UINT32 ui32Level;
- IMG_CHAR *pszString;
}DBG_IN_WRITESTRING, *PDBG_IN_WRITESTRING;
typedef struct _DBG_IN_READSTRING_
{
- IMG_VOID *pvStream;
+ union
+ {
+ IMG_CHAR *pszString;
+ IMG_UINT64 ui64String;
+ } u;
+ IMG_SID hStream;
IMG_UINT32 ui32StringLen;
- IMG_CHAR *pszString;
} DBG_IN_READSTRING, *PDBG_IN_READSTRING;
typedef struct _DBG_IN_SETDEBUGMODE_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Mode;
IMG_UINT32 ui32Start;
IMG_UINT32 ui32End;
typedef struct _DBG_IN_SETDEBUGOUTMODE_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Mode;
} DBG_IN_SETDEBUGOUTMODE, *PDBG_IN_SETDEBUGOUTMODE;
typedef struct _DBG_IN_SETDEBUGLEVEL_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Level;
} DBG_IN_SETDEBUGLEVEL, *PDBG_IN_SETDEBUGLEVEL;
typedef struct _DBG_IN_SETFRAME_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Frame;
} DBG_IN_SETFRAME, *PDBG_IN_SETFRAME;
typedef struct _DBG_IN_WRITE_
{
- IMG_VOID *pvStream;
+ union
+ {
+ IMG_UINT8 *pui8InBuffer;
+ IMG_UINT64 ui64InBuffer;
+ } u;
+ IMG_SID hStream;
IMG_UINT32 ui32Level;
IMG_UINT32 ui32TransferSize;
- IMG_UINT8 *pui8InBuffer;
} DBG_IN_WRITE, *PDBG_IN_WRITE;
typedef struct _DBG_IN_READ_
{
- IMG_VOID *pvStream;
+ union
+ {
+ IMG_UINT8 *pui8OutBuffer;
+ IMG_UINT64 ui64OutBuffer;
+ } u;
+ IMG_SID hStream;
IMG_BOOL bReadInitBuffer;
IMG_UINT32 ui32OutBufferSize;
- IMG_UINT8 *pui8OutBuffer;
} DBG_IN_READ, *PDBG_IN_READ;
typedef struct _DBG_IN_OVERRIDEMODE_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Mode;
} DBG_IN_OVERRIDEMODE, *PDBG_IN_OVERRIDEMODE;
typedef struct _DBG_IN_ISCAPTUREFRAME_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_BOOL bCheckPreviousFrame;
} DBG_IN_ISCAPTUREFRAME, *PDBG_IN_ISCAPTUREFRAME;
typedef struct _DBG_IN_SETMARKER_
{
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Marker;
} DBG_IN_SETMARKER, *PDBG_IN_SETMARKER;
typedef struct _DBG_IN_WRITE_LF_
{
+ union
+ {
+ IMG_UINT8 *pui8InBuffer;
+ IMG_UINT64 ui64InBuffer;
+ } u;
IMG_UINT32 ui32Flags;
- IMG_VOID *pvStream;
+ IMG_SID hStream;
IMG_UINT32 ui32Level;
IMG_UINT32 ui32BufferSize;
- IMG_UINT8 *pui8InBuffer;
} DBG_IN_WRITE_LF, *PDBG_IN_WRITE_LF;
#define WRITELF_FLAGS_RESETBUF 0x00000001UL
+typedef struct _DBG_STREAM_CONTROL_
+{
+ IMG_BOOL bInitPhaseComplete;
+ IMG_UINT32 ui32Flags;
+
+ IMG_UINT32 ui32CapMode;
+ IMG_UINT32 ui32OutMode;
+ IMG_UINT32 ui32DebugLevel;
+ IMG_UINT32 ui32DefaultMode;
+ IMG_UINT32 ui32Start;
+ IMG_UINT32 ui32End;
+ IMG_UINT32 ui32Current;
+ IMG_UINT32 ui32SampleRate;
+ IMG_UINT32 ui32Reserved;
+} DBG_STREAM_CONTROL, *PDBG_STREAM_CONTROL;
typedef struct _DBG_STREAM_
{
struct _DBG_STREAM_ *psNext;
struct _DBG_STREAM_ *psInitStream;
- IMG_BOOL bInitPhaseComplete;
- IMG_UINT32 ui32Flags;
- IMG_UINT32 ui32Base;
+ DBG_STREAM_CONTROL *psCtrl;
+ IMG_BOOL bCircularAllowed;
+ IMG_PVOID pvBase;
IMG_UINT32 ui32Size;
IMG_UINT32 ui32RPtr;
IMG_UINT32 ui32WPtr;
IMG_UINT32 ui32DataWritten;
- IMG_UINT32 ui32CapMode;
- IMG_UINT32 ui32OutMode;
- IMG_UINT32 ui32DebugLevel;
- IMG_UINT32 ui32DefaultMode;
- IMG_UINT32 ui32Start;
- IMG_UINT32 ui32End;
- IMG_UINT32 ui32Current;
- IMG_UINT32 ui32Access;
- IMG_UINT32 ui32SampleRate;
- IMG_UINT32 ui32Reserved;
- IMG_UINT32 ui32Timeout;
- IMG_UINT32 ui32Marker;
+ IMG_UINT32 ui32Marker;
+ IMG_UINT32 ui32InitPhaseWOff;
+
+
+
+
IMG_CHAR szName[30];
} DBG_STREAM,*PDBG_STREAM;
+typedef struct _DBGKM_CONNECT_NOTIFIER_
+{
+ IMG_VOID (IMG_CALLCONV *pfnConnectNotifier) (IMG_VOID);
+} DBGKM_CONNECT_NOTIFIER, *PDBGKM_CONNECT_NOTIFIER;
+
typedef struct _DBGKM_SERVICE_TABLE_
{
IMG_UINT32 ui32Size;
IMG_UINT32 (IMG_CALLCONV *pfnGetStreamOffset) (PDBG_STREAM psStream);
IMG_VOID (IMG_CALLCONV *pfnSetStreamOffset) (PDBG_STREAM psStream, IMG_UINT32 ui32StreamOffset);
IMG_BOOL (IMG_CALLCONV *pfnIsLastCaptureFrame) (PDBG_STREAM psStream);
- IMG_VOID (IMG_CALLCONV *pfnWaitForEvent) (DBG_EVENT eEvent);
+ IMG_VOID (IMG_CALLCONV *pfnWaitForEvent) (DBG_EVENT eEvent);
+ IMG_VOID (IMG_CALLCONV *pfnSetConnectNotifier) (DBGKM_CONNECT_NOTIFIER fn_notifier);
+ IMG_UINT32 (IMG_CALLCONV *pfnWritePersist) (PDBG_STREAM psStream,IMG_UINT8 *pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level);
} DBGKM_SERVICE_TABLE, *PDBGKM_SERVICE_TABLE;
#if defined(__linux__) || defined(__METAG)
#define IMG_CALLCONV
- #define IMG_INTERNAL __attribute__ ((visibility ("hidden")))
- #define IMG_EXPORT
+ #define IMG_INTERNAL __attribute__((visibility("hidden")))
+ #define IMG_EXPORT __attribute__((visibility("default")))
#define IMG_IMPORT
#define IMG_RESTRICT __restrict__
#define IMG_CONST const
+#if defined(__GNUC__)
+#define IMG_FORMAT_PRINTF(x,y) __attribute__((format(printf,x,y)))
+#else
#define IMG_FORMAT_PRINTF(x,y)
+#endif
+
+#if defined (_WIN64)
+#define IMG_UNDEF (~0ULL)
+#else
+#define IMG_UNDEF (~0UL)
+#endif
#endif
typedef unsigned short IMG_UINT16, *IMG_PUINT16;
typedef signed short IMG_INT16, *IMG_PINT16;
+#if !defined(IMG_UINT32_IS_ULONG)
+typedef unsigned int IMG_UINT32, *IMG_PUINT32;
+typedef signed int IMG_INT32, *IMG_PINT32;
+#else
typedef unsigned long IMG_UINT32, *IMG_PUINT32;
typedef signed long IMG_INT32, *IMG_PINT32;
-
+#endif
#if !defined(IMG_UINT32_MAX)
#define IMG_UINT32_MAX 0xFFFFFFFFUL
#endif
IMG_FORCE_ALIGN = 0x7FFFFFFF
} IMG_BOOL, *IMG_PBOOL;
-typedef void IMG_VOID, *IMG_PVOID;
+typedef void IMG_VOID, *IMG_PVOID;
typedef IMG_INT32 IMG_RESULT;
-typedef IMG_UINT32 IMG_UINTPTR_T;
+#if defined(_WIN64)
+typedef unsigned __int64 IMG_UINTPTR_T;
+#else
+typedef unsigned int IMG_UINTPTR_T;
+#endif
typedef IMG_PVOID IMG_HANDLE;
typedef IMG_UINT32 IMG_SIZE_T;
-#define IMG_NULL 0
+#define IMG_NULL 0
+
+typedef IMG_UINT32 IMG_SID;
typedef IMG_PVOID IMG_CPU_VIRTADDR;
-typedef struct
+typedef struct _IMG_DEV_VIRTADDR
{
- IMG_UINT32 uiAddr;
+ IMG_UINT32 uiAddr;
#define IMG_CAST_TO_DEVVADDR_UINT(var) (IMG_UINT32)(var)
} IMG_DEV_VIRTADDR;
#define DBGPRIV_VERBOSE 0x10UL
#define DBGPRIV_CALLTRACE 0x20UL
#define DBGPRIV_ALLOC 0x40UL
+
+#define DBGPRIV_DBGDRV_MESSAGE 0x1000UL
+
#define DBGPRIV_ALLLEVELS (DBGPRIV_FATAL | DBGPRIV_ERROR | DBGPRIV_WARNING | DBGPRIV_MESSAGE | DBGPRIV_VERBOSE)
#define PVR_DBG_CALLTRACE DBGPRIV_CALLTRACE,__FILE__, __LINE__
#define PVR_DBG_ALLOC DBGPRIV_ALLOC,__FILE__, __LINE__
-#if !defined(PVRSRV_NEED_PVR_ASSERT) && defined(DEBUG_PVR)
+#define PVR_DBGDRIV_MESSAGE DBGPRIV_DBGDRV_MESSAGE, "", 0
+
+#if !defined(PVRSRV_NEED_PVR_ASSERT) && defined(DEBUG)
#define PVRSRV_NEED_PVR_ASSERT
#endif
#define PVRSRV_NEED_PVR_DPF
#endif
-#if !defined(PVRSRV_NEED_PVR_TRACE) && (defined(DEBUG_PVR) || defined(TIMING))
+#if !defined(PVRSRV_NEED_PVR_TRACE) && (defined(DEBUG) || defined(TIMING))
#define PVRSRV_NEED_PVR_TRACE
#endif
const IMG_CHAR *pszFileName,
IMG_UINT32 ui32Line,
const IMG_CHAR *pszFormat,
- ...);
+ ...) IMG_FORMAT_PRINTF(4, 5);
#else
#define PVR_TRACE(X) PVRSRVTrace X
-IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVTrace(const IMG_CHAR* pszFormat, ... );
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVTrace(const IMG_CHAR* pszFormat, ... )
+ IMG_FORMAT_PRINTF(1, 2);
#else
#define _PVRVERSION_H_
#define PVRVERSION_MAJ 1
-#define PVRVERSION_MIN 5
-#define PVRVERSION_BRANCH 15
-#define PVRVERSION_BUILD 2766
-#define PVRVERSION_STRING "1.5.15.2766"
+#define PVRVERSION_MIN 6
+#define PVRVERSION_BRANCH 16
+#define PVRVERSION_BUILD 3977
+#define PVRVERSION_STRING "1.6.16.3977"
#define PVRVERSION_FILE "eurasiacon.pj"
#endif
#define EVENTOBJNAME_MAXLENGTH (50)
-#define PVRSRV_MEM_READ (1UL<<0)
-#define PVRSRV_MEM_WRITE (1UL<<1)
-#define PVRSRV_MEM_CACHE_CONSISTENT (1UL<<2)
-#define PVRSRV_MEM_NO_SYNCOBJ (1UL<<3)
-#define PVRSRV_MEM_INTERLEAVED (1UL<<4)
-#define PVRSRV_MEM_DUMMY (1UL<<5)
-#define PVRSRV_MEM_EDM_PROTECT (1UL<<6)
-#define PVRSRV_MEM_ZERO (1UL<<7)
-#define PVRSRV_MEM_USER_SUPPLIED_DEVVADDR (1UL<<8)
-#define PVRSRV_MEM_RAM_BACKED_ALLOCATION (1UL<<9)
-#define PVRSRV_MEM_NO_RESMAN (1UL<<10)
-#define PVRSRV_MEM_EXPORTED (1UL<<11)
-
-
-#define PVRSRV_HAP_CACHED (1UL<<12)
-#define PVRSRV_HAP_UNCACHED (1UL<<13)
-#define PVRSRV_HAP_WRITECOMBINE (1UL<<14)
+#define PVRSRV_MEM_READ (1U<<0)
+#define PVRSRV_MEM_WRITE (1U<<1)
+#define PVRSRV_MEM_CACHE_CONSISTENT (1U<<2)
+#define PVRSRV_MEM_NO_SYNCOBJ (1U<<3)
+#define PVRSRV_MEM_INTERLEAVED (1U<<4)
+#define PVRSRV_MEM_DUMMY (1U<<5)
+#define PVRSRV_MEM_EDM_PROTECT (1U<<6)
+#define PVRSRV_MEM_ZERO (1U<<7)
+#define PVRSRV_MEM_USER_SUPPLIED_DEVVADDR (1U<<8)
+#define PVRSRV_MEM_RAM_BACKED_ALLOCATION (1U<<9)
+#define PVRSRV_MEM_NO_RESMAN (1U<<10)
+#define PVRSRV_MEM_EXPORTED (1U<<11)
+
+
+#define PVRSRV_HAP_CACHED (1U<<12)
+#define PVRSRV_HAP_UNCACHED (1U<<13)
+#define PVRSRV_HAP_WRITECOMBINE (1U<<14)
#define PVRSRV_HAP_CACHETYPE_MASK (PVRSRV_HAP_CACHED|PVRSRV_HAP_UNCACHED|PVRSRV_HAP_WRITECOMBINE)
-#define PVRSRV_HAP_KERNEL_ONLY (1UL<<15)
-#define PVRSRV_HAP_SINGLE_PROCESS (1UL<<16)
-#define PVRSRV_HAP_MULTI_PROCESS (1UL<<17)
-#define PVRSRV_HAP_FROM_EXISTING_PROCESS (1UL<<18)
-#define PVRSRV_HAP_NO_CPU_VIRTUAL (1UL<<19)
+#define PVRSRV_HAP_KERNEL_ONLY (1U<<15)
+#define PVRSRV_HAP_SINGLE_PROCESS (1U<<16)
+#define PVRSRV_HAP_MULTI_PROCESS (1U<<17)
+#define PVRSRV_HAP_FROM_EXISTING_PROCESS (1U<<18)
+#define PVRSRV_HAP_NO_CPU_VIRTUAL (1U<<19)
#define PVRSRV_HAP_MAPTYPE_MASK (PVRSRV_HAP_KERNEL_ONLY \
|PVRSRV_HAP_SINGLE_PROCESS \
|PVRSRV_HAP_MULTI_PROCESS \
#define PVRSRV_DEFAULT_DEV_COOKIE (1)
-#define PVRSRV_MISC_INFO_TIMER_PRESENT (1UL<<0)
-#define PVRSRV_MISC_INFO_CLOCKGATE_PRESENT (1UL<<1)
-#define PVRSRV_MISC_INFO_MEMSTATS_PRESENT (1UL<<2)
-#define PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT (1UL<<3)
-#define PVRSRV_MISC_INFO_DDKVERSION_PRESENT (1UL<<4)
-#define PVRSRV_MISC_INFO_CPUCACHEFLUSH_PRESENT (1UL<<5)
+#define PVRSRV_MISC_INFO_TIMER_PRESENT (1U<<0)
+#define PVRSRV_MISC_INFO_CLOCKGATE_PRESENT (1U<<1)
+#define PVRSRV_MISC_INFO_MEMSTATS_PRESENT (1U<<2)
+#define PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT (1U<<3)
+#define PVRSRV_MISC_INFO_DDKVERSION_PRESENT (1U<<4)
+#define PVRSRV_MISC_INFO_CPUCACHEOP_PRESENT (1U<<5)
+#define PVRSRV_MISC_INFO_FREEMEM_PRESENT (1U<<6)
+
+#define PVRSRV_MISC_INFO_RESET_PRESENT (1U<<31)
#define PVRSRV_PDUMP_MAX_FILENAME_SIZE 20
#define PVRSRV_PDUMP_MAX_COMMENT_SIZE 200
#define PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC 0x00000001
#define PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC 0x00000002
+#define SRV_FLAGS_PERSIST 0x1
+#define SRV_FLAGS_PDUMP_ACTIVE 0x2
+
+#define PVRSRV_PDUMP_FLAGS_CONTINUOUS 0x1
+
+
typedef enum _PVRSRV_DEVICE_TYPE_
{
PVRSRV_DEVICE_TYPE_UNKNOWN = 0 ,
PVRSRV_DEVICE_TYPE eDeviceType;
PVRSRV_DEVICE_CLASS eDeviceClass;
IMG_UINT32 ui32DeviceIndex;
+ IMG_CHAR *pszPDumpDevName;
+ IMG_CHAR *pszPDumpRegName;
} PVRSRV_DEVICE_IDENTIFIER;
IMG_UINT32 ui32NumDevices;
PVRSRV_DEVICE_IDENTIFIER asDevID[PVRSRV_MAX_DEVICES];
PVRSRV_ERROR (*apfnDevConnect[PVRSRV_MAX_DEVICES])(PPVRSRV_DEV_DATA);
+ PVRSRV_ERROR (*apfnDumpTrace[PVRSRV_MAX_DEVICES])(PPVRSRV_DEV_DATA);
} PVRSRV_CLIENT_DEV_DATA;
typedef struct _PVRSRV_CONNECTION_
{
IMG_HANDLE hServices;
- IMG_UINT32 ui32ProcessID;
+ IMG_UINTPTR_T ui32ProcessID;
PVRSRV_CLIENT_DEV_DATA sClientDevData;
+ IMG_UINT32 ui32SrvFlags;
}PVRSRV_CONNECTION;
typedef struct _PVRSRV_DEV_DATA_
{
- PVRSRV_CONNECTION sConnection;
- IMG_HANDLE hDevCookie;
+ IMG_CONST PVRSRV_CONNECTION *psConnection;
+ IMG_HANDLE hDevCookie;
} PVRSRV_DEV_DATA;
typedef struct _PVRSRV_MEMUPDATE_
{
- IMG_UINT32 ui32UpdateAddr;
+ IMG_UINTPTR_T ui32UpdateAddr;
IMG_UINT32 ui32UpdateVal;
} PVRSRV_MEMUPDATE;
IMG_UINT32 ui32RegVal;
} PVRSRV_HWREG;
-typedef struct _PVRSRV_MEMBLK_
+typedef struct _PVRSRV_MEMBLK_
{
IMG_DEV_VIRTADDR sDevVirtAddr;
IMG_HANDLE hOSMemHandle;
- IMG_HANDLE hOSWrapMem;
+ IMG_HANDLE hOSWrapMem;
IMG_HANDLE hBuffer;
IMG_HANDLE hResItem;
IMG_SYS_PHYADDR *psIntSysPAddr;
typedef struct _PVRSRV_CLIENT_MEM_INFO_
{
- IMG_PVOID pvLinAddr;
+ IMG_PVOID pvLinAddr;
IMG_PVOID pvLinAddrKM;
IMG_DEV_VIRTADDR sDevVAddrBase;
IMG_UINT32 ui32HeapByteSize;
IMG_UINT32 ui32Attribs;
+ IMG_UINT32 ui32XTileStride;
}PVRSRV_HEAP_INFO;
} PVRSRV_EVENTOBJECT;
+typedef enum
+{
+ PVRSRV_MISC_INFO_CPUCACHEOP_NONE = 0,
+ PVRSRV_MISC_INFO_CPUCACHEOP_CLEAN,
+ PVRSRV_MISC_INFO_CPUCACHEOP_FLUSH
+} PVRSRV_MISC_INFO_CPUCACHEOP_TYPE;
+
typedef struct _PVRSRV_MISC_INFO_
{
IMG_UINT32 ui32StateRequest;
IMG_HANDLE hSOCTimerRegisterMappingInfo;
- IMG_VOID *pvSOCClockGateRegs;
+ IMG_VOID *pvSOCClockGateRegs;
IMG_UINT32 ui32SOCClockGateRegsSize;
IMG_UINT32 aui32DDKVersion[4];
-
- IMG_BOOL bCPUCacheFlushAll;
-
- IMG_BOOL bDeferCPUCacheFlush;
-
- IMG_PVOID pvRangeAddrStart;
-
- IMG_PVOID pvRangeAddrEnd;
-
+ struct
+ {
+
+ IMG_BOOL bDeferOp;
+
+
+ PVRSRV_MISC_INFO_CPUCACHEOP_TYPE eCacheOpType;
+
+
+ union
+ {
+
+ PVRSRV_CLIENT_MEM_INFO *psClientMemInfo;
+
+
+ struct _PVRSRV_KERNEL_MEM_INFO_ *psKernelMemInfo;
+ } u;
+
+
+ IMG_VOID *pvBaseVAddr;
+
+
+ IMG_UINT32 ui32Length;
+ } sCacheOpCtl;
} PVRSRV_MISC_INFO;
+typedef enum _PVRSRV_CLIENT_EVENT_
+{
+ PVRSRV_CLIENT_EVENT_HWTIMEOUT = 0,
+} PVRSRV_CLIENT_EVENT;
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVClientEvent(IMG_CONST PVRSRV_CLIENT_EVENT eEvent,
+ PVRSRV_DEV_DATA *psDevData,
+ IMG_PVOID pvData);
+
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVConnect(PVRSRV_CONNECTION *psConnection);
+PVRSRV_ERROR IMG_CALLCONV PVRSRVConnect(PVRSRV_CONNECTION **ppsConnection, IMG_UINT32 ui32SrvFlags);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVDisconnect(PVRSRV_CONNECTION *psConnection);
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDisconnect(IMG_CONST PVRSRV_CONNECTION *psConnection);
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevices(IMG_CONST PVRSRV_CONNECTION *psConnection,
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemory(IMG_CONST PVRSRV_DEV_DATA *psDevData,
IMG_HANDLE hDevMemContext,
- IMG_SIZE_T ui32ByteSize,
+ IMG_SIZE_T ui32ByteSize,
IMG_SIZE_T ui32PageOffset,
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psSysPAddr,
IMG_VOID *pvLinAddr,
+ IMG_UINT32 ui32Flags,
PVRSRV_CLIENT_MEM_INFO **ppsMemInfo);
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVUnwrapExtMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCFormats (IMG_HANDLE hDevice,
- IMG_UINT32 *pui32Count,
+ IMG_UINT32 *pui32Count,
DISPLAY_FORMAT *psFormat);
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCDims (IMG_HANDLE hDevice,
- IMG_UINT32 *pui32Count,
+ IMG_UINT32 *pui32Count,
DISPLAY_FORMAT *psFormat,
DISPLAY_DIMS *psDims);
IMG_UINT32 ui32Offset,
IMG_UINT32 ui32Value,
IMG_UINT32 ui32Mask,
+ PDUMP_POLL_OPERATOR eOperator,
IMG_UINT32 ui32Flags);
IMG_IMPORT
IMG_UINT32 ui32Bytes);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpReg(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpReg(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+ IMG_CHAR *pszRegRegion,
IMG_UINT32 ui32RegAddr,
IMG_UINT32 ui32RegValue,
IMG_UINT32 ui32Flags);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPolWithFlags(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPolWithFlags(const PVRSRV_DEV_DATA *psDevData,
+ IMG_CHAR *pszRegRegion,
IMG_UINT32 ui32RegAddr,
IMG_UINT32 ui32RegValue,
IMG_UINT32 ui32Mask,
IMG_UINT32 ui32Flags);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPol(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPol(const PVRSRV_DEV_DATA *psDevData,
+ IMG_CHAR *pszRegRegion,
IMG_UINT32 ui32RegAddr,
IMG_UINT32 ui32RegValue,
IMG_UINT32 ui32Mask);
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCommentf(IMG_CONST PVRSRV_CONNECTION *psConnection,
IMG_BOOL bContinuous,
- IMG_CONST IMG_CHAR *pszFormat, ...);
+ IMG_CONST IMG_CHAR *pszFormat, ...)
+#if !defined(USE_CODE)
+ IMG_FORMAT_PRINTF(3, 4)
+#endif
+;
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCommentWithFlagsf(IMG_CONST PVRSRV_CONNECTION *psConnection,
IMG_UINT32 ui32Flags,
- IMG_CONST IMG_CHAR *pszFormat, ...);
+ IMG_CONST IMG_CHAR *pszFormat, ...)
+#if !defined(USE_CODE)
+ IMG_FORMAT_PRINTF(3, 4)
+#endif
+;
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpDriverInfo(IMG_CONST PVRSRV_CONNECTION *psConnection,
IMG_BOOL *pbIsCapturing);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpBitmap(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpBitmap(IMG_CONST PVRSRV_DEV_DATA *psDevData,
IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Width,
IMG_UINT32 ui32Height,
IMG_UINT32 ui32StrideInBytes,
IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_HANDLE hDevMemContext,
IMG_UINT32 ui32Size,
PDUMP_PIXEL_FORMAT ePixelFormat,
PDUMP_MEM_FORMAT eMemFormat,
IMG_UINT32 ui32PDumpFlags);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegRead(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegRead(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+ IMG_CONST IMG_CHAR *pszRegRegion,
IMG_CONST IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Address,
IMG_BOOL IMG_CALLCONV PVRSRVPDumpIsCapturingTest(IMG_CONST PVRSRV_CONNECTION *psConnection);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCycleCountRegRead(IMG_CONST PVRSRV_CONNECTION *psConnection,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCycleCountRegRead(IMG_CONST PVRSRV_DEV_DATA *psDevData,
IMG_UINT32 ui32RegOffset,
IMG_BOOL bLastFrame);
IMG_IMPORT IMG_UINT32 PVRSRVClockus (void);
IMG_IMPORT IMG_VOID PVRSRVWaitus (IMG_UINT32 ui32Timeus);
IMG_IMPORT IMG_VOID PVRSRVReleaseThreadQuanta (void);
-IMG_IMPORT IMG_UINT32 IMG_CALLCONV PVRSRVGetCurrentProcessID(void);
+IMG_IMPORT IMG_UINTPTR_T IMG_CALLCONV PVRSRVGetCurrentProcessID(void);
IMG_IMPORT IMG_CHAR * IMG_CALLCONV PVRSRVSetLocale(const IMG_CHAR *pszLocale);
IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVLockMutex(PVRSRV_MUTEX_HANDLE hMutex);
IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVUnlockMutex(PVRSRV_MUTEX_HANDLE hMutex);
-#if (defined(DEBUG_PVR) && defined(__linux__))
-IMG_PVOID PVRSRVAllocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
-IMG_PVOID PVRSRVCallocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
-IMG_VOID PVRSRVFreeUserModeMemTracking(IMG_VOID *pvMem);
-IMG_PVOID PVRSRVReallocUserModeMemTracking(IMG_VOID *pvMem, IMG_SIZE_T ui32NewSize, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+struct _PVRSRV_SEMAPHORE_OPAQUE_STRUCT_;
+typedef struct _PVRSRV_SEMAPHORE_OPAQUE_STRUCT_ *PVRSRV_SEMAPHORE_HANDLE;
+
+
+ #define IMG_SEMAPHORE_WAIT_INFINITE ((IMG_UINT64)0xFFFFFFFFFFFFFFFFull)
+
+
+#if !defined(USE_CODE)
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVCreateSemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVCreateSemaphore(PVRSRV_SEMAPHORE_HANDLE *phSemaphore, IMG_INT iInitialCount)
+{
+ PVR_UNREFERENCED_PARAMETER(iInitialCount);
+ *phSemaphore = 0;
+ return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVDestroySemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVDestroySemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore)
+{
+ PVR_UNREFERENCED_PARAMETER(hSemaphore);
+ return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVWaitSemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVWaitSemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore, IMG_UINT64 ui64TimeoutMicroSeconds)
+{
+ PVR_UNREFERENCED_PARAMETER(hSemaphore);
+ PVR_UNREFERENCED_PARAMETER(ui64TimeoutMicroSeconds);
+ return PVRSRV_ERROR_INVALID_PARAMS;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVPostSemaphore)
+#endif
+static INLINE IMG_VOID PVRSRVPostSemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore, IMG_INT iPostCount)
+{
+ PVR_UNREFERENCED_PARAMETER(hSemaphore);
+ PVR_UNREFERENCED_PARAMETER(iPostCount);
+}
+
+#endif
+
+
+#if (defined(DEBUG) && defined(__linux__))
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVAllocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVCallocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVFreeUserModeMemTracking(IMG_VOID *pvMem);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVReallocUserModeMemTracking(IMG_VOID *pvMem, IMG_SIZE_T ui32NewSize,
+ IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
#endif
-IMG_IMPORT PVRSRV_ERROR PVRSRVEventObjectWait(const PVRSRV_CONNECTION *psConnection,
+IMG_IMPORT PVRSRV_ERROR PVRSRVEventObjectWait(const PVRSRV_CONNECTION *psConnection,
IMG_HANDLE hOSEvent);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyPendingSyncOps(PVRSRV_CONNECTION *psConnection,
- IMG_HANDLE hKernelSyncInfo,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateSyncInfoModObj(const PVRSRV_CONNECTION *psConnection,
+ IMG_HANDLE *phKernelSyncInfoModObj);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroySyncInfoModObj(const PVRSRV_CONNECTION *psConnection,
+ IMG_HANDLE hKernelSyncInfoModObj);
+
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyPendingSyncOps(const PVRSRV_CONNECTION *psConnection,
+ IMG_HANDLE hKernelSyncInfoModObj,
+ PVRSRV_CLIENT_SYNC_INFO *psSyncInfo,
IMG_UINT32 ui32ModifyFlags,
IMG_UINT32 *pui32ReadOpsPending,
IMG_UINT32 *pui32WriteOpsPending);
IMG_IMPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyCompleteSyncOps(PVRSRV_CONNECTION *psConnection,
- IMG_HANDLE hKernelSyncInfo,
- IMG_UINT32 ui32ModifyFlags);
+PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyCompleteSyncOps(const PVRSRV_CONNECTION *psConnection,
+ IMG_HANDLE hKernelSyncInfoModObj);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsFlushToModObj(const PVRSRV_CONNECTION *psConnection,
+ IMG_HANDLE hKernelSyncInfoModObj,
+ IMG_BOOL bWait);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsFlushToDelta(const PVRSRV_CONNECTION *psConnection,
+ PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+ IMG_UINT32 ui32Delta,
+ IMG_BOOL bWait);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfo(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+ PVRSRV_CLIENT_SYNC_INFO **ppsSyncInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfo(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+ PVRSRV_CLIENT_SYNC_INFO *psSyncInfo);
+
+IMG_IMPORT
+const IMG_CHAR *PVRSRVGetErrorString(PVRSRV_ERROR eError);
-#define TIME_NOT_PASSED_UINT32(a,b,c) ((a - b) < c)
+#define TIME_NOT_PASSED_UINT32(a,b,c) (((a) - (b)) < (c))
#if defined (__cplusplus)
}
typedef enum _PVRSRV_ERROR_
{
- PVRSRV_OK = 0,
- PVRSRV_ERROR_GENERIC = 1,
- PVRSRV_ERROR_OUT_OF_MEMORY = 2,
- PVRSRV_ERROR_TOO_FEW_BUFFERS = 3,
- PVRSRV_ERROR_SYMBOL_NOT_FOUND = 4,
- PVRSRV_ERROR_OUT_OF_HSPACE = 5,
- PVRSRV_ERROR_INVALID_PARAMS = 6,
- PVRSRV_ERROR_TILE_MAP_FAILED = 7,
- PVRSRV_ERROR_INIT_FAILURE = 8,
- PVRSRV_ERROR_CANT_REGISTER_CALLBACK = 9,
- PVRSRV_ERROR_INVALID_DEVICE = 10,
- PVRSRV_ERROR_NOT_OWNER = 11,
- PVRSRV_ERROR_BAD_MAPPING = 12,
- PVRSRV_ERROR_TIMEOUT = 13,
- PVRSRV_ERROR_NO_PRIMARY = 14,
- PVRSRV_ERROR_FLIP_CHAIN_EXISTS = 15,
- PVRSRV_ERROR_CANNOT_ACQUIRE_SYSDATA = 16,
- PVRSRV_ERROR_SCENE_INVALID = 17,
- PVRSRV_ERROR_STREAM_ERROR = 18,
- PVRSRV_ERROR_INVALID_INTERRUPT = 19,
- PVRSRV_ERROR_FAILED_DEPENDENCIES = 20,
- PVRSRV_ERROR_CMD_NOT_PROCESSED = 21,
- PVRSRV_ERROR_CMD_TOO_BIG = 22,
- PVRSRV_ERROR_DEVICE_REGISTER_FAILED = 23,
- PVRSRV_ERROR_FIFO_SPACE = 24,
- PVRSRV_ERROR_TA_RECOVERY = 25,
- PVRSRV_ERROR_INDOSORLOWPOWER = 26,
- PVRSRV_ERROR_TOOMANYBUFFERS = 27,
- PVRSRV_ERROR_NOT_SUPPORTED = 28,
- PVRSRV_ERROR_PROCESSING_BLOCKED = 29,
-
-
- PVRSRV_ERROR_CANNOT_FLUSH_QUEUE = 31,
- PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE = 32,
- PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS = 33,
- PVRSRV_ERROR_RETRY = 34,
-
- PVRSRV_ERROR_DDK_VERSION_MISMATCH = 35,
- PVRSRV_ERROR_BUILD_MISMATCH = 36,
+ PVRSRV_OK = 0,
+ PVRSRV_ERROR_OUT_OF_MEMORY,
+ PVRSRV_ERROR_TOO_FEW_BUFFERS,
+ PVRSRV_ERROR_INVALID_PARAMS,
+ PVRSRV_ERROR_INIT_FAILURE,
+ PVRSRV_ERROR_CANT_REGISTER_CALLBACK,
+ PVRSRV_ERROR_INVALID_DEVICE,
+ PVRSRV_ERROR_NOT_OWNER,
+ PVRSRV_ERROR_BAD_MAPPING,
+ PVRSRV_ERROR_TIMEOUT,
+ PVRSRV_ERROR_FLIP_CHAIN_EXISTS,
+ PVRSRV_ERROR_INVALID_SWAPINTERVAL,
+ PVRSRV_ERROR_SCENE_INVALID,
+ PVRSRV_ERROR_STREAM_ERROR,
+ PVRSRV_ERROR_FAILED_DEPENDENCIES,
+ PVRSRV_ERROR_CMD_NOT_PROCESSED,
+ PVRSRV_ERROR_CMD_TOO_BIG,
+ PVRSRV_ERROR_DEVICE_REGISTER_FAILED,
+ PVRSRV_ERROR_TOOMANYBUFFERS,
+ PVRSRV_ERROR_NOT_SUPPORTED,
+ PVRSRV_ERROR_PROCESSING_BLOCKED,
+
+ PVRSRV_ERROR_CANNOT_FLUSH_QUEUE,
+ PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE,
+ PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS,
+ PVRSRV_ERROR_RETRY,
+
+ PVRSRV_ERROR_DDK_VERSION_MISMATCH,
+ PVRSRV_ERROR_BUILD_MISMATCH,
+ PVRSRV_ERROR_CORE_REVISION_MISMATCH,
+
+ PVRSRV_ERROR_UPLOAD_TOO_BIG,
+
+ PVRSRV_ERROR_INVALID_FLAGS,
+ PVRSRV_ERROR_FAILED_TO_REGISTER_PROCESS,
+
+ PVRSRV_ERROR_UNABLE_TO_LOAD_LIBRARY,
+ PVRSRV_ERROR_UNABLE_GET_FUNC_ADDR,
+ PVRSRV_ERROR_UNLOAD_LIBRARY_FAILED,
+
+ PVRSRV_ERROR_BRIDGE_CALL_FAILED,
+ PVRSRV_ERROR_IOCTL_CALL_FAILED,
+
+ PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND,
+ PVRSRV_ERROR_BUFFER_DEVICE_NOT_FOUND,
+ PVRSRV_ERROR_BUFFER_DEVICE_ALREADY_PRESENT,
+
+ PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND,
+ PVRSRV_ERROR_PCI_CALL_FAILED,
+ PVRSRV_ERROR_PCI_REGION_TOO_SMALL,
+ PVRSRV_ERROR_PCI_REGION_UNAVAILABLE,
+ PVRSRV_ERROR_BAD_REGION_SIZE_MISMATCH,
+
+ PVRSRV_ERROR_REGISTER_BASE_NOT_SET,
+
+ PVRSRV_ERROR_FAILED_TO_ALLOC_USER_MEM,
+ PVRSRV_ERROR_FAILED_TO_ALLOC_VP_MEMORY,
+ PVRSRV_ERROR_FAILED_TO_MAP_SHARED_PBDESC,
+ PVRSRV_ERROR_FAILED_TO_GET_PHYS_ADDR,
+
+ PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY,
+ PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY,
+
+ PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES,
+ PVRSRV_ERROR_FAILED_TO_FREE_PAGES,
+ PVRSRV_ERROR_FAILED_TO_COPY_PAGES,
+ PVRSRV_ERROR_UNABLE_TO_LOCK_PAGES,
+ PVRSRV_ERROR_UNABLE_TO_UNLOCK_PAGES,
+ PVRSRV_ERROR_STILL_MAPPED,
+ PVRSRV_ERROR_MAPPING_NOT_FOUND,
+ PVRSRV_ERROR_PHYS_ADDRESS_EXCEEDS_32BIT,
+ PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE,
+
+ PVRSRV_ERROR_INVALID_SEGMENT_BLOCK,
+ PVRSRV_ERROR_INVALID_SGXDEVDATA,
+ PVRSRV_ERROR_INVALID_DEVINFO,
+ PVRSRV_ERROR_INVALID_MEMINFO,
+ PVRSRV_ERROR_INVALID_MISCINFO,
+ PVRSRV_ERROR_UNKNOWN_IOCTL,
+ PVRSRV_ERROR_INVALID_CONTEXT,
+ PVRSRV_ERROR_UNABLE_TO_DESTROY_CONTEXT,
+ PVRSRV_ERROR_INVALID_HEAP,
+ PVRSRV_ERROR_INVALID_KERNELINFO,
+ PVRSRV_ERROR_UNKNOWN_POWER_STATE,
+ PVRSRV_ERROR_INVALID_HANDLE_TYPE,
+ PVRSRV_ERROR_INVALID_WRAP_TYPE,
+ PVRSRV_ERROR_INVALID_PHYS_ADDR,
+ PVRSRV_ERROR_INVALID_CPU_ADDR,
+ PVRSRV_ERROR_INVALID_HEAPINFO,
+ PVRSRV_ERROR_INVALID_PERPROC,
+ PVRSRV_ERROR_FAILED_TO_RETRIEVE_HEAPINFO,
+ PVRSRV_ERROR_INVALID_MAP_REQUEST,
+ PVRSRV_ERROR_INVALID_UNMAP_REQUEST,
+ PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP,
+ PVRSRV_ERROR_MAPPING_STILL_IN_USE,
+
+ PVRSRV_ERROR_EXCEEDED_HW_LIMITS,
+ PVRSRV_ERROR_NO_STAGING_BUFFER_ALLOCATED,
+
+ PVRSRV_ERROR_UNABLE_TO_CREATE_PERPROC_AREA,
+ PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT,
+ PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT,
+ PVRSRV_ERROR_UNABLE_TO_REGISTER_EVENT,
+ PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT,
+ PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD,
+ PVRSRV_ERROR_UNABLE_TO_CLOSE_THREAD,
+ PVRSRV_ERROR_THREAD_READ_ERROR,
+ PVRSRV_ERROR_UNABLE_TO_REGISTER_ISR_HANDLER,
+ PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR,
+ PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR,
+ PVRSRV_ERROR_ISR_ALREADY_INSTALLED,
+ PVRSRV_ERROR_ISR_NOT_INSTALLED,
+ PVRSRV_ERROR_UNABLE_TO_INITIALISE_INTERRUPT,
+ PVRSRV_ERROR_UNABLE_TO_RETRIEVE_INFO,
+ PVRSRV_ERROR_UNABLE_TO_DO_BACKWARDS_BLIT,
+ PVRSRV_ERROR_UNABLE_TO_CLOSE_SERVICES,
+ PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT,
+ PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE,
+
+ PVRSRV_ERROR_INVALID_CCB_COMMAND,
+
+ PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE,
+ PVRSRV_ERROR_INVALID_LOCK_ID,
+ PVRSRV_ERROR_RESOURCE_NOT_LOCKED,
+
+ PVRSRV_ERROR_FLIP_FAILED,
+ PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED,
+
+ PVRSRV_ERROR_TIMEOUT_POLLING_FOR_VALUE,
+
+ PVRSRV_ERROR_CREATE_RENDER_CONTEXT_FAILED,
+ PVRSRV_ERROR_UNKNOWN_PRIMARY_FRAG,
+ PVRSRV_ERROR_UNEXPECTED_SECONDARY_FRAG,
+ PVRSRV_ERROR_UNEXPECTED_PRIMARY_FRAG,
+
+ PVRSRV_ERROR_UNABLE_TO_INSERT_FENCE_ID,
+
+ PVRSRV_ERROR_BLIT_SETUP_FAILED,
+
+ PVRSRV_ERROR_PDUMP_NOT_AVAILABLE,
+ PVRSRV_ERROR_PDUMP_BUFFER_FULL,
PVRSRV_ERROR_PDUMP_BUF_OVERFLOW,
+ PVRSRV_ERROR_PDUMP_NOT_ACTIVE,
+ PVRSRV_ERROR_INCOMPLETE_LINE_OVERLAPS_PAGES,
+
+ PVRSRV_ERROR_MUTEX_DESTROY_FAILED,
+ PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR,
+
+ PVRSRV_ERROR_INSUFFICIENT_SCRIPT_SPACE,
+ PVRSRV_ERROR_INSUFFICIENT_SPACE_FOR_COMMAND,
+
+ PVRSRV_ERROR_PROCESS_NOT_INITIALISED,
+ PVRSRV_ERROR_PROCESS_NOT_FOUND,
+ PVRSRV_ERROR_SRV_CONNECT_FAILED,
+ PVRSRV_ERROR_SRV_DISCONNECT_FAILED,
+ PVRSRV_ERROR_DEINT_PHASE_FAILED,
+ PVRSRV_ERROR_INIT2_PHASE_FAILED,
+
+ PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE,
+
+ PVRSRV_ERROR_NO_DC_DEVICES_FOUND,
+ PVRSRV_ERROR_UNABLE_TO_OPEN_DC_DEVICE,
+ PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE,
+ PVRSRV_ERROR_NO_DEVICEDATA_FOUND,
+ PVRSRV_ERROR_NO_DEVICENODE_FOUND,
+ PVRSRV_ERROR_NO_CLIENTNODE_FOUND,
+ PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE,
+
+ PVRSRV_ERROR_UNABLE_TO_INIT_TASK,
+ PVRSRV_ERROR_UNABLE_TO_SCHEDULE_TASK,
+ PVRSRV_ERROR_UNABLE_TO_KILL_TASK,
+
+ PVRSRV_ERROR_UNABLE_TO_ENABLE_TIMER,
+ PVRSRV_ERROR_UNABLE_TO_DISABLE_TIMER,
+ PVRSRV_ERROR_UNABLE_TO_REMOVE_TIMER,
+
+ PVRSRV_ERROR_UNKNOWN_PIXEL_FORMAT,
+ PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION,
+
+ PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE,
+ PVRSRV_ERROR_HANDLE_NOT_ALLOCATED,
+ PVRSRV_ERROR_HANDLE_TYPE_MISMATCH,
+ PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE,
+ PVRSRV_ERROR_HANDLE_NOT_SHAREABLE,
+ PVRSRV_ERROR_HANDLE_NOT_FOUND,
+ PVRSRV_ERROR_INVALID_SUBHANDLE,
+ PVRSRV_ERROR_HANDLE_BATCH_IN_USE,
+ PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE,
+
+ PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE,
+ PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED,
+
+ PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE,
+ PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP,
+
+ PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE,
+
+ PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE,
+ PVRSRV_ERROR_INVALID_DEVICEID,
+ PVRSRV_ERROR_DEVICEID_NOT_FOUND,
+
+ PVRSRV_ERROR_MEMORY_TEST_FAILED,
+ PVRSRV_ERROR_CPUPADDR_TEST_FAILED,
+ PVRSRV_ERROR_COPY_TEST_FAILED,
+
+ PVRSRV_ERROR_SEMAPHORE_NOT_INITIALISED,
+
+ PVRSRV_ERROR_UNABLE_TO_RELEASE_CLOCK,
+ PVRSRV_ERROR_CLOCK_REQUEST_FAILED,
+ PVRSRV_ERROR_DISABLE_CLOCK_FAILURE,
+ PVRSRV_ERROR_UNABLE_TO_SET_CLOCK_RATE,
+ PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE,
+ PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK,
+ PVRSRV_ERROR_UNABLE_TO_GET_CLOCK,
+ PVRSRV_ERROR_UNABLE_TO_GET_PARENT_CLOCK,
+ PVRSRV_ERROR_UNABLE_TO_GET_SYSTEM_CLOCK,
+
+ PVRSRV_ERROR_UNKNOWN_SGL_ERROR,
+
+ PVRSRV_ERROR_SYSTEM_POWER_CHANGE_FAILURE,
+ PVRSRV_ERROR_DEVICE_POWER_CHANGE_FAILURE,
+
+ PVRSRV_ERROR_BAD_SYNC_STATE,
+
+ PVRSRV_ERROR_CACHEOP_FAILED,
PVRSRV_ERROR_FORCE_I32 = 0x7fffffff
} PVRSRV_DEVICE_CLASS;
-
typedef enum _PVRSRV_SYS_POWER_STATE_
{
PVRSRV_SYS_POWER_STATE_Unspecified = -1,
typedef enum _PVRSRV_PIXEL_FORMAT_ {
- PVRSRV_PIXEL_FORMAT_UNKNOWN = 0,
- PVRSRV_PIXEL_FORMAT_RGB565 = 1,
- PVRSRV_PIXEL_FORMAT_RGB555 = 2,
- PVRSRV_PIXEL_FORMAT_RGB888 = 3,
- PVRSRV_PIXEL_FORMAT_BGR888 = 4,
- PVRSRV_PIXEL_FORMAT_GREY_SCALE = 8,
- PVRSRV_PIXEL_FORMAT_PAL12 = 13,
- PVRSRV_PIXEL_FORMAT_PAL8 = 14,
- PVRSRV_PIXEL_FORMAT_PAL4 = 15,
- PVRSRV_PIXEL_FORMAT_PAL2 = 16,
- PVRSRV_PIXEL_FORMAT_PAL1 = 17,
- PVRSRV_PIXEL_FORMAT_ARGB1555 = 18,
- PVRSRV_PIXEL_FORMAT_ARGB4444 = 19,
- PVRSRV_PIXEL_FORMAT_ARGB8888 = 20,
- PVRSRV_PIXEL_FORMAT_ABGR8888 = 21,
- PVRSRV_PIXEL_FORMAT_YV12 = 22,
- PVRSRV_PIXEL_FORMAT_I420 = 23,
- PVRSRV_PIXEL_FORMAT_IMC2 = 25,
- PVRSRV_PIXEL_FORMAT_XRGB8888,
- PVRSRV_PIXEL_FORMAT_XBGR8888,
- PVRSRV_PIXEL_FORMAT_BGRA8888,
- PVRSRV_PIXEL_FORMAT_XRGB4444,
- PVRSRV_PIXEL_FORMAT_ARGB8332,
- PVRSRV_PIXEL_FORMAT_A2RGB10,
- PVRSRV_PIXEL_FORMAT_A2BGR10,
- PVRSRV_PIXEL_FORMAT_P8,
- PVRSRV_PIXEL_FORMAT_L8,
- PVRSRV_PIXEL_FORMAT_A8L8,
- PVRSRV_PIXEL_FORMAT_A4L4,
- PVRSRV_PIXEL_FORMAT_L16,
- PVRSRV_PIXEL_FORMAT_L6V5U5,
- PVRSRV_PIXEL_FORMAT_V8U8,
- PVRSRV_PIXEL_FORMAT_V16U16,
- PVRSRV_PIXEL_FORMAT_QWVU8888,
- PVRSRV_PIXEL_FORMAT_XLVU8888,
- PVRSRV_PIXEL_FORMAT_QWVU16,
- PVRSRV_PIXEL_FORMAT_D16,
- PVRSRV_PIXEL_FORMAT_D24S8,
- PVRSRV_PIXEL_FORMAT_D24X8,
-
-
- PVRSRV_PIXEL_FORMAT_ABGR16,
- PVRSRV_PIXEL_FORMAT_ABGR16F,
- PVRSRV_PIXEL_FORMAT_ABGR32,
- PVRSRV_PIXEL_FORMAT_ABGR32F,
- PVRSRV_PIXEL_FORMAT_B10GR11,
- PVRSRV_PIXEL_FORMAT_GR88,
- PVRSRV_PIXEL_FORMAT_BGR32,
- PVRSRV_PIXEL_FORMAT_GR32,
- PVRSRV_PIXEL_FORMAT_E5BGR9,
-
-
- PVRSRV_PIXEL_FORMAT_DXT1,
- PVRSRV_PIXEL_FORMAT_DXT2,
- PVRSRV_PIXEL_FORMAT_DXT3,
- PVRSRV_PIXEL_FORMAT_DXT4,
- PVRSRV_PIXEL_FORMAT_DXT5,
-
-
- PVRSRV_PIXEL_FORMAT_R8G8_B8G8,
- PVRSRV_PIXEL_FORMAT_G8R8_G8B8,
-
-
- PVRSRV_PIXEL_FORMAT_NV11,
- PVRSRV_PIXEL_FORMAT_NV12,
-
-
- PVRSRV_PIXEL_FORMAT_YUY2,
- PVRSRV_PIXEL_FORMAT_YUV420,
- PVRSRV_PIXEL_FORMAT_YUV444,
- PVRSRV_PIXEL_FORMAT_VUY444,
- PVRSRV_PIXEL_FORMAT_YUYV,
- PVRSRV_PIXEL_FORMAT_YVYU,
- PVRSRV_PIXEL_FORMAT_UYVY,
- PVRSRV_PIXEL_FORMAT_VYUY,
-
- PVRSRV_PIXEL_FORMAT_FOURCC_ORG_UYVY,
- PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YUYV,
- PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YVYU,
- PVRSRV_PIXEL_FORMAT_FOURCC_ORG_VYUY,
- PVRSRV_PIXEL_FORMAT_FOURCC_ORG_AYUV,
-
-
- PVRSRV_PIXEL_FORMAT_A32B32G32R32,
- PVRSRV_PIXEL_FORMAT_A32B32G32R32F,
- PVRSRV_PIXEL_FORMAT_A32B32G32R32_UINT,
- PVRSRV_PIXEL_FORMAT_A32B32G32R32_SINT,
-
-
- PVRSRV_PIXEL_FORMAT_B32G32R32,
- PVRSRV_PIXEL_FORMAT_B32G32R32F,
- PVRSRV_PIXEL_FORMAT_B32G32R32_UINT,
- PVRSRV_PIXEL_FORMAT_B32G32R32_SINT,
-
-
- PVRSRV_PIXEL_FORMAT_G32R32,
- PVRSRV_PIXEL_FORMAT_G32R32F,
- PVRSRV_PIXEL_FORMAT_G32R32_UINT,
- PVRSRV_PIXEL_FORMAT_G32R32_SINT,
-
-
- PVRSRV_PIXEL_FORMAT_D32F,
- PVRSRV_PIXEL_FORMAT_R32,
- PVRSRV_PIXEL_FORMAT_R32F,
- PVRSRV_PIXEL_FORMAT_R32_UINT,
- PVRSRV_PIXEL_FORMAT_R32_SINT,
-
-
- PVRSRV_PIXEL_FORMAT_A16B16G16R16,
- PVRSRV_PIXEL_FORMAT_A16B16G16R16F,
- PVRSRV_PIXEL_FORMAT_A16B16G16R16_SINT,
- PVRSRV_PIXEL_FORMAT_A16B16G16R16_SNORM,
- PVRSRV_PIXEL_FORMAT_A16B16G16R16_UINT,
- PVRSRV_PIXEL_FORMAT_A16B16G16R16_UNORM,
-
-
- PVRSRV_PIXEL_FORMAT_G16R16,
- PVRSRV_PIXEL_FORMAT_G16R16F,
- PVRSRV_PIXEL_FORMAT_G16R16_UINT,
- PVRSRV_PIXEL_FORMAT_G16R16_UNORM,
- PVRSRV_PIXEL_FORMAT_G16R16_SINT,
- PVRSRV_PIXEL_FORMAT_G16R16_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_R16,
- PVRSRV_PIXEL_FORMAT_R16F,
- PVRSRV_PIXEL_FORMAT_R16_UINT,
- PVRSRV_PIXEL_FORMAT_R16_UNORM,
- PVRSRV_PIXEL_FORMAT_R16_SINT,
- PVRSRV_PIXEL_FORMAT_R16_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_X8R8G8B8,
- PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM,
- PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM_SRGB,
-
- PVRSRV_PIXEL_FORMAT_A8R8G8B8,
- PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM,
- PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM_SRGB,
-
- PVRSRV_PIXEL_FORMAT_A8B8G8R8,
- PVRSRV_PIXEL_FORMAT_A8B8G8R8_UINT,
- PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM,
- PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM_SRGB,
- PVRSRV_PIXEL_FORMAT_A8B8G8R8_SINT,
- PVRSRV_PIXEL_FORMAT_A8B8G8R8_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_G8R8,
- PVRSRV_PIXEL_FORMAT_G8R8_UINT,
- PVRSRV_PIXEL_FORMAT_G8R8_UNORM,
- PVRSRV_PIXEL_FORMAT_G8R8_SINT,
- PVRSRV_PIXEL_FORMAT_G8R8_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_A8,
- PVRSRV_PIXEL_FORMAT_R8,
- PVRSRV_PIXEL_FORMAT_R8_UINT,
- PVRSRV_PIXEL_FORMAT_R8_UNORM,
- PVRSRV_PIXEL_FORMAT_R8_SINT,
- PVRSRV_PIXEL_FORMAT_R8_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_A2B10G10R10,
- PVRSRV_PIXEL_FORMAT_A2B10G10R10_UNORM,
- PVRSRV_PIXEL_FORMAT_A2B10G10R10_UINT,
-
-
- PVRSRV_PIXEL_FORMAT_B10G11R11,
- PVRSRV_PIXEL_FORMAT_B10G11R11F,
-
-
- PVRSRV_PIXEL_FORMAT_X24G8R32,
- PVRSRV_PIXEL_FORMAT_G8R24,
- PVRSRV_PIXEL_FORMAT_X8R24,
- PVRSRV_PIXEL_FORMAT_E5B9G9R9,
- PVRSRV_PIXEL_FORMAT_R1,
-
- PVRSRV_PIXEL_FORMAT_BC1,
- PVRSRV_PIXEL_FORMAT_BC1_UNORM,
- PVRSRV_PIXEL_FORMAT_BC1_SRGB,
- PVRSRV_PIXEL_FORMAT_BC2,
- PVRSRV_PIXEL_FORMAT_BC2_UNORM,
- PVRSRV_PIXEL_FORMAT_BC2_SRGB,
- PVRSRV_PIXEL_FORMAT_BC3,
- PVRSRV_PIXEL_FORMAT_BC3_UNORM,
- PVRSRV_PIXEL_FORMAT_BC3_SRGB,
- PVRSRV_PIXEL_FORMAT_BC4,
- PVRSRV_PIXEL_FORMAT_BC4_UNORM,
- PVRSRV_PIXEL_FORMAT_BC4_SNORM,
- PVRSRV_PIXEL_FORMAT_BC5,
- PVRSRV_PIXEL_FORMAT_BC5_UNORM,
- PVRSRV_PIXEL_FORMAT_BC5_SNORM,
-
-
- PVRSRV_PIXEL_FORMAT_L_F16,
- PVRSRV_PIXEL_FORMAT_L_F16_REP,
- PVRSRV_PIXEL_FORMAT_L_F16_A_F16,
- PVRSRV_PIXEL_FORMAT_A_F16,
- PVRSRV_PIXEL_FORMAT_B16G16R16F,
-
- PVRSRV_PIXEL_FORMAT_L_F32,
- PVRSRV_PIXEL_FORMAT_A_F32,
- PVRSRV_PIXEL_FORMAT_L_F32_A_F32,
-
-
- PVRSRV_PIXEL_FORMAT_PVRTC2,
- PVRSRV_PIXEL_FORMAT_PVRTC4,
- PVRSRV_PIXEL_FORMAT_PVRTCII2,
- PVRSRV_PIXEL_FORMAT_PVRTCII4,
- PVRSRV_PIXEL_FORMAT_PVRTCIII,
- PVRSRV_PIXEL_FORMAT_PVRO8,
- PVRSRV_PIXEL_FORMAT_PVRO88,
- PVRSRV_PIXEL_FORMAT_PT1,
- PVRSRV_PIXEL_FORMAT_PT2,
- PVRSRV_PIXEL_FORMAT_PT4,
- PVRSRV_PIXEL_FORMAT_PT8,
- PVRSRV_PIXEL_FORMAT_PTW,
- PVRSRV_PIXEL_FORMAT_PTB,
- PVRSRV_PIXEL_FORMAT_MONO8,
- PVRSRV_PIXEL_FORMAT_MONO16,
-
-
- PVRSRV_PIXEL_FORMAT_C0_YUYV,
- PVRSRV_PIXEL_FORMAT_C0_UYVY,
- PVRSRV_PIXEL_FORMAT_C0_YVYU,
- PVRSRV_PIXEL_FORMAT_C0_VYUY,
- PVRSRV_PIXEL_FORMAT_C1_YUYV,
- PVRSRV_PIXEL_FORMAT_C1_UYVY,
- PVRSRV_PIXEL_FORMAT_C1_YVYU,
- PVRSRV_PIXEL_FORMAT_C1_VYUY,
-
-
- PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_UV,
- PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_VU,
- PVRSRV_PIXEL_FORMAT_C0_YUV420_3P,
- PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_UV,
- PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_VU,
- PVRSRV_PIXEL_FORMAT_C1_YUV420_3P,
-
- PVRSRV_PIXEL_FORMAT_A2B10G10R10F,
- PVRSRV_PIXEL_FORMAT_B8G8R8_SINT,
- PVRSRV_PIXEL_FORMAT_PVRF32SIGNMASK,
-
- PVRSRV_PIXEL_FORMAT_FORCE_I32 = 0x7fffffff,
+ PVRSRV_PIXEL_FORMAT_UNKNOWN = 0,
+ PVRSRV_PIXEL_FORMAT_RGB565 = 1,
+ PVRSRV_PIXEL_FORMAT_RGB555 = 2,
+ PVRSRV_PIXEL_FORMAT_RGB888 = 3,
+ PVRSRV_PIXEL_FORMAT_BGR888 = 4,
+ PVRSRV_PIXEL_FORMAT_GREY_SCALE = 8,
+ PVRSRV_PIXEL_FORMAT_PAL12 = 13,
+ PVRSRV_PIXEL_FORMAT_PAL8 = 14,
+ PVRSRV_PIXEL_FORMAT_PAL4 = 15,
+ PVRSRV_PIXEL_FORMAT_PAL2 = 16,
+ PVRSRV_PIXEL_FORMAT_PAL1 = 17,
+ PVRSRV_PIXEL_FORMAT_ARGB1555 = 18,
+ PVRSRV_PIXEL_FORMAT_ARGB4444 = 19,
+ PVRSRV_PIXEL_FORMAT_ARGB8888 = 20,
+ PVRSRV_PIXEL_FORMAT_ABGR8888 = 21,
+ PVRSRV_PIXEL_FORMAT_YV12 = 22,
+ PVRSRV_PIXEL_FORMAT_I420 = 23,
+ PVRSRV_PIXEL_FORMAT_IMC2 = 25,
+ PVRSRV_PIXEL_FORMAT_XRGB8888 = 26,
+ PVRSRV_PIXEL_FORMAT_XBGR8888 = 27,
+ PVRSRV_PIXEL_FORMAT_BGRA8888 = 28,
+ PVRSRV_PIXEL_FORMAT_XRGB4444 = 29,
+ PVRSRV_PIXEL_FORMAT_ARGB8332 = 30,
+ PVRSRV_PIXEL_FORMAT_A2RGB10 = 31,
+ PVRSRV_PIXEL_FORMAT_A2BGR10 = 32,
+ PVRSRV_PIXEL_FORMAT_P8 = 33,
+ PVRSRV_PIXEL_FORMAT_L8 = 34,
+ PVRSRV_PIXEL_FORMAT_A8L8 = 35,
+ PVRSRV_PIXEL_FORMAT_A4L4 = 36,
+ PVRSRV_PIXEL_FORMAT_L16 = 37,
+ PVRSRV_PIXEL_FORMAT_L6V5U5 = 38,
+ PVRSRV_PIXEL_FORMAT_V8U8 = 39,
+ PVRSRV_PIXEL_FORMAT_V16U16 = 40,
+ PVRSRV_PIXEL_FORMAT_QWVU8888 = 41,
+ PVRSRV_PIXEL_FORMAT_XLVU8888 = 42,
+ PVRSRV_PIXEL_FORMAT_QWVU16 = 43,
+ PVRSRV_PIXEL_FORMAT_D16 = 44,
+ PVRSRV_PIXEL_FORMAT_D24S8 = 45,
+ PVRSRV_PIXEL_FORMAT_D24X8 = 46,
+
+
+ PVRSRV_PIXEL_FORMAT_ABGR16 = 47,
+ PVRSRV_PIXEL_FORMAT_ABGR16F = 48,
+ PVRSRV_PIXEL_FORMAT_ABGR32 = 49,
+ PVRSRV_PIXEL_FORMAT_ABGR32F = 50,
+ PVRSRV_PIXEL_FORMAT_B10GR11 = 51,
+ PVRSRV_PIXEL_FORMAT_GR88 = 52,
+ PVRSRV_PIXEL_FORMAT_BGR32 = 53,
+ PVRSRV_PIXEL_FORMAT_GR32 = 54,
+ PVRSRV_PIXEL_FORMAT_E5BGR9 = 55,
+
+
+ PVRSRV_PIXEL_FORMAT_RESERVED1 = 56,
+ PVRSRV_PIXEL_FORMAT_RESERVED2 = 57,
+ PVRSRV_PIXEL_FORMAT_RESERVED3 = 58,
+ PVRSRV_PIXEL_FORMAT_RESERVED4 = 59,
+ PVRSRV_PIXEL_FORMAT_RESERVED5 = 60,
+
+
+ PVRSRV_PIXEL_FORMAT_R8G8_B8G8 = 61,
+ PVRSRV_PIXEL_FORMAT_G8R8_G8B8 = 62,
+
+
+ PVRSRV_PIXEL_FORMAT_NV11 = 63,
+ PVRSRV_PIXEL_FORMAT_NV12 = 64,
+
+
+ PVRSRV_PIXEL_FORMAT_YUY2 = 65,
+ PVRSRV_PIXEL_FORMAT_YUV420 = 66,
+ PVRSRV_PIXEL_FORMAT_YUV444 = 67,
+ PVRSRV_PIXEL_FORMAT_VUY444 = 68,
+ PVRSRV_PIXEL_FORMAT_YUYV = 69,
+ PVRSRV_PIXEL_FORMAT_YVYU = 70,
+ PVRSRV_PIXEL_FORMAT_UYVY = 71,
+ PVRSRV_PIXEL_FORMAT_VYUY = 72,
+
+ PVRSRV_PIXEL_FORMAT_FOURCC_ORG_UYVY = 73,
+ PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YUYV = 74,
+ PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YVYU = 75,
+ PVRSRV_PIXEL_FORMAT_FOURCC_ORG_VYUY = 76,
+ PVRSRV_PIXEL_FORMAT_FOURCC_ORG_AYUV = 77,
+
+
+ PVRSRV_PIXEL_FORMAT_A32B32G32R32 = 78,
+ PVRSRV_PIXEL_FORMAT_A32B32G32R32F = 79,
+ PVRSRV_PIXEL_FORMAT_A32B32G32R32_UINT = 80,
+ PVRSRV_PIXEL_FORMAT_A32B32G32R32_SINT = 81,
+
+
+ PVRSRV_PIXEL_FORMAT_B32G32R32 = 82,
+ PVRSRV_PIXEL_FORMAT_B32G32R32F = 83,
+ PVRSRV_PIXEL_FORMAT_B32G32R32_UINT = 84,
+ PVRSRV_PIXEL_FORMAT_B32G32R32_SINT = 85,
+
+
+ PVRSRV_PIXEL_FORMAT_G32R32 = 86,
+ PVRSRV_PIXEL_FORMAT_G32R32F = 87,
+ PVRSRV_PIXEL_FORMAT_G32R32_UINT = 88,
+ PVRSRV_PIXEL_FORMAT_G32R32_SINT = 89,
+
+
+ PVRSRV_PIXEL_FORMAT_D32F = 90,
+ PVRSRV_PIXEL_FORMAT_R32 = 91,
+ PVRSRV_PIXEL_FORMAT_R32F = 92,
+ PVRSRV_PIXEL_FORMAT_R32_UINT = 93,
+ PVRSRV_PIXEL_FORMAT_R32_SINT = 94,
+
+
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16 = 95,
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16F = 96,
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16_SINT = 97,
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16_SNORM = 98,
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16_UINT = 99,
+ PVRSRV_PIXEL_FORMAT_A16B16G16R16_UNORM = 100,
+
+
+ PVRSRV_PIXEL_FORMAT_G16R16 = 101,
+ PVRSRV_PIXEL_FORMAT_G16R16F = 102,
+ PVRSRV_PIXEL_FORMAT_G16R16_UINT = 103,
+ PVRSRV_PIXEL_FORMAT_G16R16_UNORM = 104,
+ PVRSRV_PIXEL_FORMAT_G16R16_SINT = 105,
+ PVRSRV_PIXEL_FORMAT_G16R16_SNORM = 106,
+
+
+ PVRSRV_PIXEL_FORMAT_R16 = 107,
+ PVRSRV_PIXEL_FORMAT_R16F = 108,
+ PVRSRV_PIXEL_FORMAT_R16_UINT = 109,
+ PVRSRV_PIXEL_FORMAT_R16_UNORM = 110,
+ PVRSRV_PIXEL_FORMAT_R16_SINT = 111,
+ PVRSRV_PIXEL_FORMAT_R16_SNORM = 112,
+
+
+ PVRSRV_PIXEL_FORMAT_X8R8G8B8 = 113,
+ PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM = 114,
+ PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM_SRGB = 115,
+
+ PVRSRV_PIXEL_FORMAT_A8R8G8B8 = 116,
+ PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM = 117,
+ PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM_SRGB = 118,
+
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8 = 119,
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8_UINT = 120,
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM = 121,
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM_SRGB = 122,
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8_SINT = 123,
+ PVRSRV_PIXEL_FORMAT_A8B8G8R8_SNORM = 124,
+
+
+ PVRSRV_PIXEL_FORMAT_G8R8 = 125,
+ PVRSRV_PIXEL_FORMAT_G8R8_UINT = 126,
+ PVRSRV_PIXEL_FORMAT_G8R8_UNORM = 127,
+ PVRSRV_PIXEL_FORMAT_G8R8_SINT = 128,
+ PVRSRV_PIXEL_FORMAT_G8R8_SNORM = 129,
+
+
+ PVRSRV_PIXEL_FORMAT_A8 = 130,
+ PVRSRV_PIXEL_FORMAT_R8 = 131,
+ PVRSRV_PIXEL_FORMAT_R8_UINT = 132,
+ PVRSRV_PIXEL_FORMAT_R8_UNORM = 133,
+ PVRSRV_PIXEL_FORMAT_R8_SINT = 134,
+ PVRSRV_PIXEL_FORMAT_R8_SNORM = 135,
+
+
+ PVRSRV_PIXEL_FORMAT_A2B10G10R10 = 136,
+ PVRSRV_PIXEL_FORMAT_A2B10G10R10_UNORM = 137,
+ PVRSRV_PIXEL_FORMAT_A2B10G10R10_UINT = 138,
+
+
+ PVRSRV_PIXEL_FORMAT_B10G11R11 = 139,
+ PVRSRV_PIXEL_FORMAT_B10G11R11F = 140,
+
+
+ PVRSRV_PIXEL_FORMAT_X24G8R32 = 141,
+ PVRSRV_PIXEL_FORMAT_G8R24 = 142,
+ PVRSRV_PIXEL_FORMAT_X8R24 = 143,
+ PVRSRV_PIXEL_FORMAT_E5B9G9R9 = 144,
+ PVRSRV_PIXEL_FORMAT_R1 = 145,
+
+ PVRSRV_PIXEL_FORMAT_RESERVED6 = 146,
+ PVRSRV_PIXEL_FORMAT_RESERVED7 = 147,
+ PVRSRV_PIXEL_FORMAT_RESERVED8 = 148,
+ PVRSRV_PIXEL_FORMAT_RESERVED9 = 149,
+ PVRSRV_PIXEL_FORMAT_RESERVED10 = 150,
+ PVRSRV_PIXEL_FORMAT_RESERVED11 = 151,
+ PVRSRV_PIXEL_FORMAT_RESERVED12 = 152,
+ PVRSRV_PIXEL_FORMAT_RESERVED13 = 153,
+ PVRSRV_PIXEL_FORMAT_RESERVED14 = 154,
+ PVRSRV_PIXEL_FORMAT_RESERVED15 = 155,
+ PVRSRV_PIXEL_FORMAT_RESERVED16 = 156,
+ PVRSRV_PIXEL_FORMAT_RESERVED17 = 157,
+ PVRSRV_PIXEL_FORMAT_RESERVED18 = 158,
+ PVRSRV_PIXEL_FORMAT_RESERVED19 = 159,
+ PVRSRV_PIXEL_FORMAT_RESERVED20 = 160,
+
+
+ PVRSRV_PIXEL_FORMAT_UBYTE4 = 161,
+ PVRSRV_PIXEL_FORMAT_SHORT4 = 162,
+ PVRSRV_PIXEL_FORMAT_SHORT4N = 163,
+ PVRSRV_PIXEL_FORMAT_USHORT4N = 164,
+ PVRSRV_PIXEL_FORMAT_SHORT2N = 165,
+ PVRSRV_PIXEL_FORMAT_SHORT2 = 166,
+ PVRSRV_PIXEL_FORMAT_USHORT2N = 167,
+ PVRSRV_PIXEL_FORMAT_UDEC3 = 168,
+ PVRSRV_PIXEL_FORMAT_DEC3N = 169,
+ PVRSRV_PIXEL_FORMAT_F16_2 = 170,
+ PVRSRV_PIXEL_FORMAT_F16_4 = 171,
+
+
+ PVRSRV_PIXEL_FORMAT_L_F16 = 172,
+ PVRSRV_PIXEL_FORMAT_L_F16_REP = 173,
+ PVRSRV_PIXEL_FORMAT_L_F16_A_F16 = 174,
+ PVRSRV_PIXEL_FORMAT_A_F16 = 175,
+ PVRSRV_PIXEL_FORMAT_B16G16R16F = 176,
+
+ PVRSRV_PIXEL_FORMAT_L_F32 = 177,
+ PVRSRV_PIXEL_FORMAT_A_F32 = 178,
+ PVRSRV_PIXEL_FORMAT_L_F32_A_F32 = 179,
+
+
+ PVRSRV_PIXEL_FORMAT_PVRTC2 = 180,
+ PVRSRV_PIXEL_FORMAT_PVRTC4 = 181,
+ PVRSRV_PIXEL_FORMAT_PVRTCII2 = 182,
+ PVRSRV_PIXEL_FORMAT_PVRTCII4 = 183,
+ PVRSRV_PIXEL_FORMAT_PVRTCIII = 184,
+ PVRSRV_PIXEL_FORMAT_PVRO8 = 185,
+ PVRSRV_PIXEL_FORMAT_PVRO88 = 186,
+ PVRSRV_PIXEL_FORMAT_PT1 = 187,
+ PVRSRV_PIXEL_FORMAT_PT2 = 188,
+ PVRSRV_PIXEL_FORMAT_PT4 = 189,
+ PVRSRV_PIXEL_FORMAT_PT8 = 190,
+ PVRSRV_PIXEL_FORMAT_PTW = 191,
+ PVRSRV_PIXEL_FORMAT_PTB = 192,
+ PVRSRV_PIXEL_FORMAT_MONO8 = 193,
+ PVRSRV_PIXEL_FORMAT_MONO16 = 194,
+
+
+ PVRSRV_PIXEL_FORMAT_C0_YUYV = 195,
+ PVRSRV_PIXEL_FORMAT_C0_UYVY = 196,
+ PVRSRV_PIXEL_FORMAT_C0_YVYU = 197,
+ PVRSRV_PIXEL_FORMAT_C0_VYUY = 198,
+ PVRSRV_PIXEL_FORMAT_C1_YUYV = 199,
+ PVRSRV_PIXEL_FORMAT_C1_UYVY = 200,
+ PVRSRV_PIXEL_FORMAT_C1_YVYU = 201,
+ PVRSRV_PIXEL_FORMAT_C1_VYUY = 202,
+
+
+ PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_UV = 203,
+ PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_VU = 204,
+ PVRSRV_PIXEL_FORMAT_C0_YUV420_3P = 205,
+ PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_UV = 206,
+ PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_VU = 207,
+ PVRSRV_PIXEL_FORMAT_C1_YUV420_3P = 208,
+
+ PVRSRV_PIXEL_FORMAT_A2B10G10R10F = 209,
+ PVRSRV_PIXEL_FORMAT_B8G8R8_SINT = 210,
+ PVRSRV_PIXEL_FORMAT_PVRF32SIGNMASK = 211,
+
+ PVRSRV_PIXEL_FORMAT_ABGR4444 = 212,
+ PVRSRV_PIXEL_FORMAT_ABGR1555 = 213,
+ PVRSRV_PIXEL_FORMAT_BGR565 = 214,
+
+ PVRSRV_PIXEL_FORMAT_FORCE_I32 = 0x7fffffff
+
} PVRSRV_PIXEL_FORMAT;
typedef enum _PVRSRV_ALPHA_FORMAT_ {
IMG_UINT32 ui32ReadOpsPending;
volatile IMG_UINT32 ui32ReadOpsComplete;
-
+
IMG_UINT32 ui32LastOpDumpVal;
IMG_UINT32 ui32LastReadOpDumpVal;
IMG_HANDLE hKernelSyncInfo;
-
-} PVRSRV_CLIENT_SYNC_INFO, *PPVRSRV_CLIENT_SYNC_INFO;
+} PVRSRV_CLIENT_SYNC_INFO, *PPVRSRV_CLIENT_SYNC_INFO;
-typedef struct PVRSRV_RESOURCE_TAG
+typedef struct PVRSRV_RESOURCE_TAG
{
volatile IMG_UINT32 ui32Lock;
IMG_UINT32 ui32ID;
typedef IMG_VOID (*PFN_CMD_COMPLETE) (IMG_HANDLE);
typedef IMG_VOID (**PPFN_CMD_COMPLETE) (IMG_HANDLE);
-typedef IMG_BOOL (*PFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);
-typedef IMG_BOOL (**PPFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);
+typedef IMG_BOOL (*PFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);
+typedef IMG_BOOL (**PPFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);
typedef struct _IMG_RECT_
{
IMG_INT32 x0;
- IMG_INT32 y0;
- IMG_INT32 x1;
- IMG_INT32 y1;
+ IMG_INT32 y0;
+ IMG_INT32 x1;
+ IMG_INT32 y1;
}IMG_RECT;
typedef struct _IMG_RECT_16_
{
IMG_INT16 x0;
- IMG_INT16 y0;
- IMG_INT16 x1;
- IMG_INT16 y1;
+ IMG_INT16 y0;
+ IMG_INT16 x1;
+ IMG_INT16 y1;
}IMG_RECT_16;
-typedef PVRSRV_ERROR (*PFN_GET_BUFFER_ADDR)(IMG_HANDLE,
- IMG_HANDLE,
- IMG_SYS_PHYADDR**,
- IMG_SIZE_T*,
- IMG_VOID**,
- IMG_HANDLE*,
- IMG_BOOL*);
+typedef PVRSRV_ERROR (*PFN_GET_BUFFER_ADDR)(IMG_HANDLE,
+ IMG_HANDLE,
+ IMG_SYS_PHYADDR**,
+ IMG_SIZE_T*,
+ IMG_VOID**,
+ IMG_HANDLE*,
+ IMG_BOOL*,
+ IMG_UINT32*);
typedef struct DISPLAY_DIMS_TAG
typedef struct DISPLAY_INFO_TAG
{
+
IMG_UINT32 ui32MaxSwapChains;
IMG_UINT32 ui32MaxSwapChainBuffers;
-
+
IMG_UINT32 ui32MinSwapInterval;
-
+
IMG_UINT32 ui32MaxSwapInterval;
-
+
+ IMG_UINT32 ui32PhysicalWidthmm;
+ IMG_UINT32 ui32PhysicalHeightmm;
+
IMG_CHAR szDisplayName[MAX_DISPLAY_NAME_SIZE];
-
#if defined(SUPPORT_HW_CURSOR)
+
IMG_UINT16 ui32CursorWidth;
IMG_UINT16 ui32CursorHeight;
#endif
-
} DISPLAY_INFO;
typedef struct ACCESS_INFO_TAG
IMG_UINT32 ui32SysPhysBaseAddress;
IMG_UINT32 ui32SysSize;
IMG_UINT32 ui32DevIRQ;
-}ACCESS_INFO;
+}ACCESS_INFO;
typedef struct PVRSRV_CURSOR_SHAPE_TAG
IMG_UINT16 ui16Height;
IMG_INT16 i16XHot;
IMG_INT16 i16YHot;
-
+
IMG_VOID* pvMask;
IMG_INT16 i16MaskByteStride;
-
+
IMG_VOID* pvColour;
IMG_INT16 i16ColourByteStride;
- PVRSRV_PIXEL_FORMAT eColourPixelFormat;
+ PVRSRV_PIXEL_FORMAT eColourPixelFormat;
} PVRSRV_CURSOR_SHAPE;
#define PVRSRV_SET_CURSOR_VISIBILITY (1<<0)
{
IMG_UINT32 ui32Flags;
-
+
IMG_BOOL bVisible;
-
+
IMG_INT16 i16XPos;
IMG_INT16 i16YPos;
-
+
PVRSRV_CURSOR_SHAPE sCursorShape;
-
+
IMG_UINT32 ui32Rotation;
-
+
} PVRSRV_CURSOR_INFO;
#define PVRSRV_BC_FLAGS_YUVCSC_BT601 (0 << 1)
#define PVRSRV_BC_FLAGS_YUVCSC_BT709 (1 << 1)
+#define MAX_BUFFER_DEVICE_NAME_SIZE (50)
+
typedef struct BUFFER_INFO_TAG
{
IMG_UINT32 ui32BufferCount;
IMG_UINT32 ui32Width;
IMG_UINT32 ui32Height;
IMG_UINT32 ui32Flags;
+ IMG_CHAR szDeviceName[MAX_BUFFER_DEVICE_NAME_SIZE];
} BUFFER_INFO;
typedef enum _OVERLAY_DEINTERLACE_MODE_
*
******************************************************************************/
-#if defined(DEBUG_PVR) || defined (INTERNAL_TEST)
+#if defined(DEBUG) || defined (INTERNAL_TEST)
#define DEBUG_SET_OFFSET OPTIONS_BIT0
#define OPTIONS_BIT0 0x1
#else
#define OPTIONS_BIT8 0x0
#endif
-#if defined(SGX_FEATURE_DCU) || defined (INTERNAL_TEST)
+#if defined(SGX_FEATURE_WRITEBACK_DCU) || defined (INTERNAL_TEST)
#define SGX_FEATURE_DCU_SET_OFFSET OPTIONS_BIT9
#define OPTIONS_BIT9 (0x1 << 9)
#else
#define OPTIONS_BIT20 0x0
#endif
-#if defined(SGX_LOW_LATENCY_SCHEDULING) || defined (INTERNAL_TEST)
+#if defined(SUPPORT_SGX_LOW_LATENCY_SCHEDULING) || defined (INTERNAL_TEST)
#define SUPPORT_SGX_LOW_LATENCY_SCHEDULING_SET_OFFSET OPTIONS_BIT21
#define OPTIONS_BIT21 (0x1 << 21)
#else
OPTIONS_BIT19 |\
OPTIONS_BIT20 |\
OPTIONS_BIT21 |\
+ OPTIONS_BIT22 |\
OPTIONS_HIGHBYTE
#endif
#define SGX_MAX_HEAP_ID 13
+#if defined(SGX543) || defined(SGX544) || defined(SGX554)
+#define SGX_USE_CODE_SEGMENT_RANGE_BITS 23
+#else
+#define SGX_USE_CODE_SEGMENT_RANGE_BITS 19
+#endif
#define SGX_MAX_TA_STATUS_VALS 32
-#define SGX_MAX_3D_STATUS_VALS 3
+#define SGX_MAX_3D_STATUS_VALS 4
#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
#define SGX_MAX_TA_DST_SYNCS 1
#define SGX_MAX_TA_SRC_SYNCS 1
#define SGX_MAX_3D_SRC_SYNCS 4
#else
-#if defined(ANDROID)
-#define SGX_MAX_SRC_SYNCS 8
-#else
#define SGX_MAX_SRC_SYNCS 4
-#endif
+#define SGX_MAX_DST_SYNCS 1
#endif
-#ifdef SUPPORT_SGX_HWPERF
+#if defined(SGX_FEATURE_EXTENDED_PERF_COUNTERS)
+#define PVRSRV_SGX_HWPERF_NUM_COUNTERS 8
+#else
#define PVRSRV_SGX_HWPERF_NUM_COUNTERS 9
+#endif
#define PVRSRV_SGX_HWPERF_INVALID 0x1
#define PVRSRV_SGX_HWPERF_TA 0x3
#define PVRSRV_SGX_HWPERF_3D 0x4
#define PVRSRV_SGX_HWPERF_2D 0x5
+#define PVRSRV_SGX_HWPERF_POWER 0x6
+#define PVRSRV_SGX_HWPERF_PERIODIC 0x7
#define PVRSRV_SGX_HWPERF_MK_EVENT 0x101
#define PVRSRV_SGX_HWPERF_MK_TA 0x102
#define PVRSRV_SGX_HWPERF_TYPE_3D_END (PVRSRV_SGX_HWPERF_3D | PVRSRV_SGX_HWPERF_TYPE_OP_END)
#define PVRSRV_SGX_HWPERF_TYPE_2D_START (PVRSRV_SGX_HWPERF_2D | PVRSRV_SGX_HWPERF_TYPE_OP_START)
#define PVRSRV_SGX_HWPERF_TYPE_2D_END (PVRSRV_SGX_HWPERF_2D | PVRSRV_SGX_HWPERF_TYPE_OP_END)
+#define PVRSRV_SGX_HWPERF_TYPE_POWER_START (PVRSRV_SGX_HWPERF_POWER | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#define PVRSRV_SGX_HWPERF_TYPE_POWER_END (PVRSRV_SGX_HWPERF_POWER | PVRSRV_SGX_HWPERF_TYPE_OP_END)
+#define PVRSRV_SGX_HWPERF_TYPE_PERIODIC (PVRSRV_SGX_HWPERF_PERIODIC)
#define PVRSRV_SGX_HWPERF_TYPE_MK_EVENT_START (PVRSRV_SGX_HWPERF_MK_EVENT | PVRSRV_SGX_HWPERF_TYPE_OP_START)
#define PVRSRV_SGX_HWPERF_TYPE_MK_EVENT_END (PVRSRV_SGX_HWPERF_MK_EVENT | PVRSRV_SGX_HWPERF_TYPE_OP_END)
#define PVRSRV_SGX_HWPERF_TYPE_MK_2D_START (PVRSRV_SGX_HWPERF_MK_2D | PVRSRV_SGX_HWPERF_TYPE_OP_START)
#define PVRSRV_SGX_HWPERF_TYPE_MK_2D_END (PVRSRV_SGX_HWPERF_MK_2D | PVRSRV_SGX_HWPERF_TYPE_OP_END)
-#define PVRSRV_SGX_HWPERF_OFF (0x0)
-#define PVRSRV_SGX_HWPERF_GRAPHICS_ON (1UL << 0)
-#define PVRSRV_SGX_HWPERF_MK_EXECUTION_ON (1UL << 1)
+#define PVRSRV_SGX_HWPERF_STATUS_OFF (0x0)
+#define PVRSRV_SGX_HWPERF_STATUS_RESET_COUNTERS (1UL << 0)
+#define PVRSRV_SGX_HWPERF_STATUS_GRAPHICS_ON (1UL << 1)
+#define PVRSRV_SGX_HWPERF_STATUS_PERIODIC_ON (1UL << 2)
+#define PVRSRV_SGX_HWPERF_STATUS_MK_EXECUTION_ON (1UL << 3)
typedef struct _PVRSRV_SGX_HWPERF_CB_ENTRY_
IMG_UINT32 ui32FrameNo;
IMG_UINT32 ui32Type;
IMG_UINT32 ui32Ordinal;
+ IMG_UINT32 ui32Info;
IMG_UINT32 ui32Clocksx16;
- IMG_UINT32 ui32Counters[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+ IMG_UINT32 ui32Counters[SGX_FEATURE_MP_CORE_COUNT][PVRSRV_SGX_HWPERF_NUM_COUNTERS];
} PVRSRV_SGX_HWPERF_CB_ENTRY;
-typedef struct _PVRSRV_SGX_HWPERF_CBDATA_
-{
- IMG_UINT32 ui32FrameNo;
- IMG_UINT32 ui32Type;
- IMG_UINT32 ui32StartTimeWraps;
- IMG_UINT32 ui32StartTime;
- IMG_UINT32 ui32EndTimeWraps;
- IMG_UINT32 ui32EndTime;
- IMG_UINT32 ui32ClockSpeed;
- IMG_UINT32 ui32TimeMax;
-} PVRSRV_SGX_HWPERF_CBDATA;
-
-
-typedef struct _SGX_MISC_INFO_HWPERF_RETRIEVE_CB
-{
- PVRSRV_SGX_HWPERF_CBDATA* psHWPerfData;
- IMG_UINT32 ui32ArraySize;
- IMG_UINT32 ui32DataCount;
- IMG_UINT32 ui32Time;
-} SGX_MISC_INFO_HWPERF_RETRIEVE_CB;
-#endif
-
-
typedef struct _CTL_STATUS_
{
IMG_DEV_VIRTADDR sStatusDevAddr;
SGX_MISC_INFO_REQUEST_DRIVER_SGXREV,
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
SGX_MISC_INFO_REQUEST_MEMREAD,
-#endif
-#if defined(SUPPORT_SGX_HWPERF)
- SGX_MISC_INFO_REQUEST_SET_HWPERF_STATUS,
- SGX_MISC_INFO_REQUEST_HWPERF_CB_ON,
- SGX_MISC_INFO_REQUEST_HWPERF_CB_OFF,
- SGX_MISC_INFO_REQUEST_HWPERF_RETRIEVE_CB,
+ SGX_MISC_INFO_REQUEST_MEMCOPY,
#endif
+ SGX_MISC_INFO_REQUEST_SET_HWPERF_STATUS,
#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
SGX_MISC_INFO_REQUEST_SET_BREAKPOINT,
+ SGX_MISC_INFO_REQUEST_WAIT_FOR_BREAKPOINT,
+ SGX_MISC_INFO_REQUEST_POLL_BREAKPOINT,
+ SGX_MISC_INFO_REQUEST_RESUME_BREAKPOINT,
#endif
SGX_MISC_INFO_DUMP_DEBUG_INFO,
SGX_MISC_INFO_PANIC,
+ SGX_MISC_INFO_REQUEST_SPM,
+ SGX_MISC_INFO_REQUEST_ACTIVEPOWER,
+ SGX_MISC_INFO_REQUEST_LOCKUPS,
SGX_MISC_INFO_REQUEST_FORCE_I16 = 0x7fff
} SGX_MISC_INFO_REQUEST;
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
IMG_UINT32 ui32DeviceMemValue;
#endif
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
+ IMG_DEV_VIRTADDR sDevVAEDMStatusBuffer;
+ IMG_PVOID pvEDMStatusBuffer;
+#endif
} PVRSRV_SGX_MISCINFO_FEATURES;
+typedef struct _PVRSRV_SGX_MISCINFO_LOCKUPS
+{
+ IMG_UINT32 ui32HostDetectedLockups;
+ IMG_UINT32 ui32uKernelDetectedLockups;
+} PVRSRV_SGX_MISCINFO_LOCKUPS;
+
+
+typedef struct _PVRSRV_SGX_MISCINFO_ACTIVEPOWER
+{
+ IMG_UINT32 ui32NumActivePowerEvents;
+} PVRSRV_SGX_MISCINFO_ACTIVEPOWER;
+
+
+typedef struct _PVRSRV_SGX_MISCINFO_SPM
+{
+ IMG_HANDLE hRTDataSet;
+ IMG_UINT32 ui32NumOutOfMemSignals;
+ IMG_UINT32 ui32NumSPMRenders;
+} PVRSRV_SGX_MISCINFO_SPM;
+
+
#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
typedef struct _SGX_BREAKPOINT_INFO
{
IMG_BOOL bBPEnable;
+ IMG_UINT32 ui32BPIndex;
+ IMG_UINT32 ui32DataMasterMask;
- IMG_UINT32 ui32BPIndex;
+ IMG_DEV_VIRTADDR sBPDevVAddr, sBPDevVAddrEnd;
+
+ IMG_BOOL bTrapped;
+
+ IMG_BOOL bRead;
+
+ IMG_BOOL bWrite;
+
+ IMG_BOOL bTrappedBP;
- IMG_DEV_VIRTADDR sBPDevVAddr;
+ IMG_UINT32 ui32CoreNum;
+ IMG_DEV_VIRTADDR sTrappedBPDevVAddr;
+ IMG_UINT32 ui32TrappedBPBurstLength;
+ IMG_BOOL bTrappedBPRead;
+ IMG_UINT32 ui32TrappedBPDataMaster;
+ IMG_UINT32 ui32TrappedBPTag;
} SGX_BREAKPOINT_INFO;
#endif
+
+typedef struct _PVRSRV_SGX_MISCINFO_SET_HWPERF_STATUS
+{
+
+ IMG_UINT32 ui32NewHWPerfStatus;
+
+ #if defined(SGX_FEATURE_EXTENDED_PERF_COUNTERS)
+
+ IMG_UINT32 aui32PerfGroup[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+
+ IMG_UINT32 aui32PerfBit[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+ #else
+
+ IMG_UINT32 ui32PerfGroup;
+ #endif
+} PVRSRV_SGX_MISCINFO_SET_HWPERF_STATUS;
+
+
typedef struct _SGX_MISC_INFO_
{
SGX_MISC_INFO_REQUEST eRequest;
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
- IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEV_VIRTADDR sDevVAddrSrc;
+ IMG_DEV_VIRTADDR sDevVAddrDest;
IMG_HANDLE hDevMemContext;
#endif
union
IMG_UINT32 reserved;
PVRSRV_SGX_MISCINFO_FEATURES sSGXFeatures;
IMG_UINT32 ui32SGXClockSpeed;
+ PVRSRV_SGX_MISCINFO_ACTIVEPOWER sActivePower;
+ PVRSRV_SGX_MISCINFO_LOCKUPS sLockups;
+ PVRSRV_SGX_MISCINFO_SPM sSPM;
#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
SGX_BREAKPOINT_INFO sSGXBreakpointInfo;
#endif
-#ifdef SUPPORT_SGX_HWPERF
- IMG_UINT32 ui32NewHWPerfStatus;
- SGX_MISC_INFO_HWPERF_RETRIEVE_CB sRetrieveCB;
-#endif
+ PVRSRV_SGX_MISCINFO_SET_HWPERF_STATUS sSetHWPerfStatus;
} uData;
} SGX_MISC_INFO;
#define SGX_MAX_2D_BLIT_CMD_SIZE 26
#define SGX_MAX_2D_SRC_SYNC_OPS 3
#endif
-#define SGX_MAX_TRANSFER_STATUS_VALS 2
+#define SGX_MAX_TRANSFER_STATUS_VALS 2
#define SGX_MAX_TRANSFER_SYNC_OPS 5
#endif
*
******************************************************************************/
+#if defined(__linux__)
+#include <linux/string.h>
+#else
+#include <string.h>
+#endif
+
#include "bufferclass_example.h"
+
+#define BUFFERCLASS_DEVICE_NAME "Example Bufferclass Device (SW)"
+
static void *gpvAnchor = NULL;
static PFN_BC_GET_PVRJTABLE pfnGetPVRJTable = IMG_NULL;
}
-static PVRSRV_ERROR OpenBCDevice(IMG_HANDLE *phDevice)
+static PVRSRV_ERROR OpenBCDevice(IMG_UINT32 ui32DeviceID, IMG_HANDLE *phDevice)
{
BC_EXAMPLE_DEVINFO *psDevInfo;
+
+
+
+
+ UNREFERENCED_PARAMETER(ui32DeviceID);
psDevInfo = GetAnchorPtr();
}
-static PVRSRV_ERROR CloseBCDevice(IMG_HANDLE hDevice)
+static PVRSRV_ERROR CloseBCDevice(IMG_UINT32 ui32DeviceID, IMG_HANDLE hDevice)
{
+ UNREFERENCED_PARAMETER(ui32DeviceID);
UNREFERENCED_PARAMETER(hDevice);
return (PVRSRV_OK);
IMG_UINT32 *pui32ByteSize,
IMG_VOID **ppvCpuVAddr,
IMG_HANDLE *phOSMapInfo,
- IMG_BOOL *pbIsContiguous)
+ IMG_BOOL *pbIsContiguous,
+ IMG_UINT32 *pui32TilingStride)
{
BC_EXAMPLE_BUFFER *psBuffer;
+ PVR_UNREFERENCED_PARAMETER(pui32TilingStride);
+
if(!hDevice || !hBuffer || !ppsSysAddr || !pui32ByteSize)
{
return (PVRSRV_ERROR_INVALID_PARAMS);
psBuffer = (BC_EXAMPLE_BUFFER *) hBuffer;
- *ppsSysAddr = &psBuffer->sPageAlignSysAddr;
*ppvCpuVAddr = psBuffer->sCPUVAddr;
+ *phOSMapInfo = IMG_NULL;
*pui32ByteSize = (IMG_UINT32)psBuffer->ulSize;
- *phOSMapInfo = IMG_NULL;
+#if defined(BC_DISCONTIG_BUFFERS)
+ *ppsSysAddr = psBuffer->psSysAddr;
+ *pbIsContiguous = IMG_FALSE;
+#else
+ *ppsSysAddr = &psBuffer->sPageAlignSysAddr;
*pbIsContiguous = IMG_TRUE;
+#endif
return (PVRSRV_OK);
}
psDevInfo->sBufferInfo.ui32BufferDeviceID = BC_EXAMPLE_DEVICEID;
psDevInfo->sBufferInfo.ui32Flags = 0;
psDevInfo->sBufferInfo.ui32BufferCount = (IMG_UINT32)psDevInfo->ulNumBuffers;
+
+ strncpy(psDevInfo->sBufferInfo.szDeviceName, BUFFERCLASS_DEVICE_NAME, MAX_BUFFER_DEVICE_NAME_SIZE);
if(psDevInfo->sPVRJTable.pfnPVRSRVRegisterBCDevice (&psDevInfo->sBCJTable,
- &psDevInfo->ulDeviceID ) != PVRSRV_OK)
+ (IMG_UINT32*)&psDevInfo->ulDeviceID ) != PVRSRV_OK)
{
return (BCE_ERROR_DEVICE_REGISTER_FAILED);
}
BCE_ERROR BC_Example_Buffers_Create(void)
{
BC_EXAMPLE_DEVINFO *psDevInfo;
- IMG_CPU_PHYADDR sSystemBufferCPUPAddr;
unsigned long i;
+#if !defined(BC_DISCONTIG_BUFFERS)
+ IMG_CPU_PHYADDR sSystemBufferCPUPAddr;
+#endif
ulSize += ((BC_EXAMPLE_STRIDE >> 1) * (BC_EXAMPLE_HEIGHT >> 1) << 1);
}
+ else if(psDevInfo->sBufferInfo.pixelformat == PVRSRV_PIXEL_FORMAT_I420)
+ {
+
+ ulSize += (BC_EXAMPLE_STRIDE >> 1) * (BC_EXAMPLE_HEIGHT >> 1);
+
+
+ ulSize += (BC_EXAMPLE_STRIDE >> 1) * (BC_EXAMPLE_HEIGHT >> 1);
+ }
+#if defined(BC_DISCONTIG_BUFFERS)
+ if (BCAllocDiscontigMemory(ulSize,
+ &psDevInfo->psSystemBuffer[i].hMemHandle,
+ &psDevInfo->psSystemBuffer[i].sCPUVAddr,
+ &psDevInfo->psSystemBuffer[i].psSysAddr) != BCE_OK)
+ {
+ break;
+ }
+#else
if (BCAllocContigMemory(ulSize,
&psDevInfo->psSystemBuffer[i].hMemHandle,
{
break;
}
+ psDevInfo->psSystemBuffer[i].sSysAddr = CpuPAddrToSysPAddrBC(sSystemBufferCPUPAddr);
+ psDevInfo->psSystemBuffer[i].sPageAlignSysAddr.uiAddr = (psDevInfo->psSystemBuffer[i].sSysAddr.uiAddr & 0xFFFFF000);
+#endif
psDevInfo->ulNumBuffers++;
psDevInfo->psSystemBuffer[i].ulSize = ulSize;
- psDevInfo->psSystemBuffer[i].sSysAddr = CpuPAddrToSysPAddrBC(sSystemBufferCPUPAddr);
- psDevInfo->psSystemBuffer[i].sPageAlignSysAddr.uiAddr = (psDevInfo->psSystemBuffer[i].sSysAddr.uiAddr & 0xFFFFF000);
psDevInfo->psSystemBuffer[i].psSyncData = NULL;
}
for(i = 0; i < psDevInfo->ulNumBuffers; i++)
{
+#if defined(BC_DISCONTIG_BUFFERS)
+ BCFreeDiscontigMemory(psDevInfo->psSystemBuffer[i].ulSize,
+ psDevInfo->psSystemBuffer[i].hMemHandle,
+ psDevInfo->psSystemBuffer[i].sCPUVAddr,
+ psDevInfo->psSystemBuffer[i].psSysAddr);
+#else
BCFreeContigMemory(psDevInfo->psSystemBuffer[i].ulSize,
psDevInfo->psSystemBuffer[i].hMemHandle,
psDevInfo->psSystemBuffer[i].sCPUVAddr,
SysPAddrToCpuPAddrBC(psDevInfo->psSystemBuffer[i].sSysAddr));
+#endif
}
psDevInfo->ulNumBuffers = 0;
extern "C" {
#endif
-extern IMG_IMPORT IMG_BOOL PVRGetBufferClassJTable(PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable);
-
#define BC_EXAMPLE_NUM_BUFFERS 3
-#define YUV420 1
-#ifdef YUV420
+#define NV12 1
+#ifdef NV12
#define BC_EXAMPLE_WIDTH (320)
#define BC_EXAMPLE_HEIGHT (160)
#define BC_EXAMPLE_STRIDE (320)
#define BC_EXAMPLE_PIXELFORMAT (PVRSRV_PIXEL_FORMAT_NV12)
+#else
+#ifdef I420
+
+#define BC_EXAMPLE_WIDTH (320)
+#define BC_EXAMPLE_HEIGHT (160)
+#define BC_EXAMPLE_STRIDE (320)
+#define BC_EXAMPLE_PIXELFORMAT (PVRSRV_PIXEL_FORMAT_I420)
+
#else
#ifdef YUV422
#define BC_EXAMPLE_STRIDE (320*2)
#define BC_EXAMPLE_PIXELFORMAT (PVRSRV_PIXEL_FORMAT_RGB565)
+#endif
#endif
#endif
- IMG_SYS_PHYADDR sSysAddr;
+#if defined(BC_DISCONTIG_BUFFERS)
+ IMG_SYS_PHYADDR *psSysAddr;
+#else
+ IMG_SYS_PHYADDR sSysAddr;
IMG_SYS_PHYADDR sPageAlignSysAddr;
+#endif
IMG_CPU_VIRTADDR sCPUVAddr;
PVRSRV_SYNC_DATA *psSyncData;
void *BCAllocKernelMem(unsigned long ulSize);
void BCFreeKernelMem(void *pvMem);
+#if defined(BC_DISCONTIG_BUFFERS)
+BCE_ERROR BCAllocDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ *phMemHandle,
+ IMG_CPU_VIRTADDR *pLinAddr,
+ IMG_SYS_PHYADDR **ppPhysAddr);
+
+void BCFreeDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ hMemHandle,
+ IMG_CPU_VIRTADDR LinAddr,
+ IMG_SYS_PHYADDR *pPhysAddr);
+
+#else
BCE_ERROR BCAllocContigMemory(unsigned long ulSize,
BCE_HANDLE *phMemHandle,
BCE_HANDLE hMemHandle,
IMG_CPU_VIRTADDR LinAddr,
IMG_CPU_PHYADDR PhysAddr);
+#endif
IMG_SYS_PHYADDR CpuPAddrToSysPAddrBC(IMG_CPU_PHYADDR cpu_paddr);
IMG_CPU_PHYADDR SysPAddrToCpuPAddrBC(IMG_SYS_PHYADDR sys_paddr);
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/module.h>
+#include <linux/slab.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "bufferclass_example.h"
#include "bufferclass_example_linux.h"
+#include "bufferclass_example_private.h"
+
#include "pvrmodule.h"
#define DEVNAME "bc_example"
MODULE_SUPPORTED_DEVICE(DEVNAME);
int BC_Example_Bridge(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
-int FillBuffer(unsigned int uiBufferIndex);
-int GetBufferCount(unsigned int *puiBufferCount);
+
+#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+static struct class *psPvrClass;
+#endif
static int AssignedMajorNumber;
#define VENDOR_ID_PVR 0x1010
#define DEVICE_ID_PVR 0x1CF1
+#define DEVICE_ID1_PVR 0x1CF2
+
#define PVR_MEM_PCI_BASENUM 2
#endif
static int __init BC_Example_ModInit(void)
{
+#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+ struct device *psDev;
+#endif
+
#if defined(LMA)
struct pci_dev *psPCIDev;
int error;
#if defined(LMA)
psPCIDev = pci_get_device(VENDOR_ID_PVR, DEVICE_ID_PVR, NULL);
+ if (psPCIDev == NULL)
+ {
+
+ psPCIDev = pci_get_device(VENDOR_ID_PVR, DEVICE_ID1_PVR, NULL);
+ }
+
if (psPCIDev == NULL)
{
printk(KERN_ERR DRVNAME ": BC_Example_ModInit: pci_get_device failed\n");
printk(KERN_ERR DRVNAME ": BC_Example_ModInit: major device %d\n", AssignedMajorNumber);
#endif
+#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+
+ psPvrClass = class_create(THIS_MODULE, "bc_example");
+
+ if (IS_ERR(psPvrClass))
+ {
+ printk(KERN_ERR DRVNAME ": BC_Example_ModInit: unable to create class (%ld)", PTR_ERR(psPvrClass));
+ goto ExitUnregister;
+ }
+
+ psDev = device_create(psPvrClass, NULL, MKDEV(AssignedMajorNumber, 0),
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+ NULL,
+#endif
+ DEVNAME);
+ if (IS_ERR(psDev))
+ {
+ printk(KERN_ERR DRVNAME ": BC_Example_ModInit: unable to create device (%ld)", PTR_ERR(psDev));
+ goto ExitDestroyClass;
+ }
+#endif
+
#if defined(LMA)
g_ulMemBase = pci_resource_start(psPCIDev, PVR_MEM_PCI_BASENUM) + PVR_BUFFERCLASS_MEMOFFSET;
return 0;
+#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+ExitDestroyClass:
+ class_destroy(psPvrClass);
+#endif
ExitUnregister:
unregister_chrdev(AssignedMajorNumber, DEVNAME);
ExitDisable:
static void __exit BC_Example_ModCleanup(void)
{
+#if defined(LDM_PLATFORM) || defined(LDM_PCI)
+ device_destroy(psPvrClass, MKDEV(AssignedMajorNumber, 0));
+ class_destroy(psPvrClass);
+#endif
+
unregister_chrdev(AssignedMajorNumber, DEVNAME);
if(BC_Example_Deinit() != BCE_OK)
kfree(pvMem);
}
+#if defined(BC_DISCONTIG_BUFFERS)
+
+#define RANGE_TO_PAGES(range) (((range) + (PAGE_SIZE - 1)) >> PAGE_SHIFT)
+#define VMALLOC_TO_PAGE_PHYS(vAddr) page_to_phys(vmalloc_to_page(vAddr))
+
+BCE_ERROR BCAllocDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ *phMemHandle,
+ IMG_CPU_VIRTADDR *pLinAddr,
+ IMG_SYS_PHYADDR **ppPhysAddr)
+{
+ unsigned long ulPages = RANGE_TO_PAGES(ulSize);
+ IMG_SYS_PHYADDR *pPhysAddr;
+ unsigned long ulPage;
+ IMG_CPU_VIRTADDR LinAddr;
+
+ LinAddr = __vmalloc(ulSize, GFP_KERNEL | __GFP_HIGHMEM, pgprot_noncached(PAGE_KERNEL));
+ if (!LinAddr)
+ {
+ return BCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ pPhysAddr = kmalloc(ulPages * sizeof(IMG_SYS_PHYADDR), GFP_KERNEL);
+ if (!pPhysAddr)
+ {
+ vfree(LinAddr);
+ return BCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ *pLinAddr = LinAddr;
+
+ for (ulPage = 0; ulPage < ulPages; ulPage++)
+ {
+ pPhysAddr[ulPage].uiAddr = VMALLOC_TO_PAGE_PHYS(LinAddr);
+
+ LinAddr += PAGE_SIZE;
+ }
+
+ *ppPhysAddr = pPhysAddr;
+
+ return BCE_OK;
+}
+
+void BCFreeDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ hMemHandle,
+ IMG_CPU_VIRTADDR LinAddr,
+ IMG_SYS_PHYADDR *pPhysAddr)
+{
+ kfree(pPhysAddr);
+
+ vfree(LinAddr);
+}
+#else
+
BCE_ERROR BCAllocContigMemory(unsigned long ulSize,
BCE_HANDLE unref__ *phMemHandle,
IMG_CPU_VIRTADDR *pLinAddr,
#endif
#endif
}
+#endif
IMG_SYS_PHYADDR CpuPAddrToSysPAddrBC(IMG_CPU_PHYADDR cpu_paddr)
{
{
int err = -EFAULT;
int command = _IOC_NR(cmd);
- BC_Example_ioctl_package *psBridge = (BC_Example_ioctl_package *)arg;
+ BC_Example_ioctl_package sBridge;
- if(!access_ok(VERIFY_WRITE, psBridge, sizeof(BC_Example_ioctl_package)))
+ if (copy_from_user(&sBridge, (void *)arg, sizeof(sBridge)) != 0)
{
return err;
}
{
case _IOC_NR(BC_Example_ioctl_fill_buffer):
{
- if(FillBuffer(psBridge->inputparam) == -1)
+ if(FillBuffer(sBridge.inputparam) == -1)
{
return err;
}
}
case _IOC_NR(BC_Example_ioctl_get_buffer_count):
{
- if(GetBufferCount(&psBridge->outputparam) == -1)
+ if(GetBufferCount(&sBridge.outputparam) == -1)
{
return err;
}
return err;
}
+ if (copy_to_user((void *)arg, &sBridge, sizeof(sBridge)) != 0)
+ {
+ return err;
+ }
+
return 0;
}
******************************************************************************/
#include "bufferclass_example.h"
+#include "bufferclass_example_private.h"
#define MIN(a,b) ((a)<(b)?(a):(b))
-void FillYUV420Image(void *pvDest, int width, int height, int bytestride)
+static void FillNV12Image(void *pvDest, int width, int height, int bytestride)
{
static int iPhase = 0;
int i, j;
for(j=0;j<height;j++)
{
+ pui8y = (unsigned char *)pvDest + j * bytestride;
+ count = 0;
+
for(i=0;i<width;i++)
{
y = (((i+iPhase)>>6)%(2)==0)? 0x7f:0x00;
}
}
- pui16uv = (unsigned short *)((unsigned char *)pvDest + (width * height));
- count = 0;
-
for(j=0;j<height;j+=2)
{
+ pui16uv = (unsigned short *)((unsigned char *)pvDest + height * bytestride + (j / 2) * bytestride);
+ count = 0;
+
for(i=0;i<width;i+=2)
{
u = (j<(height/2))? ((i<(width/2))? 0xFF:0x33) : ((i<(width/2))? 0x33:0xAA);
iPhase++;
}
-void FillYUV422Image(void *pvDest, int width, int height, int bytestride)
+static void FillI420Image(void *pvDest, int width, int height, int bytestride)
+{
+ static int iPhase = 0;
+ int i, j;
+ unsigned char u,v,y;
+ unsigned char *pui8y = (unsigned char *)pvDest;
+ unsigned char *pui8u, *pui8v;
+ unsigned int count = 0;
+ int uvplanestride = bytestride / 2;
+ int uvplaneheight = height / 2;
+
+ for(j=0;j<height;j++)
+ {
+ pui8y = (unsigned char *)pvDest + j * bytestride;
+ count = 0;
+
+ for(i=0;i<width;i++)
+ {
+ y = (((i+iPhase)>>6)%(2)==0)? 0x7f:0x00;
+
+ pui8y[count++] = y;
+ }
+ }
+
+ for(j=0;j<height;j+=2)
+ {
+ pui8u = (unsigned char *)pvDest + (height * bytestride) + ((j / 2) * uvplanestride);
+ count = 0;
+
+ for(i=0;i<width;i+=2)
+ {
+ u = (j<(height/2))? ((i<(width/2))? 0xFF:0x33) : ((i<(width/2))? 0x33:0xAA);
+
+ pui8u[count++] = u;
+
+ }
+ }
+
+ for(j=0;j<height;j+=2)
+ {
+ pui8v = (unsigned char *)pvDest + (height * bytestride) + (uvplaneheight * uvplanestride) + (j / 2) * uvplanestride;
+ count = 0;
+
+ for(i=0;i<width;i+=2)
+ {
+ v = (j<(height/2))? ((i<(width/2))? 0xAC:0x0) : ((i<(width/2))? 0x03:0xEE);
+
+ pui8v[count++] = v;
+ }
+ }
+
+ iPhase++;
+}
+
+static void FillYUV422Image(void *pvDest, int width, int height, int bytestride, PVRSRV_PIXEL_FORMAT pixelformat)
{
static int iPhase = 0;
int x, y;
for(y=0;y<height;y++)
{
- for(x=0;x<width;x+=2)
+ pui32yuv = (unsigned long *)((unsigned char *)pvDest + y * bytestride);
+ count = 0;
+
+ for(x=0;x<width; x+=2)
{
u = (y<(height/2))? ((x<(width/2))? 0xFF:0x33) : ((x<(width/2))? 0x33:0xAA);
v = (y<(height/2))? ((x<(width/2))? 0xAA:0x0) : ((x<(width/2))? 0x03:0xEE);
y0 = y1 = (((x+iPhase)>>6)%(2)==0)? 0x7f:0x00;
-
- pui32yuv[count++] = (y1 << 24) | (v << 16) | (y0 << 8) | u;
+ switch(pixelformat)
+ {
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_VYUY:
+ pui32yuv[count++] = (y1 << 24) | (u << 16) | (y0 << 8) | v;
+ break;
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_UYVY:
+ pui32yuv[count++] = (y1 << 24) | (v << 16) | (y0 << 8) | u;
+ break;
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YUYV:
+ pui32yuv[count++] = (v << 24) | (y1 << 16) | (u << 8) | y0;
+ break;
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YVYU:
+ pui32yuv[count++] = (u << 24) | (y1 << 16) | (v << 8) | y0;
+ break;
+
+ default:
+ break;
+
+ }
}
}
iPhase++;
}
-void FillRGB565Image(void *pvDest, int width, int height, int bytestride)
+static void FillRGB565Image(void *pvDest, int width, int height, int bytestride)
{
int i, Count;
unsigned long *pui32Addr = (unsigned long *)pvDest;
FillRGB565Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE);
break;
}
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_VYUY:
case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_UYVY:
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YUYV:
+ case PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YVYU:
{
- FillYUV422Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE);
+ FillYUV422Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE, psBufferInfo->pixelformat);
break;
}
case PVRSRV_PIXEL_FORMAT_NV12:
{
- FillYUV420Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE);
+ FillNV12Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE);
+ break;
+ }
+ case PVRSRV_PIXEL_FORMAT_I420:
+ {
+ FillI420Image(psBuffer->sCPUVAddr, BC_EXAMPLE_WIDTH, BC_EXAMPLE_HEIGHT, BC_EXAMPLE_STRIDE);
break;
}
}
if(psSyncData)
{
psSyncData->ui32WriteOpsComplete++;
+
+ if (NULL != psDevInfo->sPVRJTable.pfnPVRSRVScheduleDevices)
+ {
+ (*psDevInfo->sPVRJTable.pfnPVRSRVScheduleDevices)();
+ }
}
return 0;
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef _BUFFERCLASS_EXAMPLE_PRIVATE_H_
+#define _BUFFERCLASS_EXAMPLE_PRIVATE_H_
+
+int FillBuffer(unsigned int uiBufferIndex);
+int GetBufferCount(unsigned int *puiBufferCount);
+
+#endif
#
#
-include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
-
MODULE = bc_example
INCLUDES = -I$(EURASIAROOT)/include4 \
SYM_VERS_DEPS = $(EURASIAROOT)/services4/srvkm/env/linux
-
+include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
-I$(PVR_BUILD_DIR)/include4 \
-I$(PVR_BUILD_DIR)/services4/include
-ifeq ($(TI_PLATFORM),ti8168)
-EXTRA_CFLAGS += -DPLAT_TI8168
+ifeq ($(TI_PLATFORM),ti81xx)
+EXTRA_CFLAGS += -DPLAT_TI81xx
endif
obj-m := bufferclass_ti.o
#include <servicesext.h>
#include <kernelbuffer.h>
#include "bc_cat.h"
-
#include <linux/slab.h>
-
#include <linux/dma-mapping.h>
#define DEVNAME "bccat"
#define DRVNAME DEVNAME
#define DEVICE_COUNT 1
+#define BC_EXAMPLE_NUM_BUFFERS 3
+#define BUFFERCLASS_DEVICE_NAME "Example Bufferclass Device (SW)"
+
+#ifndef UNREFERENCED_PARAMETER
+#define UNREFERENCED_PARAMETER(param) (param) = (param)
+#endif
+
MODULE_SUPPORTED_DEVICE(DEVNAME);
typedef struct BC_CAT_BUFFER_TAG
{
- IMG_UINT32 ui32Size;
+ unsigned long ulSize;
IMG_HANDLE hMemHandle;
+#if defined(BC_DISCONTIG_BUFFERS)
+ IMG_SYS_PHYADDR *psSysAddr;
+#else
+
IMG_SYS_PHYADDR sSysAddr;
IMG_SYS_PHYADDR sPageAlignSysAddr;
+#endif
IMG_CPU_VIRTADDR sCPUVAddr;
PVRSRV_SYNC_DATA *psSyncData;
struct BC_CAT_BUFFER_TAG *psNext;
typedef struct BC_CAT_DEVINFO_TAG
-{
- int ref;
- IMG_UINT32 ui32DeviceID;
+{
+ int ref;
+ unsigned long ulDeviceID;
BC_CAT_BUFFER *psSystemBuffer;
- BUFFER_INFO sBufferInfo;
- IMG_UINT32 ui32NumBuffers;
+ unsigned long ulNumBuffers;
PVRSRV_BC_BUFFER2SRV_KMJTABLE sPVRJTable;
PVRSRV_BC_SRV2BUFFER_KMJTABLE sBCJTable;
IMG_HANDLE hPVRServices;
- IMG_UINT32 ui32RefCount;
+ unsigned long ulRefCount;
+ BUFFER_INFO sBufferInfo;
enum BC_memory buf_type;
} BC_CAT_DEVINFO;
+typedef enum _BCE_ERROR_
+{
+ BCE_OK = 0,
+ BCE_ERROR_GENERIC = 1,
+ BCE_ERROR_OUT_OF_MEMORY = 2,
+ BCE_ERROR_TOO_FEW_BUFFERS = 3,
+ BCE_ERROR_INVALID_PARAMS = 4,
+ BCE_ERROR_INIT_FAILURE = 5,
+ BCE_ERROR_CANT_REGISTER_CALLBACK = 6,
+ BCE_ERROR_INVALID_DEVICE = 7,
+ BCE_ERROR_DEVICE_REGISTER_FAILED = 8,
+ BCE_ERROR_NO_PRIMARY = 9
+} BCE_ERROR;
+
+
+
extern IMG_IMPORT IMG_BOOL PVRGetBufferClassJTable(
PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable);
static int bc_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg);
#else
-static long bc_ioctl(struct file *file,
+static int bc_ioctl(struct file *file,
unsigned int cmd, unsigned long arg);
#endif
static int bc_mmap(struct file *filp, struct vm_area_struct *vma);
static PVRSRV_ERROR BCOpenPVRServices(IMG_HANDLE *phPVRServices);
static PVRSRV_ERROR BCClosePVRServices(IMG_HANDLE hPVRServices);
-static IMG_VOID *BCAllocKernelMem(IMG_UINT32 ui32Size);
+static IMG_VOID *BCAllocKernelMem(unsigned long ulSize);
static IMG_VOID BCFreeKernelMem(IMG_VOID *pvMem);
-static PVRSRV_ERROR BCAllocContigMemory(IMG_UINT32 ui32Size,
+static PVRSRV_ERROR BCAllocContigMemory(unsigned long ulSize,
IMG_HANDLE * phMemHandle,
IMG_CPU_VIRTADDR *pLinAddr,
IMG_CPU_PHYADDR *pPhysAddr);
-static IMG_VOID BCFreeContigMemory(IMG_UINT32 ui32Size,
+static IMG_VOID BCFreeContigMemory(unsigned long ulSize,
IMG_HANDLE hMemHandle,
IMG_CPU_VIRTADDR LinAddr,
IMG_CPU_PHYADDR PhysAddr);
#else
.unlocked_ioctl = bc_ioctl,
#ifdef CONFIG_COMPAT
- .compat_ioctl = bc_ioctl,
+ .compat_ioctl = bc_ioctl,
#endif
#endif
.mmap = bc_mmap,
#else
#define OPEN_FXN(id) \
-static PVRSRV_ERROR OpenBCDevice##id(IMG_HANDLE *phDevice)\
+static PVRSRV_ERROR OpenBCDevice##id(IMG_UINT32 ui32DeviceID, IMG_HANDLE *phDevice)\
{ \
BC_CAT_DEVINFO *psDevInfo; \
+UNREFERENCED_PARAMETER(ui32DeviceID); \
psDevInfo = GetAnchorPtr (id); \
*phDevice = (IMG_HANDLE) psDevInfo; \
return PVRSRV_OK; \
IMG_UINT32 *pui32ByteSize,
IMG_VOID **ppvCpuVAddr,
IMG_HANDLE *phOSMapInfo,
- IMG_BOOL *pbIsContiguous)
+ IMG_BOOL *pbIsContiguous,
+ IMG_UINT32 *pui32TilingStride)
{
BC_CAT_BUFFER *psBuffer;
+ PVR_UNREFERENCED_PARAMETER(pui32TilingStride);
if (!hDevice || !hBuffer || !ppsSysAddr || !pui32ByteSize)
return PVRSRV_ERROR_INVALID_PARAMS;
psBuffer = (BC_CAT_BUFFER *) hBuffer;
- *ppsSysAddr = &psBuffer->sPageAlignSysAddr;
- *ppvCpuVAddr = psBuffer->sCPUVAddr;
- *pui32ByteSize = psBuffer->ui32Size;
- *phOSMapInfo = IMG_NULL;
- *pbIsContiguous = IMG_TRUE;
+ *ppvCpuVAddr = psBuffer->sCPUVAddr;
+
+ *phOSMapInfo = IMG_NULL;
+ *pui32ByteSize = (IMG_UINT32)psBuffer->ulSize;
+
+#if defined(BC_DISCONTIG_BUFFERS)
+ *ppsSysAddr = psBuffer->psSysAddr;
+ *pbIsContiguous = IMG_FALSE;
+#else
+ *ppsSysAddr = &psBuffer->sPageAlignSysAddr;
+ *pbIsContiguous = IMG_TRUE;
+#endif
+
return PVRSRV_OK;
}
static int BC_CreateBuffers(int id, bc_buf_params_t *p)
{
BC_CAT_DEVINFO *psDevInfo;
+#if !defined(BC_DISCONTIG_BUFFERS)
IMG_CPU_PHYADDR paddr;
- IMG_UINT32 i, stride, size;
+#endif
+ IMG_UINT32 i, stride;
+ unsigned long ulSize;
PVRSRV_PIXEL_FORMAT pixel_fmt;
if (p->count <= 0)
if (p->type != BC_MEMORY_MMAP && p->type != BC_MEMORY_USERPTR)
return -EINVAL;
- if ((psDevInfo = GetAnchorPtr(id)) == IMG_NULL)
- return -ENODEV;
+ psDevInfo = GetAnchorPtr(id);
+ if (psDevInfo == NULL)
+ {
+
+ return (BCE_ERROR_DEVICE_REGISTER_FAILED);
+ }
+ if (psDevInfo->ulNumBuffers)
+ {
+
+ return (BCE_ERROR_GENERIC);
+ }
+
- if (psDevInfo->ui32NumBuffers)
- BC_DestroyBuffers(id);
psDevInfo->buf_type = p->type;
psDevInfo->psSystemBuffer =
memset(psDevInfo->psSystemBuffer, 0, sizeof(BC_CAT_BUFFER) * p->count);
- size = p->height * stride;
+ ulSize = p->height * stride;
if (pixel_fmt == PVRSRV_PIXEL_FORMAT_NV12)
- size += (stride >> 1) * (p->height >> 1) << 1;
+ ulSize += (stride >> 1) * (p->height >> 1) << 1;
for (i=0; i < p->count; i++) {
if (psDevInfo->buf_type == BC_MEMORY_MMAP) {
- if (BCAllocContigMemory(size,
+
+#if defined(BC_DISCONTIG_BUFFERS)
+ if (BCAllocDiscontigMemory(ulSize,
+ &psDevInfo->psSystemBuffer[i].hMemHandle,
+ &psDevInfo->psSystemBuffer[i].sCPUVAddr,
+ &psDevInfo->psSystemBuffer[i].psSysAddr) != BCE_OK)
+ {
+ break;
+ }
+#else
+
+ if (BCAllocContigMemory(ulSize,
&psDevInfo->psSystemBuffer[i].hMemHandle,
&psDevInfo->psSystemBuffer[i].sCPUVAddr,
- &paddr) != PVRSRV_OK)
+ &paddr) != BCE_OK)
+{
/*TODO should free() and return failure*/
break;
+}
psDevInfo->psSystemBuffer[i].sSysAddr = CpuPAddrToSysPAddrBC(paddr);
psDevInfo->psSystemBuffer[i].sPageAlignSysAddr.uiAddr =
psDevInfo->psSystemBuffer[i].sSysAddr.uiAddr & 0xFFFFF000;
}
- psDevInfo->ui32NumBuffers++;
- psDevInfo->psSystemBuffer[i].ui32Size = size;
- psDevInfo->psSystemBuffer[i].psSyncData = IMG_NULL;
+#endif
+ psDevInfo->ulNumBuffers++;
+ psDevInfo->psSystemBuffer[i].ulSize = ulSize;
+ psDevInfo->psSystemBuffer[i].psSyncData = NULL;
}
- p->count = psDevInfo->ui32NumBuffers;
+ p->count = psDevInfo->ulNumBuffers;
- psDevInfo->sBufferInfo.ui32BufferCount = psDevInfo->ui32NumBuffers;
+ psDevInfo->sBufferInfo.ui32BufferCount = (IMG_UINT32)psDevInfo->ulNumBuffers;
psDevInfo->sBufferInfo.pixelformat = pixel_fmt;
psDevInfo->sBufferInfo.ui32Width = p->width;
psDevInfo->sBufferInfo.ui32Height = p->height;
psDevInfo->sBufferInfo.ui32BufferDeviceID = id;
psDevInfo->sBufferInfo.ui32Flags = PVRSRV_BC_FLAGS_YUVCSC_FULL_RANGE |
PVRSRV_BC_FLAGS_YUVCSC_BT601;
- return 0;
+
+psDevInfo->sBCJTable.ui32TableSize = sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE);
+ psDevInfo->sBCJTable.pfnOpenBCDevice = OpenBCDevice0;
+ psDevInfo->sBCJTable.pfnCloseBCDevice = CloseBCDevice;
+ psDevInfo->sBCJTable.pfnGetBCBuffer = GetBCBuffer;
+ psDevInfo->sBCJTable.pfnGetBCInfo = GetBCInfo;
+ psDevInfo->sBCJTable.pfnGetBufferAddr = GetBCBufferAddr;
+
+
+ return (BCE_OK);
+
}
BC_CAT_DEVINFO *psDevInfo;
IMG_UINT32 i;
- if ((psDevInfo = GetAnchorPtr(id)) == IMG_NULL)
- return PVRSRV_ERROR_DEVICE_REGISTER_FAILED;
-
- if (!psDevInfo->ui32NumBuffers)
- return PVRSRV_OK;
+ psDevInfo = GetAnchorPtr(id);
+
+
+ if (psDevInfo == NULL)
+ {
+
+
+ return (BCE_ERROR_DEVICE_REGISTER_FAILED);
+ }
if (psDevInfo->buf_type == BC_MEMORY_MMAP)
- for (i = 0; i < psDevInfo->ui32NumBuffers; i++) {
- BCFreeContigMemory(psDevInfo->psSystemBuffer[i].ui32Size,
+ for (i = 0; i < psDevInfo->ulNumBuffers; i++) {
+#if defined(BC_DISCONTIG_BUFFERS)
+ BCFreeDiscontigMemory(psDevInfo->psSystemBuffer[i].ulSize,
+ psDevInfo->psSystemBuffer[i].hMemHandle,
+ psDevInfo->psSystemBuffer[i].sCPUVAddr,
+ psDevInfo->psSystemBuffer[i].psSysAddr);
+#else
+
+ BCFreeContigMemory(psDevInfo->psSystemBuffer[i].ulSize,
psDevInfo->psSystemBuffer[i].hMemHandle,
psDevInfo->psSystemBuffer[i].sCPUVAddr,
SysPAddrToCpuPAddrBC(psDevInfo->psSystemBuffer[i].sSysAddr));
+#endif
}
- BCFreeKernelMem(psDevInfo->psSystemBuffer);
+ // BCFreeKernelMem(psDevInfo->psSystemBuffer);
- psDevInfo->ui32NumBuffers = 0;
+ psDevInfo->ulNumBuffers = 0;
psDevInfo->sBufferInfo.pixelformat = PVRSRV_PIXEL_FORMAT_UNKNOWN;
psDevInfo->sBufferInfo.ui32Width = 0;
psDevInfo->sBufferInfo.ui32Height = 0;
psDevInfo->sBufferInfo.ui32ByteStride = 0;
psDevInfo->sBufferInfo.ui32BufferDeviceID = id;
psDevInfo->sBufferInfo.ui32Flags = 0;
- psDevInfo->sBufferInfo.ui32BufferCount = psDevInfo->ui32NumBuffers;
+ psDevInfo->sBufferInfo.ui32BufferCount = (IMG_UINT32)psDevInfo->ulNumBuffers;
return PVRSRV_OK;
}
{
BC_CAT_DEVINFO *psDevInfo;
- psDevInfo = GetAnchorPtr(id);
-
- if (psDevInfo) {
- psDevInfo->ui32RefCount++;
- return PVRSRV_OK;
- }
+//psDevInfo = GetAnchorPtr();
+ psDevInfo = GetAnchorPtr(id);
+ if (psDevInfo == NULL)
+ {
psDevInfo = (BC_CAT_DEVINFO *)BCAllocKernelMem(sizeof(BC_CAT_DEVINFO));
if (!psDevInfo)
return PVRSRV_ERROR_OUT_OF_MEMORY;
psDevInfo->ref = 0;
- psDevInfo->ui32RefCount = 0;
+ psDevInfo->ulRefCount = 0;
SetAnchorPtr(id, (IMG_VOID*)psDevInfo);
if (BCOpenPVRServices(&psDevInfo->hPVRServices) != PVRSRV_OK)
if (!(*pfnGetPVRJTable)(&psDevInfo->sPVRJTable))
return PVRSRV_ERROR_INIT_FAILURE;
- psDevInfo->ui32NumBuffers = 0;
+ psDevInfo->ulNumBuffers = 0;
+
+ psDevInfo->psSystemBuffer = BCAllocKernelMem(sizeof(BC_CAT_BUFFER) * BC_EXAMPLE_NUM_BUFFERS);
psDevInfo->sBufferInfo.pixelformat = PVRSRV_PIXEL_FORMAT_UNKNOWN;
psDevInfo->sBufferInfo.ui32Width = 0;
psDevInfo->sBufferInfo.ui32ByteStride = 0;
psDevInfo->sBufferInfo.ui32BufferDeviceID = id;
psDevInfo->sBufferInfo.ui32Flags = 0;
- psDevInfo->sBufferInfo.ui32BufferCount = psDevInfo->ui32NumBuffers;
+ psDevInfo->sBufferInfo.ui32BufferCount = (IMG_UINT32)psDevInfo->ulNumBuffers;
psDevInfo->sBCJTable.ui32TableSize = sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE);
+
+strncpy(psDevInfo->sBufferInfo.szDeviceName, BUFFERCLASS_DEVICE_NAME, MAX_BUFFER_DEVICE_NAME_SIZE);
#if 0
psDevInfo->sBCJTable.pfnOpenBCDevice = OpenBCDevice;
#else
if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterBCDevice(
&psDevInfo->sBCJTable,
- &psDevInfo->ui32DeviceID) != PVRSRV_OK)
+ (IMG_UINT32*)&psDevInfo->ulDeviceID) != PVRSRV_OK)
return PVRSRV_ERROR_DEVICE_REGISTER_FAILED;
-
- psDevInfo->ui32RefCount++;
+}
+ psDevInfo->ulRefCount++;
return PVRSRV_OK;
}
static PVRSRV_ERROR BC_Unregister(int id)
{
BC_CAT_DEVINFO *psDevInfo;
- PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable;
+// PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable;
if ((psDevInfo = GetAnchorPtr(id)) == IMG_NULL)
return PVRSRV_ERROR_DEVICE_REGISTER_FAILED;
- psDevInfo->ui32RefCount--;
+ psDevInfo->ulRefCount--;
- if (psDevInfo->ui32RefCount)
+ if (psDevInfo->ulRefCount)
return PVRSRV_ERROR_RETRY;
- psJTable = &psDevInfo->sPVRJTable;
-
- if (psJTable->pfnPVRSRVRemoveBCDevice(psDevInfo->ui32DeviceID) != PVRSRV_OK)
- return PVRSRV_ERROR_GENERIC;
+
+ if (psDevInfo->ulRefCount == 0)
+ {
+
+ PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable = &psDevInfo->sPVRJTable;
+
+
+ if (psJTable->pfnPVRSRVRemoveBCDevice(psDevInfo->ulDeviceID) != PVRSRV_OK)
+ //return PVRSRV_ERROR_GENERIC;
+ return 1;
if (BCClosePVRServices(psDevInfo->hPVRServices) != PVRSRV_OK) {
psDevInfo->hPVRServices = IMG_NULL;
- return PVRSRV_ERROR_GENERIC;
+ //return PVRSRV_ERROR_GENERIC;
+ return 1;
}
+if (psDevInfo->psSystemBuffer)
+ {
+ BCFreeKernelMem(psDevInfo->psSystemBuffer);
+ }
BCFreeKernelMem(psDevInfo);
SetAnchorPtr(id, IMG_NULL);
-
+}
return PVRSRV_OK;
}
/* texture buffer width should be multiple of 8 for OMAP3 ES3.x,
* or 32 for ES2.x */
-#ifdef PLAT_TI8168
- width_align = 8;
+
+#ifdef PLAT_TI8168
+ width_align = 8;
#else
- width_align = cpu_is_omap3530() && ( omap_rev() < OMAP3430_REV_ES3_0 ) ? 32 : 8;
-#endif
+ width_align = cpu_is_omap3530() && ( omap_rev() < OMAP3430_REV_ES3_0 ) ? 32 : 8;
+#endif
+
major = register_chrdev(0, DEVNAME, &bc_cat_fops);
if (major <= 0) {
static void __exit bc_cat_cleanup(void)
{
- int id;
+ int id=0;
for (id = 0; id < DEVICE_COUNT; id++) {
+device_destroy(bc_class, MKDEV(major, id));
+}
+
+ class_destroy(bc_class);
+
+ unregister_chrdev(major, DEVNAME);
+
+ for (id = 0; id < DEVICE_COUNT; id++) {
if (BC_DestroyBuffers(id) != PVRSRV_OK) {
printk(KERN_ERR DRVNAME ": can't free texture buffers\n");
return;
printk(KERN_ERR DRVNAME ": can't un-register BC service\n");
return;
}
- device_destroy(bc_class, MKDEV(major, id));
}
- class_destroy(bc_class);
- unregister_chrdev(major, DEVNAME);
}
-static IMG_VOID *BCAllocKernelMem(IMG_UINT32 ui32Size)
+static IMG_VOID *BCAllocKernelMem(unsigned long ulSize)
{
- return kmalloc(ui32Size, GFP_KERNEL);
+ return kmalloc(ulSize, GFP_KERNEL);
}
static IMG_VOID BCFreeKernelMem(IMG_VOID *pvMem)
kfree(pvMem);
}
-static PVRSRV_ERROR BCAllocContigMemory(IMG_UINT32 ui32Size,
+#if defined(BC_DISCONTIG_BUFFERS)
+
+#define RANGE_TO_PAGES(range) (((range) + (PAGE_SIZE - 1)) >> PAGE_SHIFT)
+#define VMALLOC_TO_PAGE_PHYS(vAddr) page_to_phys(vmalloc_to_page(vAddr))
+
+BCE_ERROR BCAllocDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ *phMemHandle,
+ IMG_CPU_VIRTADDR *pLinAddr,
+ IMG_SYS_PHYADDR **ppPhysAddr)
+{
+ unsigned long ulPages = RANGE_TO_PAGES(ulSize);
+ IMG_SYS_PHYADDR *pPhysAddr;
+ unsigned long ulPage;
+ IMG_CPU_VIRTADDR LinAddr;
+
+ LinAddr = __vmalloc(ulSize, GFP_KERNEL | __GFP_HIGHMEM, pgprot_noncached(PAGE_KERNEL));
+ if (!LinAddr)
+ {
+ return BCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ pPhysAddr = kmalloc(ulPages * sizeof(IMG_SYS_PHYADDR), GFP_KERNEL);
+ if (!pPhysAddr)
+ {
+ vfree(LinAddr);
+ return BCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ *pLinAddr = LinAddr;
+
+ for (ulPage = 0; ulPage < ulPages; ulPage++)
+ {
+ pPhysAddr[ulPage].uiAddr = VMALLOC_TO_PAGE_PHYS(LinAddr);
+
+ LinAddr += PAGE_SIZE;
+ }
+
+ *ppPhysAddr = pPhysAddr;
+
+ return BCE_OK;
+}
+
+void BCFreeDiscontigMemory(unsigned long ulSize,
+ BCE_HANDLE unref__ hMemHandle,
+ IMG_CPU_VIRTADDR LinAddr,
+ IMG_SYS_PHYADDR *pPhysAddr)
+{
+ kfree(pPhysAddr);
+
+ vfree(LinAddr);
+}
+#else
+
+PVRSRV_ERROR BCAllocContigMemory(unsigned long ulSize,
IMG_HANDLE unref__ *phMemHandle,
IMG_CPU_VIRTADDR *pLinAddr,
IMG_CPU_PHYADDR *pPhysAddr)
{
+
+#if defined(BCE_USE_SET_MEMORY)
+ void *pvLinAddr;
+ unsigned long ulAlignedSize = PAGE_ALIGN(ulSize);
+ int iPages = (int)(ulAlignedSize >> PAGE_SHIFT);
+ int iError;
+
+ pvLinAddr = kmalloc(ulAlignedSize, GFP_KERNEL);
+ BUG_ON(((unsigned long)pvLinAddr) & ~PAGE_MASK);
+
+ iError = set_memory_wc((unsigned long)pvLinAddr, iPages);
+ if (iError != 0)
+ {
+ printk(KERN_ERR DRVNAME ": BCAllocContigMemory: set_memory_wc failed (%d)\n", iError);
+ return (BCE_ERROR_OUT_OF_MEMORY);
+ }
+
+ pPhysAddr->uiAddr = virt_to_phys(pvLinAddr);
+ *pLinAddr = pvLinAddr;
+
+ return (BCE_OK);
+#else
+ dma_addr_t dma;
+ void *pvLinAddr;
+
+ pvLinAddr = dma_alloc_coherent(NULL, ulSize, &dma, GFP_KERNEL);
+ if (pvLinAddr == NULL)
+ {
+ return (BCE_ERROR_OUT_OF_MEMORY);
+ }
+
+ pPhysAddr->uiAddr = dma;
+ *pLinAddr = pvLinAddr;
+
+ return (BCE_OK);
+#endif
+#if 0
IMG_VOID *pvLinAddr;
gfp_t mask = GFP_KERNEL;
pvLinAddr = alloc_pages_exact(ui32Size, mask);
-/* printk("pvLinAddr=%p, ui32Size=%ld\n", pvLinAddr, ui32Size);*/
if (pvLinAddr == IMG_NULL)
return PVRSRV_ERROR_OUT_OF_MEMORY;
pPhysAddr->uiAddr = virt_to_phys(pvLinAddr);
*pLinAddr = pvLinAddr;
-
- return PVRSRV_OK;
+#endif
+ // return PVRSRV_OK;
}
-static IMG_VOID BCFreeContigMemory(IMG_UINT32 ui32Size,
+static IMG_VOID BCFreeContigMemory(unsigned long ulSize,
IMG_HANDLE unref__ hMemHandle,
IMG_CPU_VIRTADDR LinAddr,
IMG_CPU_PHYADDR PhysAddr)
{
- free_pages_exact(LinAddr, ui32Size);
+ // free_pages_exact(LinAddr, ui32Size);
+#if defined(BCE_USE_SET_MEMORY)
+ unsigned long ulAlignedSize = PAGE_ALIGN(ulSize);
+ int iError;
+ int iPages = (int)(ulAlignedSize >> PAGE_SHIFT);
+
+ iError = set_memory_wb((unsigned long)LinAddr, iPages);
+ if (iError != 0)
+ {
+ printk(KERN_ERR DRVNAME ": BCFreeContigMemory: set_memory_wb failed (%d)\n", iError);
+ }
+ kfree(LinAddr);
+#else
+ dma_free_coherent(NULL, ulSize, LinAddr, (dma_addr_t)PhysAddr.uiAddr);
+#endif
+
}
+#endif
static IMG_SYS_PHYADDR CpuPAddrToSysPAddrBC(IMG_CPU_PHYADDR cpu_paddr)
{
IMG_SYS_PHYADDR sys_paddr;
if ((devinfo = GetAnchorPtr(id)) == IMG_NULL)
return -ENODEV;
+ for (id = 0; id < DEVICE_COUNT; id++) {
+ if (BC_DestroyBuffers(id) != PVRSRV_OK) {
+ printk(KERN_ERR DRVNAME ": can't free texture buffer \n");
+ }
+ }
+
if (devinfo->ref)
devinfo->ref--;
return 0;
static int bc_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
#else
-static long bc_ioctl(struct file *file,
+static int bc_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
#endif
{
return -EFAULT;
idx = params->input;
- if (idx < 0 || idx > devinfo->ui32NumBuffers) {
+ if (idx < 0 || idx > devinfo->ulNumBuffers) {
printk(KERN_ERR DRVNAME
": BCIOGET_BUFFERADDR - idx out of range\n");
return -EINVAL;
if (!access_ok(VERIFY_WRITE, params, sizeof(BCIO_package)))
return -EFAULT;
- for (idx = 0; idx < devinfo->ui32NumBuffers; idx++) {
+ for (idx = 0; idx < devinfo->ulNumBuffers; idx++) {
buffer = &devinfo->psSystemBuffer[idx];
if (params->input == (int)buffer->sSysAddr.uiAddr) {
if (copy_from_user(&p, (void __user *)arg, sizeof(p)))
return -EFAULT;
- if (p.index >= devinfo->ui32NumBuffers || !p.pa)
+ if (p.index >= devinfo->ulNumBuffers || !p.pa)
return -EINVAL;
/*TODO check buffer size*/
SYS_USING_INTERRUPTS = 1
+SUPPORT_OMAP3430_OMAPFB3 =1
SUPPORT_TI_DSS_FW = 0
SYS_CFLAGS.$(SYS_USING_INTERRUPTS) += -DSYS_USING_INTERRUPTS
+SYS_CFLAGS.$(SUPPORT_OMAP3430_OMAPFB3) += -DSUPPORT_OMAP3430_OMAPFB3
SYS_CFLAGS.$(SUPPORT_TI_DSS_FW) += -DSUPPORT_TI_DSS_FW
-
EXTRA_CFLAGS = -DLINUX \
-I$(PVR_BUILD_DIR)/include4 \
-I$(PVR_BUILD_DIR)/services4/include \
-I$(PVR_BUILD_DIR)/services4/system/include \
$(SYS_CFLAGS.1) \
-ifeq ($(VERSION), 3)
-export EXTRA_CFLAGS += -DAUTOCONF_INCLUDED
-endif
-
obj-m := omaplfb.o
omaplfb-y := omaplfb_displayclass.o omaplfb_linux.o
#
#
-include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
-
MODULE = omaplfb
INCLUDES = -I$(EURASIAROOT)/include4 \
SYM_VERS_DEPS = $(EURASIAROOT)/services4/srvkm/env/linux
-
-
-
+include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
#ifndef __OMAPLFB_H__
#define __OMAPLFB_H__
-#if defined(SGX_EARLYSUSPEND)
-#include <linux/earlysuspend.h>
-#endif
-
-extern IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
+#define OMAPLCD_IRQ 25
+
+#define OMAPLCD_SYSCONFIG 0x0410
+#define OMAPLCD_CONFIG 0x0444
+#define OMAPLCD_DEFAULT_COLOR0 0x044C
+#define OMAPLCD_TIMING_H 0x0464
+#define OMAPLCD_TIMING_V 0x0468
+#define OMAPLCD_POL_FREQ 0x046C
+#define OMAPLCD_DIVISOR 0x0470
+#define OMAPLCD_SIZE_DIG 0x0478
+#define OMAPLCD_SIZE_LCD 0x047C
+#define OMAPLCD_GFX_POSITION 0x0488
+#define OMAPLCD_GFX_SIZE 0x048C
+#define OMAPLCD_GFX_ATTRIBUTES 0x04a0
+#define OMAPLCD_GFX_FIFO_THRESHOLD 0x04a4
+#define OMAPLCD_GFX_WINDOW_SKIP 0x04b4
+
+#define OMAPLCD_IRQSTATUS 0x0418
+#define OMAPLCD_IRQENABLE 0x041c
+#define OMAPLCD_CONTROL 0x0440
+#define OMAPLCD_GFX_BA0 0x0480
+#define OMAPLCD_GFX_BA1 0x0484
+#define OMAPLCD_GFX_ROW_INC 0x04ac
+#define OMAPLCD_GFX_PIX_INC 0x04b0
+#define OMAPLCD_VID1_BA0 0x04bc
+#define OMAPLCD_VID1_BA1 0x04c0
+#define OMAPLCD_VID1_ROW_INC 0x04d8
+#define OMAPLCD_VID1_PIX_INC 0x04dc
+
+#define OMAP_CONTROL_GODIGITAL (1 << 6)
+#define OMAP_CONTROL_GOLCD (1 << 5)
+#define OMAP_CONTROL_DIGITALENABLE (1 << 1)
+#define OMAP_CONTROL_LCDENABLE (1 << 0)
+
+#define OMAPLCD_INTMASK_VSYNC (1 << 1)
+#define OMAPLCD_INTMASK_OFF 0
typedef void * OMAP_HANDLE;
unsigned long ulRemoveIndex;
+ void *pvRegs;
+
+
PVRSRV_DC_DISP2SRV_KMJTABLE *psPVRJTable;
OMAP_BOOL bBlanked;
-
- void* pvDevInfo;
+
+ spinlock_t *psSwapChainLock;
} OMAPLFB_SWAPCHAIN;
typedef struct OMAPLFB_FBINFO_TAG
unsigned long ulWidth;
unsigned long ulHeight;
unsigned long ulByteStride;
+ unsigned long ulPhysicalWidthmm;
+ unsigned long ulPhysicalHeightmm;
+
+
IMG_SYS_PHYADDR sSysAddr;
IMG_CPU_VIRTADDR sCPUVAddr;
+
PVRSRV_PIXEL_FORMAT ePixelFormat;
-
-#if defined(SGX_EARLYSUSPEND)
- struct early_suspend early_suspend;
-#endif
-
}OMAPLFB_FBINFO;
typedef struct OMAPLFB_DEVINFO_TAG
{
- unsigned long ulDeviceID;
+ unsigned int uiDeviceID;
OMAPLFB_BUFFER sSystemBuffer;
struct fb_info *psLINFBInfo;
+
struct notifier_block sLINNotifBlock;
+
OMAP_BOOL bDeviceSuspended;
+
+
+ spinlock_t sSwapChainLock;
+
- struct mutex sSwapChainLockMutex;
+
+
IMG_DEV_VIRTADDR sDisplayDevVAddr;
DISPLAY_INFO sDisplayInfo;
+
DISPLAY_FORMAT sDisplayFormat;
+
DISPLAY_DIMS sDisplayDim;
- struct workqueue_struct *vsync_isr_wq;
-
- struct work_struct vsync_work;
-
} OMAPLFB_DEVINFO;
#define OMAPLFB_PAGE_SIZE 4096
#define OMAPLFB_PAGE_ROUNDUP(x) (((x) + OMAPLFB_PAGE_MASK) & OMAPLFB_PAGE_TRUNC)
-#ifdef DEBUG_PVR
+#ifdef DEBUG
#define DEBUG_PRINTK(x) printk x
#else
#define DEBUG_PRINTK(x)
void *OMAPLFBAllocKernelMem(unsigned long ulSize);
void OMAPLFBFreeKernelMem(void *pvMem);
OMAP_ERROR OMAPLFBGetLibFuncAddr(char *szFunctionName, PFN_DC_GET_PVRJTABLE *ppfnFuncTable);
-void OMAPLFBWaitForVSync(void);
+OMAP_ERROR OMAPLFBInstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain);
+OMAP_ERROR OMAPLFBUninstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain);
+OMAP_BOOL OMAPLFBVSyncIHandler(OMAPLFB_SWAPCHAIN *psSwapChain);
+void OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain);
+void OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain);
+#if defined (SUPPORT_TI_DSS_FW)
+void OMAPLFBEnableDisplayRegisterAccess(void);
+void OMAPLFBDisableDisplayRegisterAccess(void);
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr);
+#endif
#if defined (CONFIG_OMAP2_DSS)
IMG_VOID OMAPLFBFlipDSS2(OMAPLFB_SWAPCHAIN *psSwapChain,
- IMG_UINT32 aPhyAddr);
+ IMG_UINT32 aPhyAddr);
#endif
-void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr);
-OMAPLFB_DEVINFO * GetAnchorPtr(void);
+IMG_VOID OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr);
#endif
#include <linux/module.h>
#include <linux/string.h>
#include <linux/notifier.h>
+#include <linux/spinlock.h>
#include "img_defs.h"
#include "servicesext.h"
#include "kerneldisplay.h"
#include "omaplfb.h"
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)
-#define acquire_console_sem console_lock
-#define release_console_sem console_unlock
-#endif
-
static void *gpvAnchor;
static int fb_idx = 0;
#define OMAPLFB_COMMAND_COUNT 1
static PFN_DC_GET_PVRJTABLE pfnGetPVRJTable = 0;
-static void OMAPLFBVSyncIHandler(struct work_struct*);
-OMAPLFB_DEVINFO * GetAnchorPtr(void)
+static OMAPLFB_DEVINFO * GetAnchorPtr(void)
{
return (OMAPLFB_DEVINFO *)gpvAnchor;
}
{
if (psSwapChain->ulSetFlushStateRefCount == 0)
{
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
psSwapChain->bFlushCommands = OMAP_TRUE;
FlushInternalVSyncQueue(psSwapChain);
}
if (psSwapChain->ulSetFlushStateRefCount == 0)
{
psSwapChain->bFlushCommands = OMAP_FALSE;
+ OMAPLFBEnableVSyncInterrupt(psSwapChain);
}
}
}
static IMG_VOID SetFlushStateInternal(OMAPLFB_DEVINFO* psDevInfo,
OMAP_BOOL bFlushState)
{
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
-
+ unsigned long ulLockFlags;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
SetFlushStateInternalNoLock(psDevInfo, bFlushState);
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
}
static void SetFlushStateExternal(OMAPLFB_DEVINFO* psDevInfo,
OMAP_BOOL bFlushState)
{
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ unsigned long ulLockFlags;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
if (psDevInfo->bFlushCommands != bFlushState)
SetFlushStateInternalNoLock(psDevInfo, bFlushState);
}
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
}
static IMG_VOID SetDCState(IMG_HANDLE hDevice, IMG_UINT32 ui32State)
acquire_console_sem();
res = fb_blank(psDevInfo->psLINFBInfo, 0);
release_console_sem();
+#if !defined (CONFIG_OMAP2_DSS)
if (res != 0 && res != -EINVAL)
{
printk(KERN_WARNING DRIVER_PREFIX
": fb_blank failed (%d)", res);
return (OMAP_ERROR_GENERIC);
}
-
+#endif
return (OMAP_OK);
}
#include <linux/workqueue.h>
struct wq_flip {
struct fb_var_screeninfo var;
- struct fb_info *psLINFBInfo;
+ struct fb_info *psLINFBInfo;
struct work_struct work;
};
struct wq_flip wq_flipdss2;
}
/*
- Flip implementation for DSS2 using fb_pan_display
-*/
+ * Flip implementation for DSS2 using fb_pan_display
+ * */
IMG_VOID OMAPLFBFlipDSS2(OMAPLFB_SWAPCHAIN *psSwapChain,
- IMG_UINT32 aPhyAddr)
+ IMG_UINT32 aPhyAddr)
{
- OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr ();
- struct fb_info *psLINFBInfo = psDevInfo->psLINFBInfo;
- memcpy ( &wq_flipdss2.var, &psLINFBInfo->var, sizeof(struct fb_var_screeninfo));
+ OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr ();
+ struct fb_info *psLINFBInfo = psDevInfo->psLINFBInfo;
+ memcpy ( &wq_flipdss2.var, &psLINFBInfo->var, sizeof(struct fb_var_screeninfo));
wq_flipdss2.var.yoffset = (aPhyAddr-psLINFBInfo->fix.smem_start)/psLINFBInfo->fix.line_length;
- wq_flipdss2.psLINFBInfo = psLINFBInfo;
- schedule_work (&wq_flipdss2.work);
+ wq_flipdss2.psLINFBInfo = psLINFBInfo;
+ schedule_work (&wq_flipdss2.work);
}
#endif
+
+
static OMAP_ERROR EnableLFBEventNotification(OMAPLFB_DEVINFO *psDevInfo)
{
int res;
{
DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX
": UnblankDisplay failed (%d)", eError));
- return (PVRSRV_ERROR_GENERIC);
+ return (PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED);
}
IMG_UINT32 *pui32ByteSize,
IMG_VOID **ppvCpuVAddr,
IMG_HANDLE *phOSMapInfo,
- IMG_BOOL *pbIsContiguous)
+ IMG_BOOL *pbIsContiguous,
+ IMG_UINT32 *pui32TilingStride)
{
OMAPLFB_DEVINFO *psDevInfo;
OMAPLFB_BUFFER *psSystemBuffer;
+ UNREFERENCED_PARAMETER(pui32TilingStride);
+
if(!hDevice)
{
return (PVRSRV_ERROR_INVALID_PARAMS);
OMAPLFB_BUFFER *psBuffer;
OMAPLFB_VSYNC_FLIP_ITEM *psVSyncFlips;
IMG_UINT32 i;
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError = PVRSRV_ERROR_NOT_SUPPORTED;
+ unsigned long ulLockFlags;
IMG_UINT32 ui32BuffersToSkip;
+
UNREFERENCED_PARAMETER(ui32OEMFlags);
UNREFERENCED_PARAMETER(pui32SwapChainID);
psSwapChain->ulInsertIndex = 0;
psSwapChain->ulRemoveIndex = 0;
psSwapChain->psPVRJTable = &psDevInfo->sPVRJTable;
- psSwapChain->pvDevInfo = (void*)psDevInfo;
+ psSwapChain->psSwapChainLock = &psDevInfo->sSwapChainLock;
- /* Init the workqueue and its own work */
- INIT_WORK(&psDevInfo->vsync_work, OMAPLFBVSyncIHandler);
- psDevInfo->vsync_isr_wq = create_workqueue("pvr_vsync_wq");
for(i=0; i<ui32BufferCount-1; i++)
{
psBuffer[i].sSysAddr.uiAddr = psDevInfo->sFBInfo.sSysAddr.uiAddr + ui32BufferOffset;
psBuffer[i].sCPUVAddr = psDevInfo->sFBInfo.sCPUVAddr + ui32BufferOffset;
}
+
for(i=0; i<ui32BufferCount; i++)
{
psVSyncFlips[i].bFlipped = OMAP_FALSE;
psVSyncFlips[i].bCmdCompleted = OMAP_FALSE;
}
+
+#if defined (SUPPORT_TI_DSS_FW)
+ OMAPLFBEnableDisplayRegisterAccess();
+
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ psSwapChain->pvRegs = ioremap(psDevInfo->psLINFBInfo->fix.mmio_start, psDevInfo->psLINFBInfo->fix.mmio_len);
+ if (psSwapChain->pvRegs == NULL)
+ {
+ eError = PVRSRV_ERROR_BAD_MAPPING;
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't map registers needed for flipping\n");
+ goto ErrorDisableDisplayRegisters;
+ }
+#endif
+ if (OMAPLFBInstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ eError = PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
+ printk(KERN_WARNING DRIVER_PREFIX ": ISR handler failed to register\n");
+ goto ErrorUnmapRegisters;
+ }
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
psDevInfo->psSwapChain = psSwapChain;
+
psSwapChain->bFlushCommands = psDevInfo->bFlushCommands;
else
{
psSwapChain->ulSetFlushStateRefCount = 0;
+ OMAPLFBEnableVSyncInterrupt(psSwapChain);
}
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
if (EnableLFBEventNotification(psDevInfo)!= OMAP_OK)
{
+ eError = PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT;
printk(KERN_WARNING DRIVER_PREFIX ": Couldn't enable framebuffer event notification\n");
- goto ErrorDisableDisplayRegisters;
+ goto ErrorUninstallVSyncInterrupt;
}
return (PVRSRV_OK);
+ErrorUninstallVSyncInterrupt:
+ if(OMAPLFBUninstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't uninstall VSync ISR\n");
+ }
+ErrorUnmapRegisters:
+#if defined (SUPPORT_TI_DSS_FW)
+ iounmap(psSwapChain->pvRegs);
ErrorDisableDisplayRegisters:
+ OMAPLFBDisableDisplayRegisterAccess();
+#endif
OMAPLFBFreeKernelMem(psVSyncFlips);
ErrorFreeBuffers:
OMAPLFBFreeKernelMem(psBuffer);
{
OMAPLFB_DEVINFO *psDevInfo;
OMAPLFB_SWAPCHAIN *psSwapChain;
+ unsigned long ulLockFlags;
OMAP_ERROR eError;
printk(KERN_WARNING DRIVER_PREFIX ": Couldn't disable framebuffer event notification\n");
}
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
FlushInternalVSyncQueue(psSwapChain);
+
OMAPLFBFlip(psSwapChain, (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
+
psDevInfo->psSwapChain = NULL;
-
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
- /* Destroy the workqueue */
- flush_workqueue(psDevInfo->vsync_isr_wq);
- destroy_workqueue(psDevInfo->vsync_isr_wq);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ if(OMAPLFBUninstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't uninstall VSync ISR\n");
+ return (PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR);
+ }
+
+#if defined (SUPPORT_TI_DSS_FW)
+ iounmap(psSwapChain->pvRegs);
+
+ OMAPLFBDisableDisplayRegisterAccess();
+#endif
OMAPLFBFreeKernelMem(psSwapChain->psVSyncFlips);
OMAPLFBFreeKernelMem(psSwapChain->psBuffer);
{
OMAPLFB_DEVINFO *psDevInfo;
OMAPLFB_SWAPCHAIN *psSwapChain;
+ unsigned long ulLockFlags;
if(!hDevice || !hSwapChain)
{
return (PVRSRV_ERROR_INVALID_PARAMS);
}
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
FlushInternalVSyncQueue(psSwapChain);
+
OMAPLFBFlip(psSwapChain, (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
return (PVRSRV_OK);
}
-static void OMAPLFBVSyncIHandler(struct work_struct *work)
+OMAP_BOOL OMAPLFBVSyncIHandler(OMAPLFB_SWAPCHAIN *psSwapChain)
{
- OMAPLFB_DEVINFO *psDevInfo = container_of(work, OMAPLFB_DEVINFO, vsync_work);
+ OMAP_BOOL bStatus = OMAP_FALSE;
OMAPLFB_VSYNC_FLIP_ITEM *psFlipItem;
- OMAPLFB_SWAPCHAIN *psSwapChain;
unsigned long ulMaxIndex;
-
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
-
- psSwapChain = psDevInfo->psSwapChain;
- if (!psSwapChain || psSwapChain->bFlushCommands)
- goto ExitUnlock;
+ unsigned long ulLockFlags;
psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+ spin_lock_irqsave(psSwapChain->psSwapChainLock, ulLockFlags);
+
- /* VSync with the display here */
- OMAPLFBWaitForVSync();
+ if (psSwapChain->bFlushCommands)
+ {
+ goto ExitUnlock;
+ }
while(psFlipItem->bValid)
{
}
else
{
- queue_work(psDevInfo->vsync_isr_wq, &psDevInfo->vsync_work);
- goto ExitUnlock;
+
+ break;
}
}
else
{
OMAPLFBFlip(psSwapChain, (unsigned long)psFlipItem->sSysAddr);
-
+
+
psFlipItem->bFlipped = OMAP_TRUE;
-
- /*
- * If the flip has been presented here then we need in the next
- * VSYNC execute the command complete, schedule another work
- */
- queue_work(psDevInfo->vsync_isr_wq, &psDevInfo->vsync_work);
-
- goto ExitUnlock;
+
+
+ break;
}
psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
}
-
+
ExitUnlock:
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(psSwapChain->psSwapChainLock, ulLockFlags);
+ return bStatus;
}
static IMG_BOOL ProcessFlip(IMG_HANDLE hCmdCookie,
#if defined(SYS_USING_INTERRUPTS)
OMAPLFB_VSYNC_FLIP_ITEM* psFlipItem;
#endif
+ unsigned long ulLockFlags;
+
if(!hCmdCookie || !pvData)
{
psBuffer = (OMAPLFB_BUFFER*)psFlipCmd->hExtBuffer;
psSwapChain = (OMAPLFB_SWAPCHAIN*) psFlipCmd->hExtSwapChain;
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
if (psDevInfo->bDeviceSuspended)
{
if(psSwapChain->ulInsertIndex == psSwapChain->ulRemoveIndex)
{
- /* If both indexes are equal the queue is empty, present immediatly */
+
OMAPLFBFlip(psSwapChain, (unsigned long)psBuffer->sSysAddr.uiAddr);
psFlipItem->bFlipped = OMAP_TRUE;
psFlipItem->bFlipped = OMAP_FALSE;
}
- /* The buffer is queued here, must be consumed by the VSYNC workqueue */
psFlipItem->hCmdComplete = (OMAP_HANDLE)hCmdCookie;
psFlipItem->ulSwapInterval = (unsigned long)psFlipCmd->ui32SwapInterval;
psFlipItem->sSysAddr = &psBuffer->sSysAddr;
psSwapChain->ulInsertIndex = 0;
}
- /* Give work to the workqueue to sync with the display */
- queue_work(psDevInfo->vsync_isr_wq, &psDevInfo->vsync_work);
-
goto ExitTrueUnlock;
}
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
-
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
return IMG_FALSE;
#endif
ExitTrueUnlock:
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
return IMG_TRUE;
}
psPVRFBInfo->ulFBSize = FBSize;
psPVRFBInfo->ulBufferSize = psPVRFBInfo->ulHeight * psPVRFBInfo->ulByteStride;
-#ifdef CONFIG_OMAP2_DSS
+#ifdef CONFIG_OMAP2_DSS
psPVRFBInfo->ulRoundedBufferSize = psPVRFBInfo->ulBufferSize;
#else
+
psPVRFBInfo->ulRoundedBufferSize = OMAPLFB_PAGE_ROUNDUP(psPVRFBInfo->ulBufferSize);
#endif
-
if(psLINFBInfo->var.bits_per_pixel == 16)
{
if((psLINFBInfo->var.red.length == 5) &&
printk("Unknown FB format\n");
}
+ psDevInfo->sFBInfo.ulPhysicalWidthmm =
+ ((int)psLINFBInfo->var.width > 0) ? psLINFBInfo->var.width : 90;
+
+ psDevInfo->sFBInfo.ulPhysicalHeightmm =
+ ((int)psLINFBInfo->var.height > 0) ? psLINFBInfo->var.height : 54;
+
psDevInfo->sFBInfo.sSysAddr.uiAddr = psPVRFBInfo->sSysAddr.uiAddr;
psDevInfo->sFBInfo.sCPUVAddr = psPVRFBInfo->sCPUVAddr;
-
#ifdef CONFIG_OMAP2_DSS
- INIT_WORK (&wq_flipdss2.work, dss2_pan_display);
+ INIT_WORK (&wq_flipdss2.work, dss2_pan_display);
#endif
-
eError = OMAP_OK;
goto errRelSem;
return (OMAP_ERROR_INIT_FAILURE);
}
- mutex_init(&psDevInfo->sSwapChainLockMutex);
+
+ spin_lock_init(&psDevInfo->sSwapChainLock);
psDevInfo->psSwapChain = 0;
psDevInfo->bFlushCommands = OMAP_FALSE;
psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = (IMG_UINT32)(psDevInfo->sFBInfo.ulFBSize / psDevInfo->sFBInfo.ulRoundedBufferSize);
#if !defined (SUPPORT_TI_DSS_FW)
- /* Limiting the ui32MaxSwapChainBuffers to 3 */
- if (psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers > 3)
- psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = 3;
+ /* DSS2 have trouble with ui32MaxSwapChainBuffers > 3 */
+ if (psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers > 3)
+ psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = 3;
#endif
+
+
if (psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers == 0)
{
psDevInfo->sDisplayInfo.ui32MaxSwapChains = 0;
}
psDevInfo->sDisplayInfo.ui32MinSwapInterval = 0;
+ psDevInfo->sDisplayInfo.ui32PhysicalWidthmm = psDevInfo->sFBInfo.ulPhysicalWidthmm;
+ psDevInfo->sDisplayInfo.ui32PhysicalHeightmm = psDevInfo->sFBInfo.ulPhysicalHeightmm;
+
strncpy(psDevInfo->sDisplayInfo.szDisplayName, DISPLAY_DEVICE_NAME, MAX_DISPLAY_NAME_SIZE);
psDevInfo->sDisplayFormat.pixelformat = psDevInfo->sFBInfo.ePixelFormat;
psDevInfo->sDisplayDim.ui32ByteStride = (IMG_UINT32)psDevInfo->sFBInfo.ulByteStride;
DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
- ": Maximum number of swap chain buffers: %lu\n",
+ ": Maximum number of swap chain buffers: %u\n",
psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers));
if(psDevInfo->sPVRJTable.pfnPVRSRVRegisterDCDevice (
&psDevInfo->sDCJTable,
- &psDevInfo->ulDeviceID ) != PVRSRV_OK)
+ &psDevInfo->uiDeviceID ) != PVRSRV_OK)
{
return (OMAP_ERROR_DEVICE_REGISTER_FAILED);
}
-
+
+
pfnCmdProcList[DC_FLIP_COMMAND] = ProcessFlip;
- if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterCmdProcList (psDevInfo->ulDeviceID,
+ if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterCmdProcList (psDevInfo->uiDeviceID,
&pfnCmdProcList[0],
aui32SyncCountList,
OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable = &psDevInfo->sPVRJTable;
- if (psDevInfo->sPVRJTable.pfnPVRSRVRemoveCmdProcList (psDevInfo->ulDeviceID, OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
+ if (psDevInfo->sPVRJTable.pfnPVRSRVRemoveCmdProcList (psDevInfo->uiDeviceID, OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
{
return (OMAP_ERROR_GENERIC);
}
- if (psJTable->pfnPVRSRVRemoveDCDevice(psDevInfo->ulDeviceID) != PVRSRV_OK)
+ if (psJTable->pfnPVRSRVRemoveDCDevice(psDevInfo->uiDeviceID) != PVRSRV_OK)
{
return (OMAP_ERROR_GENERIC);
}
-
+
DeInitDev(psDevInfo);
void OMAPLFBDriverSuspend(void)
{
OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr();
+ unsigned long ulLockFlags;
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
if (psDevInfo->bDeviceSuspended)
{
SetFlushStateInternalNoLock(psDevInfo, OMAP_TRUE);
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
-
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+#if defined (SUPPORT_TI_DSS_FW)
+ if (psDevInfo->psSwapChain != NULL)
+ {
+ OMAPLFBDisableDisplayRegisterAccess();
+ }
+#endif
return;
ExitUnlock:
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
}
void OMAPLFBDriverResume(void)
{
OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr();
+ unsigned long ulLockFlags;
if (psDevInfo->bDeviceSuspended == OMAP_FALSE)
{
return;
}
+#if defined (SUPPORT_TI_DSS_FW)
+ if (psDevInfo->psSwapChain != NULL)
+ {
+ OMAPLFBEnableDisplayRegisterAccess();
+ }
+#endif
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
- mutex_lock(&psDevInfo->sSwapChainLockMutex);
SetFlushStateInternalNoLock(psDevInfo, OMAP_FALSE);
psDevInfo->bDeviceSuspended = OMAP_FALSE;
- mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
}
#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef AUTOCONF_INCLUDED
+#include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+#include <linux/module.h>
+
+#include <linux/pci.h>
+#include <asm/uaccess.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+
+#if defined(LDM_PLATFORM)
+#include <linux/platform_device.h>
+#endif
+
+#if defined (SUPPORT_TI_DSS_FW)
+#include <asm/io.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
+#include <plat/display.h>
+#else
+#include <mach/display.h>
+#endif
+#else
+#include <asm/arch-omap/display.h>
+#endif
+
+#else
+#if !defined (CONFIG_OMAP2_DSS)
+#define DISPC_IRQ_VSYNC 0x0002
+extern int omap_dispc_request_irq(unsigned long, void (*)(void *), void *);
+extern void omap_dispc_free_irq(unsigned long, void (*)(void *), void *);
+extern void omap_dispc_set_plane_base(int plane, IMG_UINT32 phys_addr);
+#else
+#include <plat/display.h>
+#include <linux/console.h>
+#include <linux/fb.h>
+static omap_dispc_isr_t *pOMAPLFBVSyncISRHandle = NULL;
+#endif
+#endif
+
+
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omaplfb.h"
+#include "pvrmodule.h"
+
+MODULE_SUPPORTED_DEVICE(DEVNAME);
+
+#define unref__ __attribute__ ((unused))
+
+void *OMAPLFBAllocKernelMem(unsigned long ulSize)
+{
+ return kmalloc(ulSize, GFP_KERNEL);
+}
+
+void OMAPLFBFreeKernelMem(void *pvMem)
+{
+ kfree(pvMem);
+}
+
+
+OMAP_ERROR OMAPLFBGetLibFuncAddr (char *szFunctionName, PFN_DC_GET_PVRJTABLE *ppfnFuncTable)
+{
+ if(strcmp("PVRGetDisplayClassJTable", szFunctionName) != 0)
+ {
+ return (OMAP_ERROR_INVALID_PARAMS);
+ }
+
+
+ *ppfnFuncTable = PVRGetDisplayClassJTable;
+
+ return (OMAP_OK);
+}
+
+
+#if defined(SYS_USING_INTERRUPTS)
+
+#if defined(SUPPORT_OMAP3430_OMAPFB3)
+
+static void OMAPLFBVSyncISR(void *arg, u32 mask)
+{
+ OMAPLFB_SWAPCHAIN *psSwapChain= (OMAPLFB_SWAPCHAIN *)arg;
+ (void) OMAPLFBVSyncIHandler(psSwapChain);
+}
+
+static inline int OMAPLFBRegisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ return omap_dispc_register_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQ_VSYNC);
+}
+
+static inline int OMAPLFBUnregisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ return omap_dispc_unregister_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQ_VSYNC);
+}
+
+#else
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+static void OMAPLFBVSyncISR(void *arg)
+#else
+static void OMAPLFBVSyncISR(void *arg, struct pt_regs unref__ *regs)
+#endif
+{
+ OMAPLFB_SWAPCHAIN *psSwapChain= (OMAPLFB_SWAPCHAIN *)arg;
+ (void) OMAPLFBVSyncIHandler(psSwapChain);
+}
+
+static inline int OMAPLFBRegisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+ return omap_dispc_request_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+#else
+ return omap2_disp_register_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQSTATUS_VSYNC);
+#endif
+}
+
+static inline int OMAPLFBUnregisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+ omap_dispc_free_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+ return 0;
+#else
+ return omap2_disp_unregister_isr(OMAPLFBVSyncISR);
+#endif
+}
+
+#endif
+
+#endif
+
+#if !defined (SUPPORT_TI_DSS_FW)
+
+IMG_VOID OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ if (pOMAPLFBVSyncISRHandle == NULL)
+ OMAPLFBInstallVSyncISR (psSwapChain);
+}
+
+IMG_VOID OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ if (pOMAPLFBVSyncISRHandle != NULL)
+ OMAPLFBUninstallVSyncISR (psSwapChain);
+}
+#else
+
+static void OMAPLFBVSyncWriteReg(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long ulOffset, unsigned long ulValue)
+{
+ void *pvRegAddr = (void *)((char *)psSwapChain->pvRegs + ulOffset);
+
+
+ writel(ulValue, pvRegAddr);
+}
+
+static unsigned long OMAPLFBVSyncReadReg(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long ulOffset)
+{
+ return readl((char *)psSwapChain->pvRegs + ulOffset);
+}
+
+void OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+
+ unsigned long ulInterruptEnable = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_IRQENABLE);
+ ulInterruptEnable |= OMAPLCD_INTMASK_VSYNC;
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_IRQENABLE, ulInterruptEnable );
+#endif
+}
+
+void OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+
+ unsigned long ulInterruptEnable = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_IRQENABLE);
+ ulInterruptEnable &= ~(OMAPLCD_INTMASK_VSYNC);
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_IRQENABLE, ulInterruptEnable);
+#endif
+}
+#endif
+
+#if !defined (SUPPORT_TI_DSS_FW)
+OMAP_ERROR OMAPLFBInstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ if (omap_dispc_request_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain) != 0)
+#else
+ pOMAPLFBVSyncISRHandle = omap_dispc_register_isr(
+ (omap_dispc_isr_t)OMAPLFBVSyncISR, psSwapChain, DISPC_IRQ_VSYNC);
+
+ if (pOMAPLFBVSyncISRHandle != NULL)
+#endif
+ return PVRSRV_ERROR_OUT_OF_MEMORY; /* not worth a proper mapping */
+ return OMAP_OK;
+}
+
+
+OMAP_ERROR OMAPLFBUninstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ omap_dispc_free_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+#else
+ omap_dispc_unregister_isr (OMAPLFBVSyncISR, psSwapChain, DISPC_IRQ_VSYNC);
+#endif
+ return OMAP_OK;
+}
+
+
+IMG_VOID OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ omap_dispc_set_plane_base(0, aPhyAddr);
+#else
+ OMAPLFBFlipDSS2 (psSwapChain, aPhyAddr);
+#endif
+}
+#else
+
+OMAP_ERROR OMAPLFBInstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
+ if (OMAPLFBRegisterVSyncISR(psSwapChain))
+ {
+ printk(KERN_INFO DRIVER_PREFIX ": OMAPLFBInstallVSyncISR: Request OMAPLCD IRQ failed\n");
+ return (OMAP_ERROR_INIT_FAILURE);
+ }
+
+#endif
+ return (OMAP_OK);
+}
+
+
+OMAP_ERROR OMAPLFBUninstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
+ OMAPLFBUnregisterVSyncISR(psSwapChain);
+
+#endif
+ return (OMAP_OK);
+}
+
+void OMAPLFBEnableDisplayRegisterAccess(void)
+{
+#if !defined(SUPPORT_OMAP3430_OMAPFB3)
+ omap2_disp_get_dss();
+#endif
+}
+
+void OMAPLFBDisableDisplayRegisterAccess(void)
+{
+#if !defined(SUPPORT_OMAP3430_OMAPFB3)
+ omap2_disp_put_dss();
+#endif
+}
+
+
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr)
+{
+ unsigned long control;
+
+
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_GFX_BA0, aPhyAddr);
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_GFX_BA1, aPhyAddr);
+
+ control = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_CONTROL);
+ control |= OMAP_CONTROL_GOLCD;
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_CONTROL, control);
+}
+#endif
+
+#if defined(LDM_PLATFORM)
+
+static OMAP_BOOL bDeviceSuspended;
+
+static void OMAPLFBCommonSuspend(void)
+{
+ if (bDeviceSuspended)
+ {
+ return;
+ }
+
+ OMAPLFBDriverSuspend();
+
+ bDeviceSuspended = OMAP_TRUE;
+}
+
+static int OMAPLFBDriverSuspend_Entry(struct platform_device unref__ *pDevice, pm_message_t unref__ state)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverSuspend_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+
+ return 0;
+}
+
+static int OMAPLFBDriverResume_Entry(struct platform_device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverResume_Entry\n"));
+
+ OMAPLFBDriverResume();
+
+ bDeviceSuspended = OMAP_FALSE;
+
+ return 0;
+}
+
+static IMG_VOID OMAPLFBDriverShutdown_Entry(struct platform_device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverShutdown_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+}
+
+static struct platform_driver omaplfb_driver = {
+ .driver = {
+ .name = DRVNAME,
+ },
+ .suspend = OMAPLFBDriverSuspend_Entry,
+ .resume = OMAPLFBDriverResume_Entry,
+ .shutdown = OMAPLFBDriverShutdown_Entry,
+};
+
+#if defined(MODULE)
+
+static void OMAPLFBDeviceRelease_Entry(struct device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverRelease_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+}
+
+static struct platform_device omaplfb_device = {
+ .name = DEVNAME,
+ .id = -1,
+ .dev = {
+ .release = OMAPLFBDeviceRelease_Entry
+ }
+};
+
+#endif
+
+#endif
+
+static int __init OMAPLFB_Init(void)
+{
+#if defined(LDM_PLATFORM)
+ int error;
+#endif
+
+ if(OMAPLFBInit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBInit failed\n");
+ return -ENODEV;
+ }
+
+#if defined(LDM_PLATFORM)
+ if ((error = platform_driver_register(&omaplfb_driver)) != 0)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform driver (%d)\n", error);
+
+ goto ExitDeinit;
+ }
+
+#if defined(MODULE)
+ if ((error = platform_device_register(&omaplfb_device)) != 0)
+ {
+ platform_driver_unregister(&omaplfb_driver);
+
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform device (%d)\n", error);
+
+ goto ExitDeinit;
+ }
+#endif
+
+#endif
+
+ return 0;
+
+#if defined(LDM_PLATFORM)
+ExitDeinit:
+ if(OMAPLFBDeinit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBDeinit failed\n");
+ }
+
+ return -ENODEV;
+#endif
+}
+
+static IMG_VOID __exit OMAPLFB_Cleanup(IMG_VOID)
+{
+#if defined (LDM_PLATFORM)
+#if defined (MODULE)
+ platform_device_unregister(&omaplfb_device);
+#endif
+ platform_driver_unregister(&omaplfb_driver);
+#endif
+
+ if(OMAPLFBDeinit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Cleanup: OMAPLFBDeinit failed\n");
+ }
+}
+
+module_init(OMAPLFB_Init);
+module_exit(OMAPLFB_Cleanup);
+
+++ /dev/null
-/**********************************************************************
- *
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful but, except
- * as otherwise stated in writing, without any warranty; without even the
- * implied warranty of merchantability or fitness for a particular purpose.
- * See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * The full GNU General Public License is included in this distribution in
- * the file called "COPYING".
- *
- * Contact Information:
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
- *
- ******************************************************************************/
-
-#ifndef AUTOCONF_INCLUDED
-#include <linux/config.h>
-#endif
-
-#include <linux/version.h>
-#include <linux/module.h>
-
-#include <linux/fb.h>
-#include <linux/omapfb.h>
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
-#include <plat/vrfb.h>
-#else
-#include <mach/vrfb.h>
-#endif
-#include <../drivers/video/omap2/omapfb/omapfb.h>
-
-#if defined(LDM_PLATFORM)
-#include <linux/platform_device.h>
-#endif
-
-#include <asm/io.h>
-
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0))
-#include <video/omapdss.h>
-#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32))
-#include <plat/display.h>
-#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
-#include <mach/display.h>
-#else
-#include <asm/arch-omap/display.h>
-#endif
-
-#include "img_defs.h"
-#include "servicesext.h"
-#include "kerneldisplay.h"
-#include "omaplfb.h"
-#include "pvrmodule.h"
-
-MODULE_SUPPORTED_DEVICE(DEVNAME);
-
-#define unref__ __attribute__ ((unused))
-
-static struct omap_overlay_manager* lcd_mgr = 0;
-
-void *OMAPLFBAllocKernelMem(unsigned long ulSize)
-{
- return kmalloc(ulSize, GFP_KERNEL);
-}
-
-void OMAPLFBFreeKernelMem(void *pvMem)
-{
- kfree(pvMem);
-}
-
-
-OMAP_ERROR OMAPLFBGetLibFuncAddr (char *szFunctionName, PFN_DC_GET_PVRJTABLE *ppfnFuncTable)
-{
- if(strcmp("PVRGetDisplayClassJTable", szFunctionName) != 0)
- {
- return (OMAP_ERROR_INVALID_PARAMS);
- }
-
-
- *ppfnFuncTable = PVRGetDisplayClassJTable;
-
- return (OMAP_OK);
-}
-
-static void GetLcdManager(void){
- lcd_mgr = omap_dss_get_overlay_manager(OMAP_DSS_OVL_MGR_LCD);
- if(!lcd_mgr)
- {
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": GetLcdManager couldn't find lcd overlay manager\n"));
- }
-
-}
-
-
-void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr)
-{
- OMAPLFBFlipDSS2 (psSwapChain, aPhyAddr);
-}
-
-void OMAPLFBWaitForVSync(void)
-{
-#if 0
- if (lcd_mgr && lcd_mgr->device)
- lcd_mgr->device->wait_vsync(lcd_mgr->device);
-#endif
-}
-
-
-#if defined(LDM_PLATFORM)
-
-static volatile OMAP_BOOL bDeviceSuspended;
-
-#if !defined(SGX_EARLYSUSPEND)
-
-static void OMAPLFBCommonSuspend(void)
-{
- if (bDeviceSuspended)
- {
- return;
- }
-
- OMAPLFBDriverSuspend();
-
- bDeviceSuspended = OMAP_TRUE;
-}
-
-static int OMAPLFBDriverSuspend_Entry(struct platform_device unref__ *pDevice, pm_message_t unref__ state)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverSuspend_Entry\n"));
-
- OMAPLFBCommonSuspend();
-
- return 0;
-}
-
-static int OMAPLFBDriverResume_Entry(struct platform_device unref__ *pDevice)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverResume_Entry\n"));
-
- OMAPLFBDriverResume();
-
- bDeviceSuspended = OMAP_FALSE;
-
- return 0;
-}
-
-static IMG_VOID OMAPLFBDriverShutdown_Entry(struct platform_device unref__ *pDevice)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverShutdown_Entry\n"));
-
- OMAPLFBCommonSuspend();
-}
-
-#else /* !defined(SGX_EARLYSUSPEND) */
-static void OMAPLFBCommonSuspend(void)
-{
-
- if (bDeviceSuspended)
- {
- return;
- }
-
- OMAPLFBDriverSuspend();
-
- bDeviceSuspended = OMAP_TRUE;
-
-}
-
-static void OMAPLFBDriverSuspend_Entry(struct early_suspend *h)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverSuspend_Entry\n"));
-
- printk(KERN_WARNING DRIVER_PREFIX ": **** SUSPEND\n");
-
- OMAPLFBCommonSuspend();
-
-}
-
-static void OMAPLFBDriverResume_Entry(struct early_suspend *h)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverResume_Entry\n"));
-
- printk(KERN_WARNING DRIVER_PREFIX ": **** RESUME\n");
-
- OMAPLFBDriverResume();
-
- bDeviceSuspended = OMAP_FALSE;
-
-}
-#endif /* !defined(SGX_EARLYSUSPEND) */
-
-static struct platform_driver omaplfb_driver = {
- .driver = {
- .name = DRVNAME,
- },
-#if !defined(SGX_EARLYSUSPEND)
- .suspend = OMAPLFBDriverSuspend_Entry,
- .resume = OMAPLFBDriverResume_Entry,
- .shutdown = OMAPLFBDriverShutdown_Entry,
-#endif
-};
-
-#if defined(MODULE)
-
-static void OMAPLFBDeviceRelease_Entry(struct device unref__ *pDevice)
-{
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverRelease_Entry\n"));
-
- OMAPLFBCommonSuspend();
-}
-
-static struct platform_device omaplfb_device = {
- .name = DEVNAME,
- .id = -1,
- .dev = {
- .release = OMAPLFBDeviceRelease_Entry
- }
-};
-
-#endif /* defined(MODULE) */
-
-#endif /* defined(LDM_PLATFORM) */
-
-#if defined(SGX_EARLYSUSPEND)
- OMAPLFB_DEVINFO *psDevInfo;
-#endif
-
-static int __init OMAPLFB_Init(void)
-{
-#if defined(LDM_PLATFORM)
- int error;
-#endif
-
- if(OMAPLFBInit() != OMAP_OK)
- {
- printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBInit failed\n");
- return -ENODEV;
- }
-
- /* Get the LCD manager which corresponds to the primary display*/
- GetLcdManager();
-
-#if defined(LDM_PLATFORM)
- if ((error = platform_driver_register(&omaplfb_driver)) != 0)
- {
- printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform driver (%d)\n", error);
-
- goto ExitDeinit;
- }
-
-#if defined(MODULE)
- if ((error = platform_device_register(&omaplfb_device)) != 0)
- {
- printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform device (%d)\n", error);
-
- goto ExitDeinit;
- }
-#endif /* defined(MODULE) */
-
-#if defined(SGX_EARLYSUSPEND)
- psDevInfo = NULL;
- psDevInfo = GetAnchorPtr();
-
- if (psDevInfo == NULL)
- {
- DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFB_Init: Unable to get DevInfo anchor pointer\n"));
- goto ExitDeinit;
- }
-
- psDevInfo->sFBInfo.early_suspend.suspend = OMAPLFBDriverSuspend_Entry;
- psDevInfo->sFBInfo.early_suspend.resume = OMAPLFBDriverResume_Entry;
- psDevInfo->sFBInfo.early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
- register_early_suspend(&psDevInfo->sFBInfo.early_suspend);
-#endif /* defined(SGX_EARLYSUSPEND) */
-
-#endif /* defined(LDM_PLATFORM) */
-
- return 0;
-
-#if defined(LDM_PLATFORM)
-ExitDeinit:
- platform_driver_unregister(&omaplfb_driver);
-
-#if defined(SGX_EARLYSUSPEND)
- unregister_early_suspend(&psDevInfo->sFBInfo.early_suspend);
-#endif
- if(OMAPLFBDeinit() != OMAP_OK)
- {
- printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBDeinit failed\n");
- }
-
- return -ENODEV;
-#endif /* defined(LDM_PLATFORM) */
-}
-
-static IMG_VOID __exit OMAPLFB_Cleanup(IMG_VOID)
-{
-#if defined (LDM_PLATFORM)
-#if defined (MODULE)
- platform_device_unregister(&omaplfb_device);
-#endif
- platform_driver_unregister(&omaplfb_driver);
-#endif /* defined (LDM_PLATFORM) */
-
-#if defined(SGX_EARLYSUSPEND)
- unregister_early_suspend(&psDevInfo->sFBInfo.early_suspend);
-#endif
-
- if(OMAPLFBDeinit() != OMAP_OK)
- {
- printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Cleanup: OMAPLFBDeinit failed\n");
- }
-}
-
-module_init(OMAPLFB_Init);
-module_exit(OMAPLFB_Cleanup);
-
--- /dev/null
+SYS_USING_INTERRUPTS = 1
+SUPPORT_OMAP3430_OMAPFB3 =1
+SUPPORT_TI_DSS_FW = 0
+
+SYS_CFLAGS.$(SYS_USING_INTERRUPTS) += -DSYS_USING_INTERRUPTS
+SYS_CFLAGS.$(SUPPORT_OMAP3430_OMAPFB3) += -DSUPPORT_OMAP3430_OMAPFB3
+SYS_CFLAGS.$(SUPPORT_TI_DSS_FW) += -DSUPPORT_TI_DSS_FW
+
+EXTRA_CFLAGS = -DLINUX \
+ -DCONFIG_OMAP2_DSS \
+ -I$(PVR_BUILD_DIR)/include4 \
+ -I$(PVR_BUILD_DIR)/services4/include \
+ -I$(PVR_BUILD_DIR)/services4/system/$(PVR_SYSTEM) \
+ -I$(PVR_BUILD_DIR)/services4/system/include \
+ $(SYS_CFLAGS.1) \
+
+ifneq ($(FBDEV),no)
+EXTRA_CFLAGS += -DFBDEV_PRESENT
+endif
+
+obj-m := omaplfb.o
+omaplfb-y := omaplfb_displayclass.o omaplfb_linux.o
--- /dev/null
+#
+# Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope it will be useful but, except
+# as otherwise stated in writing, without any warranty; without even the
+# implied warranty of merchantability or fitness for a particular purpose.
+# See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# The full GNU General Public License is included in this distribution in
+# the file called "COPYING".
+#
+# Contact Information:
+# Imagination Technologies Ltd. <gpl-support@imgtec.com>
+# Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+#
+#
+#
+
+MODULE = omaplfb
+
+INCLUDES = -I$(EURASIAROOT)/include4 \
+ -I$(EURASIAROOT)/services4/include \
+ -I$(EURASIAROOT)/services4/system/$(PVR_SYSTEM) \
+ -I$(EURASIAROOT)/services4/system/include \
+
+SOURCES = ../omaplfb_displayclass.c \
+ ../omaplfb_linux.c
+
+SYM_VERS_DEPS = $(EURASIAROOT)/services4/srvkm/env/linux
+
+include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
--- /dev/null
+kernel//proj/SGX_Graphics/mahesh/sgxsdk/Graphics_SDK_4_03_00_02/GFX_Linux_KM/services4/3rdparty/dc_ti81xx_linux/omaplfb.ko
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef __OMAPLFB_H__
+#define __OMAPLFB_H__
+
+#define OMAPLCD_IRQ 25
+
+#define OMAPLCD_SYSCONFIG 0x0410
+#define OMAPLCD_CONFIG 0x0444
+#define OMAPLCD_DEFAULT_COLOR0 0x044C
+#define OMAPLCD_TIMING_H 0x0464
+#define OMAPLCD_TIMING_V 0x0468
+#define OMAPLCD_POL_FREQ 0x046C
+#define OMAPLCD_DIVISOR 0x0470
+#define OMAPLCD_SIZE_DIG 0x0478
+#define OMAPLCD_SIZE_LCD 0x047C
+#define OMAPLCD_GFX_POSITION 0x0488
+#define OMAPLCD_GFX_SIZE 0x048C
+#define OMAPLCD_GFX_ATTRIBUTES 0x04a0
+#define OMAPLCD_GFX_FIFO_THRESHOLD 0x04a4
+#define OMAPLCD_GFX_WINDOW_SKIP 0x04b4
+
+#define OMAPLCD_IRQSTATUS 0x0418
+#define OMAPLCD_IRQENABLE 0x041c
+#define OMAPLCD_CONTROL 0x0440
+#define OMAPLCD_GFX_BA0 0x0480
+#define OMAPLCD_GFX_BA1 0x0484
+#define OMAPLCD_GFX_ROW_INC 0x04ac
+#define OMAPLCD_GFX_PIX_INC 0x04b0
+#define OMAPLCD_VID1_BA0 0x04bc
+#define OMAPLCD_VID1_BA1 0x04c0
+#define OMAPLCD_VID1_ROW_INC 0x04d8
+#define OMAPLCD_VID1_PIX_INC 0x04dc
+
+#define OMAP_CONTROL_GODIGITAL (1 << 6)
+#define OMAP_CONTROL_GOLCD (1 << 5)
+#define OMAP_CONTROL_DIGITALENABLE (1 << 1)
+#define OMAP_CONTROL_LCDENABLE (1 << 0)
+
+#define OMAPLCD_INTMASK_VSYNC (1 << 1)
+#define OMAPLCD_INTMASK_OFF 0
+
+typedef void * OMAP_HANDLE;
+
+typedef enum tag_omap_bool
+{
+ OMAP_FALSE = 0,
+ OMAP_TRUE = 1,
+} OMAP_BOOL, *OMAP_PBOOL;
+
+typedef struct OMAPLFB_BUFFER_TAG
+{
+ unsigned long ulBufferSize;
+
+
+
+
+ IMG_SYS_PHYADDR sSysAddr;
+ IMG_CPU_VIRTADDR sCPUVAddr;
+ PVRSRV_SYNC_DATA *psSyncData;
+
+ struct OMAPLFB_BUFFER_TAG *psNext;
+} OMAPLFB_BUFFER;
+
+typedef struct OMAPLFB_VSYNC_FLIP_ITEM_TAG
+{
+
+
+
+ OMAP_HANDLE hCmdComplete;
+
+ unsigned long ulSwapInterval;
+
+ OMAP_BOOL bValid;
+
+ OMAP_BOOL bFlipped;
+
+ OMAP_BOOL bCmdCompleted;
+
+
+
+
+
+ IMG_SYS_PHYADDR* sSysAddr;
+} OMAPLFB_VSYNC_FLIP_ITEM;
+
+typedef struct PVRPDP_SWAPCHAIN_TAG
+{
+
+ unsigned long ulBufferCount;
+
+ OMAPLFB_BUFFER *psBuffer;
+
+ OMAPLFB_VSYNC_FLIP_ITEM *psVSyncFlips;
+
+
+ unsigned long ulInsertIndex;
+
+
+ unsigned long ulRemoveIndex;
+
+
+ void *pvRegs;
+
+
+ PVRSRV_DC_DISP2SRV_KMJTABLE *psPVRJTable;
+
+
+ OMAP_BOOL bFlushCommands;
+
+
+ unsigned long ulSetFlushStateRefCount;
+
+
+ OMAP_BOOL bBlanked;
+
+
+ spinlock_t *psSwapChainLock;
+} OMAPLFB_SWAPCHAIN;
+
+typedef struct OMAPLFB_FBINFO_TAG
+{
+ unsigned long ulFBSize;
+ unsigned long ulBufferSize;
+ unsigned long ulRoundedBufferSize;
+ unsigned long ulWidth;
+ unsigned long ulHeight;
+ unsigned long ulByteStride;
+ unsigned long ulPhysicalWidthmm;
+ unsigned long ulPhysicalHeightmm;
+
+
+
+ IMG_SYS_PHYADDR sSysAddr;
+ IMG_CPU_VIRTADDR sCPUVAddr;
+
+
+ PVRSRV_PIXEL_FORMAT ePixelFormat;
+}OMAPLFB_FBINFO;
+
+typedef struct OMAPLFB_DEVINFO_TAG
+{
+ unsigned int uiDeviceID;
+
+
+ OMAPLFB_BUFFER sSystemBuffer;
+
+
+ PVRSRV_DC_DISP2SRV_KMJTABLE sPVRJTable;
+
+
+ PVRSRV_DC_SRV2DISP_KMJTABLE sDCJTable;
+
+
+ OMAPLFB_FBINFO sFBInfo;
+
+
+ unsigned long ulRefCount;
+
+
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+
+
+ OMAP_BOOL bFlushCommands;
+
+
+ struct fb_info *psLINFBInfo;
+
+
+ struct notifier_block sLINNotifBlock;
+
+
+ OMAP_BOOL bDeviceSuspended;
+
+
+ spinlock_t sSwapChainLock;
+
+
+
+
+
+ IMG_DEV_VIRTADDR sDisplayDevVAddr;
+
+ DISPLAY_INFO sDisplayInfo;
+
+
+ DISPLAY_FORMAT sDisplayFormat;
+
+
+ DISPLAY_DIMS sDisplayDim;
+
+} OMAPLFB_DEVINFO;
+
+#define OMAPLFB_PAGE_SIZE 4096
+#define OMAPLFB_PAGE_MASK (OMAPLFB_PAGE_SIZE - 1)
+#define OMAPLFB_PAGE_TRUNC (~OMAPLFB_PAGE_MASK)
+
+#define OMAPLFB_PAGE_ROUNDUP(x) (((x) + OMAPLFB_PAGE_MASK) & OMAPLFB_PAGE_TRUNC)
+
+#ifdef DEBUG
+#define DEBUG_PRINTK(x) printk x
+#else
+#define DEBUG_PRINTK(x)
+#endif
+
+#define DISPLAY_DEVICE_NAME "PowerVR OMAP Linux Display Driver"
+#define DRVNAME "omaplfb"
+#define DEVNAME DRVNAME
+#define DRIVER_PREFIX DRVNAME
+
+typedef enum _OMAP_ERROR_
+{
+ OMAP_OK = 0,
+ OMAP_ERROR_GENERIC = 1,
+ OMAP_ERROR_OUT_OF_MEMORY = 2,
+ OMAP_ERROR_TOO_FEW_BUFFERS = 3,
+ OMAP_ERROR_INVALID_PARAMS = 4,
+ OMAP_ERROR_INIT_FAILURE = 5,
+ OMAP_ERROR_CANT_REGISTER_CALLBACK = 6,
+ OMAP_ERROR_INVALID_DEVICE = 7,
+ OMAP_ERROR_DEVICE_REGISTER_FAILED = 8
+} OMAP_ERROR;
+
+
+#ifndef UNREFERENCED_PARAMETER
+#define UNREFERENCED_PARAMETER(param) (param) = (param)
+#endif
+
+OMAP_ERROR OMAPLFBInit(void);
+OMAP_ERROR OMAPLFBDeinit(void);
+
+#ifdef LDM_PLATFORM
+void OMAPLFBDriverSuspend(void);
+void OMAPLFBDriverResume(void);
+#endif
+
+void *OMAPLFBAllocKernelMem(unsigned long ulSize);
+void OMAPLFBFreeKernelMem(void *pvMem);
+OMAP_ERROR OMAPLFBGetLibFuncAddr(char *szFunctionName, PFN_DC_GET_PVRJTABLE *ppfnFuncTable);
+OMAP_ERROR OMAPLFBInstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain);
+OMAP_ERROR OMAPLFBUninstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain);
+OMAP_BOOL OMAPLFBVSyncIHandler(OMAPLFB_SWAPCHAIN *psSwapChain);
+void OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain);
+void OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain);
+#if defined (SUPPORT_TI_DSS_FW)
+void OMAPLFBEnableDisplayRegisterAccess(void);
+void OMAPLFBDisableDisplayRegisterAccess(void);
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr);
+#endif
+#if defined (CONFIG_OMAP2_DSS)
+IMG_VOID OMAPLFBFlipDSS2(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr);
+#endif
+
+IMG_VOID OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr);
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/console.h>
+#include <linux/fb.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/notifier.h>
+#include <linux/spinlock.h>
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omaplfb.h"
+
+static void *gpvAnchor;
+
+static int fb_idx = 0;
+
+#define OMAPLFB_COMMAND_COUNT 1
+
+static PFN_DC_GET_PVRJTABLE pfnGetPVRJTable = 0;
+
+static OMAPLFB_DEVINFO * GetAnchorPtr(void)
+{
+ return (OMAPLFB_DEVINFO *)gpvAnchor;
+}
+
+static void SetAnchorPtr(OMAPLFB_DEVINFO *psDevInfo)
+{
+ gpvAnchor = (void*)psDevInfo;
+}
+
+
+static void FlushInternalVSyncQueue(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ OMAPLFB_VSYNC_FLIP_ITEM *psFlipItem;
+ unsigned long ulMaxIndex;
+ unsigned long i;
+
+
+ psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
+ ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+ for(i = 0; i < psSwapChain->ulBufferCount; i++)
+ {
+ if (psFlipItem->bValid == OMAP_FALSE)
+ {
+ continue;
+ }
+
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": FlushInternalVSyncQueue: Flushing swap buffer (index %lu)\n", psSwapChain->ulRemoveIndex));
+
+ if(psFlipItem->bFlipped == OMAP_FALSE)
+ {
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psFlipItem->sSysAddr);
+ }
+
+ if(psFlipItem->bCmdCompleted == OMAP_FALSE)
+ {
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": FlushInternalVSyncQueue: Calling command complete for swap buffer (index %lu)\n", psSwapChain->ulRemoveIndex));
+
+ psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete((IMG_HANDLE)psFlipItem->hCmdComplete, IMG_TRUE);
+ }
+
+
+ psSwapChain->ulRemoveIndex++;
+
+ if(psSwapChain->ulRemoveIndex > ulMaxIndex)
+ {
+ psSwapChain->ulRemoveIndex = 0;
+ }
+
+
+ psFlipItem->bFlipped = OMAP_FALSE;
+ psFlipItem->bCmdCompleted = OMAP_FALSE;
+ psFlipItem->bValid = OMAP_FALSE;
+
+
+ psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
+ }
+
+ psSwapChain->ulInsertIndex = 0;
+ psSwapChain->ulRemoveIndex = 0;
+}
+
+static void SetFlushStateInternalNoLock(OMAPLFB_DEVINFO* psDevInfo,
+ OMAP_BOOL bFlushState)
+{
+ OMAPLFB_SWAPCHAIN *psSwapChain = psDevInfo->psSwapChain;
+
+ if (psSwapChain == NULL)
+ {
+ return;
+ }
+
+ if (bFlushState)
+ {
+ if (psSwapChain->ulSetFlushStateRefCount == 0)
+ {
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+ psSwapChain->bFlushCommands = OMAP_TRUE;
+ FlushInternalVSyncQueue(psSwapChain);
+ }
+ psSwapChain->ulSetFlushStateRefCount++;
+ }
+ else
+ {
+ if (psSwapChain->ulSetFlushStateRefCount != 0)
+ {
+ psSwapChain->ulSetFlushStateRefCount--;
+ if (psSwapChain->ulSetFlushStateRefCount == 0)
+ {
+ psSwapChain->bFlushCommands = OMAP_FALSE;
+ OMAPLFBEnableVSyncInterrupt(psSwapChain);
+ }
+ }
+ }
+}
+
+static IMG_VOID SetFlushStateInternal(OMAPLFB_DEVINFO* psDevInfo,
+ OMAP_BOOL bFlushState)
+{
+ unsigned long ulLockFlags;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ SetFlushStateInternalNoLock(psDevInfo, bFlushState);
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+}
+
+static void SetFlushStateExternal(OMAPLFB_DEVINFO* psDevInfo,
+ OMAP_BOOL bFlushState)
+{
+ unsigned long ulLockFlags;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
+ if (psDevInfo->bFlushCommands != bFlushState)
+ {
+ psDevInfo->bFlushCommands = bFlushState;
+ SetFlushStateInternalNoLock(psDevInfo, bFlushState);
+ }
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+}
+
+static IMG_VOID SetDCState(IMG_HANDLE hDevice, IMG_UINT32 ui32State)
+{
+ OMAPLFB_DEVINFO *psDevInfo = (OMAPLFB_DEVINFO *)hDevice;
+
+ switch (ui32State)
+ {
+ case DC_STATE_FLUSH_COMMANDS:
+ SetFlushStateExternal(psDevInfo, OMAP_TRUE);
+ break;
+ case DC_STATE_NO_FLUSH_COMMANDS:
+ SetFlushStateExternal(psDevInfo, OMAP_FALSE);
+ break;
+ default:
+ break;
+ }
+
+ return;
+}
+
+static int FrameBufferEvents(struct notifier_block *psNotif,
+ unsigned long event, void *data)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+ struct fb_event *psFBEvent = (struct fb_event *)data;
+ OMAP_BOOL bBlanked;
+
+
+ if (event != FB_EVENT_BLANK)
+ {
+ return 0;
+ }
+
+ psDevInfo = GetAnchorPtr();
+ psSwapChain = psDevInfo->psSwapChain;
+
+ bBlanked = (*(IMG_INT *)psFBEvent->data != 0) ? OMAP_TRUE: OMAP_FALSE;
+
+ if (bBlanked != psSwapChain->bBlanked)
+ {
+ psSwapChain->bBlanked = bBlanked;
+
+ if (bBlanked)
+ {
+
+ SetFlushStateInternal(psDevInfo, OMAP_TRUE);
+ }
+ else
+ {
+
+ SetFlushStateInternal(psDevInfo, OMAP_FALSE);
+ }
+ }
+
+ return 0;
+}
+
+
+static OMAP_ERROR UnblankDisplay(OMAPLFB_DEVINFO *psDevInfo)
+{
+ int res;
+#ifdef FBDEV_PRESENT
+
+ acquire_console_sem();
+ res = fb_blank(psDevInfo->psLINFBInfo, 0);
+ release_console_sem();
+#if !defined (CONFIG_OMAP2_DSS)
+ if (res != 0 && res != -EINVAL)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX
+ ": fb_blank failed (%d)", res);
+ return (OMAP_ERROR_GENERIC);
+ }
+#endif
+#endif
+ return (OMAP_OK);
+}
+
+#if defined (CONFIG_OMAP2_DSS)
+#include <linux/workqueue.h>
+struct wq_flip {
+ struct fb_var_screeninfo var;
+ struct fb_info *psLINFBInfo;
+ struct work_struct work;
+};
+struct wq_flip wq_flipdss2;
+
+static void dss2_pan_display (struct work_struct *work)
+{
+ struct wq_flip *ptrwq_flip =
+ container_of(work, struct wq_flip, work);
+ if (ptrwq_flip->psLINFBInfo->fbops->fb_pan_display != NULL) {
+ ptrwq_flip->psLINFBInfo->fbops->fb_pan_display (&ptrwq_flip->var, ptrwq_flip->psLINFBInfo);
+
+ }
+
+}
+
+/*
+ * Flip implementation for DSS2 using fb_pan_display
+ * */
+IMG_VOID OMAPLFBFlipDSS2(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr)
+{
+ OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr ();
+ struct fb_info *psLINFBInfo = psDevInfo->psLINFBInfo;
+ memcpy ( &wq_flipdss2.var, &psLINFBInfo->var, sizeof(struct fb_var_screeninfo));
+ wq_flipdss2.var.yoffset = (aPhyAddr-psLINFBInfo->fix.smem_start)/psLINFBInfo->fix.line_length;
+ wq_flipdss2.psLINFBInfo = psLINFBInfo;
+ schedule_work (&wq_flipdss2.work);
+}
+#endif
+
+
+
+static OMAP_ERROR EnableLFBEventNotification(OMAPLFB_DEVINFO *psDevInfo)
+{
+ int res;
+ OMAPLFB_SWAPCHAIN *psSwapChain = psDevInfo->psSwapChain;
+ OMAP_ERROR eError;
+
+
+ memset(&psDevInfo->sLINNotifBlock, 0, sizeof(psDevInfo->sLINNotifBlock));
+
+ psDevInfo->sLINNotifBlock.notifier_call = FrameBufferEvents;
+
+ psSwapChain->bBlanked = OMAP_FALSE;
+
+ res = fb_register_client(&psDevInfo->sLINNotifBlock);
+ if (res != 0)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX
+ ": fb_register_client failed (%d)", res);
+
+ return (OMAP_ERROR_GENERIC);
+ }
+
+ eError = UnblankDisplay(psDevInfo);
+ if (eError != OMAP_OK)
+ {
+ DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX
+ ": UnblankDisplay failed (%d)", eError));
+ return eError;
+ }
+
+ return (OMAP_OK);
+}
+
+static OMAP_ERROR DisableLFBEventNotification(OMAPLFB_DEVINFO *psDevInfo)
+{
+ int res;
+
+
+ res = fb_unregister_client(&psDevInfo->sLINNotifBlock);
+ if (res != 0)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX
+ ": fb_unregister_client failed (%d)", res);
+ return (OMAP_ERROR_GENERIC);
+ }
+
+ return (OMAP_OK);
+}
+
+static PVRSRV_ERROR OpenDCDevice(IMG_UINT32 ui32DeviceID,
+ IMG_HANDLE *phDevice,
+ PVRSRV_SYNC_DATA* psSystemBufferSyncData)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAP_ERROR eError;
+
+ UNREFERENCED_PARAMETER(ui32DeviceID);
+
+ psDevInfo = GetAnchorPtr();
+
+
+ psDevInfo->sSystemBuffer.psSyncData = psSystemBufferSyncData;
+
+ eError = UnblankDisplay(psDevInfo);
+ if (eError != OMAP_OK)
+ {
+ DEBUG_PRINTK((KERN_WARNING DRIVER_PREFIX
+ ": UnblankDisplay failed (%d)", eError));
+ return (PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED);
+ }
+
+
+ *phDevice = (IMG_HANDLE)psDevInfo;
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR CloseDCDevice(IMG_HANDLE hDevice)
+{
+ UNREFERENCED_PARAMETER(hDevice);
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR EnumDCFormats(IMG_HANDLE hDevice,
+ IMG_UINT32 *pui32NumFormats,
+ DISPLAY_FORMAT *psFormat)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ if(!hDevice || !pui32NumFormats)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+ *pui32NumFormats = 1;
+
+ if(psFormat)
+ {
+ psFormat[0] = psDevInfo->sDisplayFormat;
+ }
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR EnumDCDims(IMG_HANDLE hDevice,
+ DISPLAY_FORMAT *psFormat,
+ IMG_UINT32 *pui32NumDims,
+ DISPLAY_DIMS *psDim)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ if(!hDevice || !psFormat || !pui32NumDims)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+ *pui32NumDims = 1;
+
+
+ if(psDim)
+ {
+ psDim[0] = psDevInfo->sDisplayDim;
+ }
+
+ return (PVRSRV_OK);
+}
+
+
+static PVRSRV_ERROR GetDCSystemBuffer(IMG_HANDLE hDevice, IMG_HANDLE *phBuffer)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ if(!hDevice || !phBuffer)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+ *phBuffer = (IMG_HANDLE)&psDevInfo->sSystemBuffer;
+
+ return (PVRSRV_OK);
+}
+
+
+static PVRSRV_ERROR GetDCInfo(IMG_HANDLE hDevice, DISPLAY_INFO *psDCInfo)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ if(!hDevice || !psDCInfo)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+ *psDCInfo = psDevInfo->sDisplayInfo;
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR GetDCBufferAddr(IMG_HANDLE hDevice,
+ IMG_HANDLE hBuffer,
+ IMG_SYS_PHYADDR **ppsSysAddr,
+ IMG_UINT32 *pui32ByteSize,
+ IMG_VOID **ppvCpuVAddr,
+ IMG_HANDLE *phOSMapInfo,
+ IMG_BOOL *pbIsContiguous,
+ IMG_UINT32 *pui32TilingStride)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_BUFFER *psSystemBuffer;
+
+ UNREFERENCED_PARAMETER(pui32TilingStride);
+
+ if(!hDevice)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+ if(!hBuffer)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+ psSystemBuffer = (OMAPLFB_BUFFER *)hBuffer;
+
+ if (!ppsSysAddr)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ *ppsSysAddr = &psSystemBuffer->sSysAddr;
+
+ if (!pui32ByteSize)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ *pui32ByteSize = (IMG_UINT32)psDevInfo->sFBInfo.ulBufferSize;
+
+ if (ppvCpuVAddr)
+ {
+ *ppvCpuVAddr = psSystemBuffer->sCPUVAddr;
+ }
+
+ if (phOSMapInfo)
+ {
+ *phOSMapInfo = (IMG_HANDLE)0;
+ }
+
+ if (pbIsContiguous)
+ {
+ *pbIsContiguous = IMG_TRUE;
+ }
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR CreateDCSwapChain(IMG_HANDLE hDevice,
+ IMG_UINT32 ui32Flags,
+ DISPLAY_SURF_ATTRIBUTES *psDstSurfAttrib,
+ DISPLAY_SURF_ATTRIBUTES *psSrcSurfAttrib,
+ IMG_UINT32 ui32BufferCount,
+ PVRSRV_SYNC_DATA **ppsSyncData,
+ IMG_UINT32 ui32OEMFlags,
+ IMG_HANDLE *phSwapChain,
+ IMG_UINT32 *pui32SwapChainID)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+ OMAPLFB_BUFFER *psBuffer;
+ OMAPLFB_VSYNC_FLIP_ITEM *psVSyncFlips;
+ IMG_UINT32 i;
+ PVRSRV_ERROR eError = PVRSRV_ERROR_NOT_SUPPORTED;
+ unsigned long ulLockFlags;
+ IMG_UINT32 ui32BuffersToSkip;
+
+ UNREFERENCED_PARAMETER(ui32OEMFlags);
+ UNREFERENCED_PARAMETER(pui32SwapChainID);
+
+
+ if(!hDevice
+ || !psDstSurfAttrib
+ || !psSrcSurfAttrib
+ || !ppsSyncData
+ || !phSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+
+ if (psDevInfo->sDisplayInfo.ui32MaxSwapChains == 0)
+ {
+ return (PVRSRV_ERROR_NOT_SUPPORTED);
+ }
+
+
+ if(psDevInfo->psSwapChain != NULL)
+ {
+ return (PVRSRV_ERROR_FLIP_CHAIN_EXISTS);
+ }
+
+
+ if(ui32BufferCount > psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers)
+ {
+ return (PVRSRV_ERROR_TOOMANYBUFFERS);
+ }
+
+ if ((psDevInfo->sFBInfo.ulRoundedBufferSize * (unsigned long)ui32BufferCount) > psDevInfo->sFBInfo.ulFBSize)
+ {
+ return (PVRSRV_ERROR_TOOMANYBUFFERS);
+ }
+
+
+ ui32BuffersToSkip = psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers - ui32BufferCount;
+
+
+ if(psDstSurfAttrib->pixelformat != psDevInfo->sDisplayFormat.pixelformat
+ || psDstSurfAttrib->sDims.ui32ByteStride != psDevInfo->sDisplayDim.ui32ByteStride
+ || psDstSurfAttrib->sDims.ui32Width != psDevInfo->sDisplayDim.ui32Width
+ || psDstSurfAttrib->sDims.ui32Height != psDevInfo->sDisplayDim.ui32Height)
+ {
+
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ if(psDstSurfAttrib->pixelformat != psSrcSurfAttrib->pixelformat
+ || psDstSurfAttrib->sDims.ui32ByteStride != psSrcSurfAttrib->sDims.ui32ByteStride
+ || psDstSurfAttrib->sDims.ui32Width != psSrcSurfAttrib->sDims.ui32Width
+ || psDstSurfAttrib->sDims.ui32Height != psSrcSurfAttrib->sDims.ui32Height)
+ {
+
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+
+ UNREFERENCED_PARAMETER(ui32Flags);
+
+
+ psSwapChain = (OMAPLFB_SWAPCHAIN*)OMAPLFBAllocKernelMem(sizeof(OMAPLFB_SWAPCHAIN));
+ if(!psSwapChain)
+ {
+ return (PVRSRV_ERROR_OUT_OF_MEMORY);
+ }
+
+ psBuffer = (OMAPLFB_BUFFER*)OMAPLFBAllocKernelMem(sizeof(OMAPLFB_BUFFER) * ui32BufferCount);
+ if(!psBuffer)
+ {
+ eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto ErrorFreeSwapChain;
+ }
+
+ psVSyncFlips = (OMAPLFB_VSYNC_FLIP_ITEM *)OMAPLFBAllocKernelMem(sizeof(OMAPLFB_VSYNC_FLIP_ITEM) * ui32BufferCount);
+ if (!psVSyncFlips)
+ {
+ eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto ErrorFreeBuffers;
+ }
+
+ psSwapChain->ulBufferCount = (unsigned long)ui32BufferCount;
+ psSwapChain->psBuffer = psBuffer;
+ psSwapChain->psVSyncFlips = psVSyncFlips;
+ psSwapChain->ulInsertIndex = 0;
+ psSwapChain->ulRemoveIndex = 0;
+ psSwapChain->psPVRJTable = &psDevInfo->sPVRJTable;
+ psSwapChain->psSwapChainLock = &psDevInfo->sSwapChainLock;
+
+
+ for(i=0; i<ui32BufferCount-1; i++)
+ {
+ psBuffer[i].psNext = &psBuffer[i+1];
+ }
+
+ psBuffer[i].psNext = &psBuffer[0];
+
+
+ for(i=0; i<ui32BufferCount; i++)
+ {
+ IMG_UINT32 ui32SwapBuffer = i + ui32BuffersToSkip;
+ IMG_UINT32 ui32BufferOffset = ui32SwapBuffer * (IMG_UINT32)psDevInfo->sFBInfo.ulRoundedBufferSize;
+
+ psBuffer[i].psSyncData = ppsSyncData[i];
+
+ psBuffer[i].sSysAddr.uiAddr = psDevInfo->sFBInfo.sSysAddr.uiAddr + ui32BufferOffset;
+ psBuffer[i].sCPUVAddr = psDevInfo->sFBInfo.sCPUVAddr + ui32BufferOffset;
+ }
+
+
+ for(i=0; i<ui32BufferCount; i++)
+ {
+ psVSyncFlips[i].bValid = OMAP_FALSE;
+ psVSyncFlips[i].bFlipped = OMAP_FALSE;
+ psVSyncFlips[i].bCmdCompleted = OMAP_FALSE;
+ }
+
+#if defined (SUPPORT_TI_DSS_FW)
+ OMAPLFBEnableDisplayRegisterAccess();
+
+
+ psSwapChain->pvRegs = ioremap(psDevInfo->psLINFBInfo->fix.mmio_start, psDevInfo->psLINFBInfo->fix.mmio_len);
+ if (psSwapChain->pvRegs == NULL)
+ {
+ eError = PVRSRV_ERROR_BAD_MAPPING;
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't map registers needed for flipping\n");
+ goto ErrorDisableDisplayRegisters;
+ }
+#endif
+ if (OMAPLFBInstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ eError = PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
+ printk(KERN_WARNING DRIVER_PREFIX ": ISR handler failed to register\n");
+ goto ErrorUnmapRegisters;
+ }
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
+ psDevInfo->psSwapChain = psSwapChain;
+
+
+ psSwapChain->bFlushCommands = psDevInfo->bFlushCommands;
+
+ if (psSwapChain->bFlushCommands)
+ {
+ psSwapChain->ulSetFlushStateRefCount = 1;
+ }
+ else
+ {
+ psSwapChain->ulSetFlushStateRefCount = 0;
+ OMAPLFBEnableVSyncInterrupt(psSwapChain);
+ }
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ if (EnableLFBEventNotification(psDevInfo)!= OMAP_OK)
+ {
+ eError = PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT;
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't enable framebuffer event notification\n");
+ goto ErrorUninstallVSyncInterrupt;
+ }
+
+
+ *phSwapChain = (IMG_HANDLE)psSwapChain;
+
+ return (PVRSRV_OK);
+
+ErrorUninstallVSyncInterrupt:
+ if(OMAPLFBUninstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't uninstall VSync ISR\n");
+ }
+ErrorUnmapRegisters:
+#if defined (SUPPORT_TI_DSS_FW)
+ iounmap(psSwapChain->pvRegs);
+ErrorDisableDisplayRegisters:
+ OMAPLFBDisableDisplayRegisterAccess();
+#endif
+ OMAPLFBFreeKernelMem(psVSyncFlips);
+ErrorFreeBuffers:
+ OMAPLFBFreeKernelMem(psBuffer);
+ErrorFreeSwapChain:
+ OMAPLFBFreeKernelMem(psSwapChain);
+
+ return eError;
+}
+
+static PVRSRV_ERROR DestroyDCSwapChain(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+ unsigned long ulLockFlags;
+ OMAP_ERROR eError;
+
+ if(!hDevice || !hSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+ psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+ if (psSwapChain != psDevInfo->psSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ eError = DisableLFBEventNotification(psDevInfo);
+ if (eError != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't disable framebuffer event notification\n");
+ }
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
+
+ FlushInternalVSyncQueue(psSwapChain);
+
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
+
+
+ psDevInfo->psSwapChain = NULL;
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ if(OMAPLFBUninstallVSyncISR(psSwapChain) != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Couldn't uninstall VSync ISR\n");
+ return (PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR);
+ }
+
+#if defined (SUPPORT_TI_DSS_FW)
+ iounmap(psSwapChain->pvRegs);
+
+ OMAPLFBDisableDisplayRegisterAccess();
+#endif
+
+ OMAPLFBFreeKernelMem(psSwapChain->psVSyncFlips);
+ OMAPLFBFreeKernelMem(psSwapChain->psBuffer);
+ OMAPLFBFreeKernelMem(psSwapChain);
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR SetDCDstRect(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain,
+ IMG_RECT *psRect)
+{
+ UNREFERENCED_PARAMETER(hDevice);
+ UNREFERENCED_PARAMETER(hSwapChain);
+ UNREFERENCED_PARAMETER(psRect);
+
+
+
+ return (PVRSRV_ERROR_NOT_SUPPORTED);
+}
+
+static PVRSRV_ERROR SetDCSrcRect(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain,
+ IMG_RECT *psRect)
+{
+ UNREFERENCED_PARAMETER(hDevice);
+ UNREFERENCED_PARAMETER(hSwapChain);
+ UNREFERENCED_PARAMETER(psRect);
+
+
+
+ return (PVRSRV_ERROR_NOT_SUPPORTED);
+}
+
+static PVRSRV_ERROR SetDCDstColourKey(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain,
+ IMG_UINT32 ui32CKColour)
+{
+ UNREFERENCED_PARAMETER(hDevice);
+ UNREFERENCED_PARAMETER(hSwapChain);
+ UNREFERENCED_PARAMETER(ui32CKColour);
+
+
+
+ return (PVRSRV_ERROR_NOT_SUPPORTED);
+}
+
+static PVRSRV_ERROR SetDCSrcColourKey(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain,
+ IMG_UINT32 ui32CKColour)
+{
+ UNREFERENCED_PARAMETER(hDevice);
+ UNREFERENCED_PARAMETER(hSwapChain);
+ UNREFERENCED_PARAMETER(ui32CKColour);
+
+
+
+ return (PVRSRV_ERROR_NOT_SUPPORTED);
+}
+
+static PVRSRV_ERROR GetDCBuffers(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain,
+ IMG_UINT32 *pui32BufferCount,
+ IMG_HANDLE *phBuffer)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+ unsigned long i;
+
+
+ if(!hDevice
+ || !hSwapChain
+ || !pui32BufferCount
+ || !phBuffer)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+ psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+ if (psSwapChain != psDevInfo->psSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+
+ *pui32BufferCount = (IMG_UINT32)psSwapChain->ulBufferCount;
+
+
+ for(i=0; i<psSwapChain->ulBufferCount; i++)
+ {
+ phBuffer[i] = (IMG_HANDLE)&psSwapChain->psBuffer[i];
+ }
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR SwapToDCBuffer(IMG_HANDLE hDevice,
+ IMG_HANDLE hBuffer,
+ IMG_UINT32 ui32SwapInterval,
+ IMG_HANDLE hPrivateTag,
+ IMG_UINT32 ui32ClipRectCount,
+ IMG_RECT *psClipRect)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ UNREFERENCED_PARAMETER(ui32SwapInterval);
+ UNREFERENCED_PARAMETER(hPrivateTag);
+ UNREFERENCED_PARAMETER(psClipRect);
+
+ if(!hDevice
+ || !hBuffer
+ || (ui32ClipRectCount != 0))
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+
+
+ return (PVRSRV_OK);
+}
+
+static PVRSRV_ERROR SwapToDCSystem(IMG_HANDLE hDevice,
+ IMG_HANDLE hSwapChain)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+ unsigned long ulLockFlags;
+
+ if(!hDevice || !hSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+ psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+ if (psSwapChain != psDevInfo->psSwapChain)
+ {
+ return (PVRSRV_ERROR_INVALID_PARAMS);
+ }
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
+ FlushInternalVSyncQueue(psSwapChain);
+
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ return (PVRSRV_OK);
+}
+
+OMAP_BOOL OMAPLFBVSyncIHandler(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ OMAP_BOOL bStatus = OMAP_FALSE;
+ OMAPLFB_VSYNC_FLIP_ITEM *psFlipItem;
+ unsigned long ulMaxIndex;
+ unsigned long ulLockFlags;
+
+ psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
+ ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+ spin_lock_irqsave(psSwapChain->psSwapChainLock, ulLockFlags);
+
+
+ if (psSwapChain->bFlushCommands)
+ {
+ goto ExitUnlock;
+ }
+
+ while(psFlipItem->bValid)
+ {
+
+ if(psFlipItem->bFlipped)
+ {
+
+ if(!psFlipItem->bCmdCompleted)
+ {
+
+ psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete((IMG_HANDLE)psFlipItem->hCmdComplete, IMG_TRUE);
+
+
+ psFlipItem->bCmdCompleted = OMAP_TRUE;
+ }
+
+
+ psFlipItem->ulSwapInterval--;
+
+
+ if(psFlipItem->ulSwapInterval == 0)
+ {
+
+ psSwapChain->ulRemoveIndex++;
+
+ if(psSwapChain->ulRemoveIndex > ulMaxIndex)
+ {
+ psSwapChain->ulRemoveIndex = 0;
+ }
+
+
+ psFlipItem->bCmdCompleted = OMAP_FALSE;
+ psFlipItem->bFlipped = OMAP_FALSE;
+
+
+ psFlipItem->bValid = OMAP_FALSE;
+ }
+ else
+ {
+
+ break;
+ }
+ }
+ else
+ {
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psFlipItem->sSysAddr);
+
+
+ psFlipItem->bFlipped = OMAP_TRUE;
+
+
+ break;
+ }
+
+
+ psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulRemoveIndex];
+ }
+
+ExitUnlock:
+ spin_unlock_irqrestore(psSwapChain->psSwapChainLock, ulLockFlags);
+
+ return bStatus;
+}
+
+static IMG_BOOL ProcessFlip(IMG_HANDLE hCmdCookie,
+ IMG_UINT32 ui32DataSize,
+ IMG_VOID *pvData)
+{
+ DISPLAYCLASS_FLIP_COMMAND *psFlipCmd;
+ OMAPLFB_DEVINFO *psDevInfo;
+ OMAPLFB_BUFFER *psBuffer;
+ OMAPLFB_SWAPCHAIN *psSwapChain;
+#if defined(SYS_USING_INTERRUPTS)
+ OMAPLFB_VSYNC_FLIP_ITEM* psFlipItem;
+#endif
+ unsigned long ulLockFlags;
+
+
+ if(!hCmdCookie || !pvData)
+ {
+ return IMG_FALSE;
+ }
+
+
+ psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)pvData;
+
+ if (psFlipCmd == IMG_NULL || sizeof(DISPLAYCLASS_FLIP_COMMAND) != ui32DataSize)
+ {
+ return IMG_FALSE;
+ }
+
+
+ psDevInfo = (OMAPLFB_DEVINFO*)psFlipCmd->hExtDevice;
+
+ psBuffer = (OMAPLFB_BUFFER*)psFlipCmd->hExtBuffer;
+ psSwapChain = (OMAPLFB_SWAPCHAIN*) psFlipCmd->hExtSwapChain;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
+ if (psDevInfo->bDeviceSuspended)
+ {
+ psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(hCmdCookie, IMG_TRUE);
+ goto ExitTrueUnlock;
+ }
+
+#if defined(SYS_USING_INTERRUPTS)
+
+ if(psFlipCmd->ui32SwapInterval == 0 || psSwapChain->bFlushCommands == OMAP_TRUE)
+ {
+#endif
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psBuffer->sSysAddr.uiAddr);
+
+
+ psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(hCmdCookie, IMG_TRUE);
+
+#if defined(SYS_USING_INTERRUPTS)
+ goto ExitTrueUnlock;
+ }
+
+ psFlipItem = &psSwapChain->psVSyncFlips[psSwapChain->ulInsertIndex];
+
+
+ if(psFlipItem->bValid == OMAP_FALSE)
+ {
+ unsigned long ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+ if(psSwapChain->ulInsertIndex == psSwapChain->ulRemoveIndex)
+ {
+
+ OMAPLFBFlip(psSwapChain, (unsigned long)psBuffer->sSysAddr.uiAddr);
+
+ psFlipItem->bFlipped = OMAP_TRUE;
+ }
+ else
+ {
+ psFlipItem->bFlipped = OMAP_FALSE;
+ }
+
+ psFlipItem->hCmdComplete = (OMAP_HANDLE)hCmdCookie;
+ psFlipItem->ulSwapInterval = (unsigned long)psFlipCmd->ui32SwapInterval;
+ psFlipItem->sSysAddr = &psBuffer->sSysAddr;
+ psFlipItem->bValid = OMAP_TRUE;
+
+ psSwapChain->ulInsertIndex++;
+ if(psSwapChain->ulInsertIndex > ulMaxIndex)
+ {
+ psSwapChain->ulInsertIndex = 0;
+ }
+
+ goto ExitTrueUnlock;
+ }
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+ return IMG_FALSE;
+#endif
+
+ExitTrueUnlock:
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+ return IMG_TRUE;
+}
+
+
+static OMAP_ERROR InitDev(OMAPLFB_DEVINFO *psDevInfo)
+{
+ struct fb_info *psLINFBInfo;
+ struct module *psLINFBOwner;
+ OMAPLFB_FBINFO *psPVRFBInfo = &psDevInfo->sFBInfo;
+ OMAP_ERROR eError = OMAP_ERROR_GENERIC;
+ unsigned long FBSize;
+
+ acquire_console_sem();
+
+ if (fb_idx < 0 || fb_idx >= num_registered_fb)
+ {
+ eError = OMAP_ERROR_INVALID_DEVICE;
+ goto errRelSem;
+ }
+
+ psLINFBInfo = registered_fb[fb_idx];
+
+ psLINFBOwner = psLINFBInfo->fbops->owner;
+ if (!try_module_get(psLINFBOwner))
+ {
+ printk(KERN_INFO DRIVER_PREFIX
+ ": Couldn't get framebuffer module\n");
+
+ goto errRelSem;
+ }
+
+ if (psLINFBInfo->fbops->fb_open != NULL)
+ {
+ int res;
+
+ res = psLINFBInfo->fbops->fb_open(psLINFBInfo, 0);
+ if (res != 0)
+ {
+ printk(KERN_INFO DRIVER_PREFIX
+ ": Couldn't open framebuffer: %d\n", res);
+
+ goto errModPut;
+ }
+ }
+
+ psDevInfo->psLINFBInfo = psLINFBInfo;
+
+ FBSize = (psLINFBInfo->screen_size) != 0 ?
+ psLINFBInfo->screen_size :
+ psLINFBInfo->fix.smem_len;
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer physical address: 0x%lx\n",
+ psLINFBInfo->fix.smem_start));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer virtual address: 0x%lx\n",
+ (unsigned long)psLINFBInfo->screen_base));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer size: %lu\n",
+ FBSize));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer virtual width: %u\n",
+ psLINFBInfo->var.xres_virtual));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer virtual height: %u\n",
+ psLINFBInfo->var.yres_virtual));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer width: %u\n",
+ psLINFBInfo->var.xres));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer height: %u\n",
+ psLINFBInfo->var.yres));
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Framebuffer stride: %u\n",
+ psLINFBInfo->fix.line_length));
+
+
+ psPVRFBInfo->sSysAddr.uiAddr = psLINFBInfo->fix.smem_start;
+ psPVRFBInfo->sCPUVAddr = psLINFBInfo->screen_base;
+
+ psPVRFBInfo->ulWidth = psLINFBInfo->var.xres;
+ psPVRFBInfo->ulHeight = psLINFBInfo->var.yres;
+ psPVRFBInfo->ulByteStride = psLINFBInfo->fix.line_length;
+ psPVRFBInfo->ulFBSize = FBSize;
+ psPVRFBInfo->ulBufferSize = psPVRFBInfo->ulHeight * psPVRFBInfo->ulByteStride;
+
+#ifdef CONFIG_OMAP2_DSS
+ psPVRFBInfo->ulRoundedBufferSize = psPVRFBInfo->ulBufferSize;
+#else
+
+ psPVRFBInfo->ulRoundedBufferSize = OMAPLFB_PAGE_ROUNDUP(psPVRFBInfo->ulBufferSize);
+#endif
+ if(psLINFBInfo->var.bits_per_pixel == 16)
+ {
+ if((psLINFBInfo->var.red.length == 5) &&
+ (psLINFBInfo->var.green.length == 6) &&
+ (psLINFBInfo->var.blue.length == 5) &&
+ (psLINFBInfo->var.red.offset == 11) &&
+ (psLINFBInfo->var.green.offset == 5) &&
+ (psLINFBInfo->var.blue.offset == 0) &&
+ (psLINFBInfo->var.red.msb_right == 0))
+ {
+ psPVRFBInfo->ePixelFormat = PVRSRV_PIXEL_FORMAT_RGB565;
+ }
+ else
+ {
+ printk("Unknown FB format\n");
+ }
+ }
+ else if(psLINFBInfo->var.bits_per_pixel == 32)
+ {
+ if((psLINFBInfo->var.red.length == 8) &&
+ (psLINFBInfo->var.green.length == 8) &&
+ (psLINFBInfo->var.blue.length == 8) &&
+ (psLINFBInfo->var.red.offset == 16) &&
+ (psLINFBInfo->var.green.offset == 8) &&
+ (psLINFBInfo->var.blue.offset == 0) &&
+ (psLINFBInfo->var.red.msb_right == 0))
+ {
+ psPVRFBInfo->ePixelFormat = PVRSRV_PIXEL_FORMAT_ARGB8888;
+ }
+ else
+ {
+ printk("Unknown FB format\n");
+ }
+ }
+ else
+ {
+ printk("Unknown FB format\n");
+ }
+
+ psDevInfo->sFBInfo.ulPhysicalWidthmm =
+ ((int)psLINFBInfo->var.width > 0) ? psLINFBInfo->var.width : 90;
+
+ psDevInfo->sFBInfo.ulPhysicalHeightmm =
+ ((int)psLINFBInfo->var.height > 0) ? psLINFBInfo->var.height : 54;
+
+
+ psDevInfo->sFBInfo.sSysAddr.uiAddr = psPVRFBInfo->sSysAddr.uiAddr;
+ psDevInfo->sFBInfo.sCPUVAddr = psPVRFBInfo->sCPUVAddr;
+#ifdef CONFIG_OMAP2_DSS
+ INIT_WORK (&wq_flipdss2.work, dss2_pan_display);
+#endif
+ eError = OMAP_OK;
+ goto errRelSem;
+
+errModPut:
+ module_put(psLINFBOwner);
+errRelSem:
+ release_console_sem();
+ return eError;
+}
+
+static void DeInitDev(OMAPLFB_DEVINFO *psDevInfo)
+{
+ struct fb_info *psLINFBInfo = psDevInfo->psLINFBInfo;
+ struct module *psLINFBOwner;
+
+ acquire_console_sem();
+
+ psLINFBOwner = psLINFBInfo->fbops->owner;
+
+ if (psLINFBInfo->fbops->fb_release != NULL)
+ {
+ (void) psLINFBInfo->fbops->fb_release(psLINFBInfo, 0);
+ }
+
+ module_put(psLINFBOwner);
+
+ release_console_sem();
+}
+
+OMAP_ERROR OMAPLFBInit(void)
+{
+ OMAPLFB_DEVINFO *psDevInfo;
+
+ psDevInfo = GetAnchorPtr();
+
+ if (psDevInfo == NULL)
+ {
+ PFN_CMD_PROC pfnCmdProcList[OMAPLFB_COMMAND_COUNT];
+ IMG_UINT32 aui32SyncCountList[OMAPLFB_COMMAND_COUNT][2];
+
+ psDevInfo = (OMAPLFB_DEVINFO *)OMAPLFBAllocKernelMem(sizeof(OMAPLFB_DEVINFO));
+
+ if(!psDevInfo)
+ {
+ return (OMAP_ERROR_OUT_OF_MEMORY);
+ }
+
+
+ memset(psDevInfo, 0, sizeof(OMAPLFB_DEVINFO));
+
+
+ SetAnchorPtr((void*)psDevInfo);
+
+
+ psDevInfo->ulRefCount = 0;
+
+#ifdef FBDEV_PRESENT
+ if(InitDev(psDevInfo) != OMAP_OK)
+ {
+ return (OMAP_ERROR_INIT_FAILURE);
+ }
+#endif
+ if(OMAPLFBGetLibFuncAddr ("PVRGetDisplayClassJTable", &pfnGetPVRJTable) != OMAP_OK)
+ {
+ return (OMAP_ERROR_INIT_FAILURE);
+ }
+
+
+ if(!(*pfnGetPVRJTable)(&psDevInfo->sPVRJTable))
+ {
+ return (OMAP_ERROR_INIT_FAILURE);
+ }
+
+
+ spin_lock_init(&psDevInfo->sSwapChainLock);
+
+ psDevInfo->psSwapChain = 0;
+ psDevInfo->bFlushCommands = OMAP_FALSE;
+ psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+#ifdef FBDEV_PRESENT
+ psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = (IMG_UINT32)(psDevInfo->sFBInfo.ulFBSize / psDevInfo->sFBInfo.ulRoundedBufferSize);
+#if !defined (SUPPORT_TI_DSS_FW)
+ /* DSS2 have trouble with ui32MaxSwapChainBuffers > 3 */
+ if (psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers > 3)
+ psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = 3;
+#endif
+#if 1
+ /* for fb_pan_display to work, yres_virtual should be set to number of buffers multiplied yres */
+ psDevInfo->psLINFBInfo->var.yres_virtual = psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers * psDevInfo->psLINFBInfo->var.yres;
+ if (fb_set_var(psDevInfo->psLINFBInfo, &psDevInfo->psLINFBInfo->var) != 0)
+ {
+ printk(KERN_INFO DRIVER_PREFIX ": Couldn't set framebuffer paramter: ");
+
+ }
+#endif
+
+
+ if (psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers == 0)
+ {
+ psDevInfo->sDisplayInfo.ui32MaxSwapChains = 0;
+ psDevInfo->sDisplayInfo.ui32MaxSwapInterval = 0;
+ }
+ else
+ {
+ psDevInfo->sDisplayInfo.ui32MaxSwapChains = 1;
+ psDevInfo->sDisplayInfo.ui32MaxSwapInterval = 3;
+ }
+ psDevInfo->sDisplayInfo.ui32MinSwapInterval = 0;
+
+ psDevInfo->sDisplayInfo.ui32PhysicalWidthmm = psDevInfo->sFBInfo.ulPhysicalWidthmm;
+ psDevInfo->sDisplayInfo.ui32PhysicalHeightmm = psDevInfo->sFBInfo.ulPhysicalHeightmm;
+
+ strncpy(psDevInfo->sDisplayInfo.szDisplayName, DISPLAY_DEVICE_NAME, MAX_DISPLAY_NAME_SIZE);
+
+ psDevInfo->sDisplayFormat.pixelformat = psDevInfo->sFBInfo.ePixelFormat;
+ psDevInfo->sDisplayDim.ui32Width = (IMG_UINT32)psDevInfo->sFBInfo.ulWidth;
+ psDevInfo->sDisplayDim.ui32Height = (IMG_UINT32)psDevInfo->sFBInfo.ulHeight;
+ psDevInfo->sDisplayDim.ui32ByteStride = (IMG_UINT32)psDevInfo->sFBInfo.ulByteStride;
+
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX
+ ": Maximum number of swap chain buffers: %u\n",
+ psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers));
+
+
+ psDevInfo->sSystemBuffer.sSysAddr = psDevInfo->sFBInfo.sSysAddr;
+ psDevInfo->sSystemBuffer.sCPUVAddr = psDevInfo->sFBInfo.sCPUVAddr;
+ psDevInfo->sSystemBuffer.ulBufferSize = psDevInfo->sFBInfo.ulRoundedBufferSize;
+
+#else
+ psDevInfo->sSystemBuffer.sCPUVAddr = 0x100;
+ psDevInfo->sSystemBuffer.ulBufferSize = 600*3200;
+
+ psDevInfo->sDisplayFormat.pixelformat = 20;
+ psDevInfo->sFBInfo.ulWidth = 800;
+ psDevInfo->sFBInfo.ulHeight = 600;
+ psDevInfo->sFBInfo.ulByteStride = 3200;
+ psDevInfo->sFBInfo.ulFBSize = 8388608;
+ psDevInfo->sFBInfo.ulBufferSize = 600*3200;
+
+#endif
+
+ psDevInfo->sDCJTable.ui32TableSize = sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE);
+ psDevInfo->sDCJTable.pfnOpenDCDevice = OpenDCDevice;
+ psDevInfo->sDCJTable.pfnCloseDCDevice = CloseDCDevice;
+ psDevInfo->sDCJTable.pfnEnumDCFormats = EnumDCFormats;
+ psDevInfo->sDCJTable.pfnEnumDCDims = EnumDCDims;
+ psDevInfo->sDCJTable.pfnGetDCSystemBuffer = GetDCSystemBuffer;
+ psDevInfo->sDCJTable.pfnGetDCInfo = GetDCInfo;
+ psDevInfo->sDCJTable.pfnGetBufferAddr = GetDCBufferAddr;
+ psDevInfo->sDCJTable.pfnCreateDCSwapChain = CreateDCSwapChain;
+ psDevInfo->sDCJTable.pfnDestroyDCSwapChain = DestroyDCSwapChain;
+ psDevInfo->sDCJTable.pfnSetDCDstRect = SetDCDstRect;
+ psDevInfo->sDCJTable.pfnSetDCSrcRect = SetDCSrcRect;
+ psDevInfo->sDCJTable.pfnSetDCDstColourKey = SetDCDstColourKey;
+ psDevInfo->sDCJTable.pfnSetDCSrcColourKey = SetDCSrcColourKey;
+ psDevInfo->sDCJTable.pfnGetDCBuffers = GetDCBuffers;
+ psDevInfo->sDCJTable.pfnSwapToDCBuffer = SwapToDCBuffer;
+ psDevInfo->sDCJTable.pfnSwapToDCSystem = SwapToDCSystem;
+ psDevInfo->sDCJTable.pfnSetDCState = SetDCState;
+
+
+ if(psDevInfo->sPVRJTable.pfnPVRSRVRegisterDCDevice (
+ &psDevInfo->sDCJTable,
+ &psDevInfo->uiDeviceID ) != PVRSRV_OK)
+ {
+ return (OMAP_ERROR_DEVICE_REGISTER_FAILED);
+ }
+
+
+ pfnCmdProcList[DC_FLIP_COMMAND] = ProcessFlip;
+
+
+ aui32SyncCountList[DC_FLIP_COMMAND][0] = 0;
+ aui32SyncCountList[DC_FLIP_COMMAND][1] = 2;
+
+
+
+
+
+ if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterCmdProcList (psDevInfo->uiDeviceID,
+ &pfnCmdProcList[0],
+ aui32SyncCountList,
+ OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": Can't register callback\n");
+ return (OMAP_ERROR_CANT_REGISTER_CALLBACK);
+ }
+
+ }
+
+
+ psDevInfo->ulRefCount++;
+
+
+ return (OMAP_OK);
+
+ }
+
+OMAP_ERROR OMAPLFBDeinit(void)
+{
+ OMAPLFB_DEVINFO *psDevInfo, *psDevFirst;
+
+ psDevFirst = GetAnchorPtr();
+ psDevInfo = psDevFirst;
+
+
+ if (psDevInfo == NULL)
+ {
+ return (OMAP_ERROR_GENERIC);
+ }
+
+
+ psDevInfo->ulRefCount--;
+
+ if (psDevInfo->ulRefCount == 0)
+ {
+
+ PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable = &psDevInfo->sPVRJTable;
+
+ if (psDevInfo->sPVRJTable.pfnPVRSRVRemoveCmdProcList (psDevInfo->uiDeviceID, OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
+ {
+ return (OMAP_ERROR_GENERIC);
+ }
+
+
+ if (psJTable->pfnPVRSRVRemoveDCDevice(psDevInfo->uiDeviceID) != PVRSRV_OK)
+ {
+ return (OMAP_ERROR_GENERIC);
+ }
+#ifdef FBDEV_PRESENT
+ DeInitDev(psDevInfo);
+#endif
+
+ OMAPLFBFreeKernelMem(psDevInfo);
+ }
+
+
+ SetAnchorPtr(NULL);
+
+
+ return (OMAP_OK);
+}
+
+
+#if defined(LDM_PLATFORM)
+void OMAPLFBDriverSuspend(void)
+{
+ OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr();
+ unsigned long ulLockFlags;
+
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+ if (psDevInfo->bDeviceSuspended)
+ {
+ goto ExitUnlock;
+ }
+ psDevInfo->bDeviceSuspended = OMAP_TRUE;
+
+
+ SetFlushStateInternalNoLock(psDevInfo, OMAP_TRUE);
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+#if defined (SUPPORT_TI_DSS_FW)
+ if (psDevInfo->psSwapChain != NULL)
+ {
+ OMAPLFBDisableDisplayRegisterAccess();
+ }
+#endif
+ return;
+
+ExitUnlock:
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+}
+
+void OMAPLFBDriverResume(void)
+{
+ OMAPLFB_DEVINFO *psDevInfo = GetAnchorPtr();
+ unsigned long ulLockFlags;
+
+ if (psDevInfo->bDeviceSuspended == OMAP_FALSE)
+ {
+ return;
+ }
+#if defined (SUPPORT_TI_DSS_FW)
+ if (psDevInfo->psSwapChain != NULL)
+ {
+ OMAPLFBEnableDisplayRegisterAccess();
+ }
+#endif
+ spin_lock_irqsave(&psDevInfo->sSwapChainLock, ulLockFlags);
+
+
+ SetFlushStateInternalNoLock(psDevInfo, OMAP_FALSE);
+
+ psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+ spin_unlock_irqrestore(&psDevInfo->sSwapChainLock, ulLockFlags);
+}
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef AUTOCONF_INCLUDED
+#include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+#include <linux/module.h>
+
+#include <linux/pci.h>
+#include <asm/uaccess.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+
+#include <plat/ti81xx-vpss.h>
+
+#if defined(LDM_PLATFORM)
+#include <linux/platform_device.h>
+#endif
+
+#if defined (SUPPORT_TI_DSS_FW)
+#include <asm/io.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
+#include <plat/display.h>
+#else
+#include <mach/display.h>
+#endif
+#else
+#include <asm/arch-omap/display.h>
+#endif
+
+#else
+#if !defined (CONFIG_OMAP2_DSS)
+#define DISPC_IRQ_VSYNC 0x0002
+extern int omap_dispc_request_irq(unsigned long, void (*)(void *), void *);
+extern void omap_dispc_free_irq(unsigned long, void (*)(void *), void *);
+extern void omap_dispc_set_plane_base(int plane, IMG_UINT32 phys_addr);
+#else
+#include <plat/display.h>
+#include <linux/console.h>
+#include <linux/fb.h>
+static omap_dispc_isr_t *pOMAPLFBVSyncISRHandle = NULL;
+#endif
+#endif
+
+
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omaplfb.h"
+#include "pvrmodule.h"
+
+MODULE_SUPPORTED_DEVICE(DEVNAME);
+
+#define unref__ __attribute__ ((unused))
+
+void *OMAPLFBAllocKernelMem(unsigned long ulSize)
+{
+ return kmalloc(ulSize, GFP_KERNEL);
+}
+
+void OMAPLFBFreeKernelMem(void *pvMem)
+{
+ kfree(pvMem);
+}
+
+
+OMAP_ERROR OMAPLFBGetLibFuncAddr (char *szFunctionName, PFN_DC_GET_PVRJTABLE *ppfnFuncTable)
+{
+ if(strcmp("PVRGetDisplayClassJTable", szFunctionName) != 0)
+ {
+ return (OMAP_ERROR_INVALID_PARAMS);
+ }
+
+
+ *ppfnFuncTable = PVRGetDisplayClassJTable;
+
+ return (OMAP_OK);
+}
+
+
+#if defined(SYS_USING_INTERRUPTS)
+
+#if defined(SUPPORT_OMAP3430_OMAPFB3)
+
+static void OMAPLFBVSyncISR(void *arg, u32 mask)
+{
+ OMAPLFB_SWAPCHAIN *psSwapChain= (OMAPLFB_SWAPCHAIN *)arg;
+ (void) OMAPLFBVSyncIHandler(psSwapChain);
+ // printk (" VSync ISR \n");
+}
+
+static inline int OMAPLFBRegisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ return omap_dispc_register_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQ_VSYNC);
+}
+
+static inline int OMAPLFBUnregisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ return omap_dispc_unregister_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQ_VSYNC);
+}
+
+#else
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+static void OMAPLFBVSyncISR(void *arg)
+#else
+static void OMAPLFBVSyncISR(void *arg, struct pt_regs unref__ *regs)
+#endif
+{
+ OMAPLFB_SWAPCHAIN *psSwapChain= (OMAPLFB_SWAPCHAIN *)arg;
+ (void) OMAPLFBVSyncIHandler(psSwapChain);
+}
+
+static inline int OMAPLFBRegisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+ return omap_dispc_request_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+#else
+ return omap2_disp_register_isr(OMAPLFBVSyncISR, psSwapChain,
+ DISPC_IRQSTATUS_VSYNC);
+#endif
+}
+
+static inline int OMAPLFBUnregisterVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+ omap_dispc_free_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+ return 0;
+#else
+ return omap2_disp_unregister_isr(OMAPLFBVSyncISR);
+#endif
+}
+
+#endif
+
+#endif
+
+#if !defined (SUPPORT_TI_DSS_FW)
+
+IMG_VOID OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ if (pOMAPLFBVSyncISRHandle == NULL)
+ OMAPLFBInstallVSyncISR (psSwapChain);
+}
+
+IMG_VOID OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+ if (pOMAPLFBVSyncISRHandle != NULL)
+ OMAPLFBUninstallVSyncISR (psSwapChain);
+}
+#else
+
+static void OMAPLFBVSyncWriteReg(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long ulOffset, unsigned long ulValue)
+{
+ void *pvRegAddr = (void *)((char *)psSwapChain->pvRegs + ulOffset);
+
+
+ writel(ulValue, pvRegAddr);
+}
+
+static unsigned long OMAPLFBVSyncReadReg(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long ulOffset)
+{
+ return readl((char *)psSwapChain->pvRegs + ulOffset);
+}
+
+void OMAPLFBEnableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+
+ unsigned long ulInterruptEnable = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_IRQENABLE);
+ ulInterruptEnable |= OMAPLCD_INTMASK_VSYNC;
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_IRQENABLE, ulInterruptEnable );
+#endif
+}
+
+void OMAPLFBDisableVSyncInterrupt(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+
+ unsigned long ulInterruptEnable = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_IRQENABLE);
+ ulInterruptEnable &= ~(OMAPLCD_INTMASK_VSYNC);
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_IRQENABLE, ulInterruptEnable);
+#endif
+}
+#endif
+
+#if !defined (SUPPORT_TI_DSS_FW)
+OMAP_ERROR OMAPLFBInstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ if (omap_dispc_request_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain) != 0)
+#else
+ int ret;
+#ifdef FBDEV_PRESENT
+ ret = vps_grpx_register_isr ((vsync_callback_t)OMAPLFBVSyncISR, psSwapChain, 0); // fb_idx = 0
+#endif
+// if (ret == 0)
+ pOMAPLFBVSyncISRHandle = (omap_dispc_isr_t *)NULL;
+ // else
+ // pOMAPLFBVSyncISRHandle = NULL;
+
+ if (pOMAPLFBVSyncISRHandle != NULL)
+#endif
+ return PVRSRV_ERROR_OUT_OF_MEMORY; /* not worth a proper mapping */
+ return OMAP_OK;
+}
+
+
+OMAP_ERROR OMAPLFBUninstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ omap_dispc_free_irq(DISPC_IRQ_VSYNC, OMAPLFBVSyncISR, psSwapChain);
+#else
+ int ret;
+#ifdef FBDEV_PRESENT
+ ret = vps_grpx_unregister_isr((vsync_callback_t) OMAPLFBVSyncISR, (void *)psSwapChain, 0); // fb_idx = 0
+#endif
+#endif
+ return OMAP_OK;
+}
+
+
+IMG_VOID OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain,
+ IMG_UINT32 aPhyAddr)
+{
+#if !defined (CONFIG_OMAP2_DSS)
+ omap_dispc_set_plane_base(0, aPhyAddr);
+#else
+ OMAPLFBFlipDSS2 (psSwapChain, aPhyAddr);
+#endif
+}
+#else
+
+OMAP_ERROR OMAPLFBInstallVSyncISR(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
+ if (OMAPLFBRegisterVSyncISR(psSwapChain))
+ {
+ printk(KERN_INFO DRIVER_PREFIX ": OMAPLFBInstallVSyncISR: Request OMAPLCD IRQ failed\n");
+ return (OMAP_ERROR_INIT_FAILURE);
+ }
+
+#endif
+ return (OMAP_OK);
+}
+
+
+OMAP_ERROR OMAPLFBUninstallVSyncISR (OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#if defined(SYS_USING_INTERRUPTS)
+ OMAPLFBDisableVSyncInterrupt(psSwapChain);
+
+ OMAPLFBUnregisterVSyncISR(psSwapChain);
+
+#endif
+ return (OMAP_OK);
+}
+
+void OMAPLFBEnableDisplayRegisterAccess(void)
+{
+#if !defined(SUPPORT_OMAP3430_OMAPFB3)
+ omap2_disp_get_dss();
+#endif
+}
+
+void OMAPLFBDisableDisplayRegisterAccess(void)
+{
+#if !defined(SUPPORT_OMAP3430_OMAPFB3)
+ omap2_disp_put_dss();
+#endif
+}
+
+
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr)
+{
+ unsigned long control;
+
+
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_GFX_BA0, aPhyAddr);
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_GFX_BA1, aPhyAddr);
+
+ control = OMAPLFBVSyncReadReg(psSwapChain, OMAPLCD_CONTROL);
+ control |= OMAP_CONTROL_GOLCD;
+ OMAPLFBVSyncWriteReg(psSwapChain, OMAPLCD_CONTROL, control);
+}
+#endif
+
+#if defined(LDM_PLATFORM)
+
+static OMAP_BOOL bDeviceSuspended;
+
+static void OMAPLFBCommonSuspend(void)
+{
+ if (bDeviceSuspended)
+ {
+ return;
+ }
+
+ OMAPLFBDriverSuspend();
+
+ bDeviceSuspended = OMAP_TRUE;
+}
+
+static int OMAPLFBDriverSuspend_Entry(struct platform_device unref__ *pDevice, pm_message_t unref__ state)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverSuspend_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+
+ return 0;
+}
+
+static int OMAPLFBDriverResume_Entry(struct platform_device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverResume_Entry\n"));
+
+ OMAPLFBDriverResume();
+
+ bDeviceSuspended = OMAP_FALSE;
+
+ return 0;
+}
+
+static IMG_VOID OMAPLFBDriverShutdown_Entry(struct platform_device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverShutdown_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+}
+
+static struct platform_driver omaplfb_driver = {
+ .driver = {
+ .name = DRVNAME,
+ },
+ .suspend = OMAPLFBDriverSuspend_Entry,
+ .resume = OMAPLFBDriverResume_Entry,
+ .shutdown = OMAPLFBDriverShutdown_Entry,
+};
+
+#if defined(MODULE)
+
+static void OMAPLFBDeviceRelease_Entry(struct device unref__ *pDevice)
+{
+ DEBUG_PRINTK((KERN_INFO DRIVER_PREFIX ": OMAPLFBDriverRelease_Entry\n"));
+
+ OMAPLFBCommonSuspend();
+}
+
+static struct platform_device omaplfb_device = {
+ .name = DEVNAME,
+ .id = -1,
+ .dev = {
+ .release = OMAPLFBDeviceRelease_Entry
+ }
+};
+
+#endif
+
+#endif
+
+static int __init OMAPLFB_Init(void)
+{
+#if defined(LDM_PLATFORM)
+ int error;
+#endif
+
+ if(OMAPLFBInit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBInit failed\n");
+ return -ENODEV;
+ }
+
+#if defined(LDM_PLATFORM)
+ if ((error = platform_driver_register(&omaplfb_driver)) != 0)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform driver (%d)\n", error);
+
+ goto ExitDeinit;
+ }
+
+#if defined(MODULE)
+ if ((error = platform_device_register(&omaplfb_device)) != 0)
+ {
+ platform_driver_unregister(&omaplfb_driver);
+
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: Unable to register platform device (%d)\n", error);
+
+ goto ExitDeinit;
+ }
+#endif
+
+#endif
+
+ return 0;
+
+#if defined(LDM_PLATFORM)
+ExitDeinit:
+ if(OMAPLFBDeinit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Init: OMAPLFBDeinit failed\n");
+ }
+
+ return -ENODEV;
+#endif
+}
+
+static IMG_VOID __exit OMAPLFB_Cleanup(IMG_VOID)
+{
+#if defined (LDM_PLATFORM)
+#if defined (MODULE)
+ platform_device_unregister(&omaplfb_device);
+#endif
+ platform_driver_unregister(&omaplfb_driver);
+#endif
+
+ if(OMAPLFBDeinit() != OMAP_OK)
+ {
+ printk(KERN_WARNING DRIVER_PREFIX ": OMAPLFB_Cleanup: OMAPLFBDeinit failed\n");
+ }
+}
+
+module_init(OMAPLFB_Init);
+module_exit(OMAPLFB_Cleanup);
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__PVR_DRM_SHARED_H__)
+#define __PVR_DRM_SHARED_H__
+
+#if defined(SUPPORT_DRI_DRM)
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+#define PVR_DRM_SRVKM_CMD DRM_PVR_RESERVED1
+#define PVR_DRM_DISP_CMD DRM_PVR_RESERVED2
+#define PVR_DRM_BC_CMD DRM_PVR_RESERVED3
+#define PVR_DRM_IS_MASTER_CMD DRM_PVR_RESERVED4
+#define PVR_DRM_UNPRIV_CMD DRM_PVR_RESERVED5
+#define PVR_DRM_DBGDRV_CMD DRM_PVR_RESERVED6
+#else
+#define PVR_DRM_SRVKM_CMD 0
+#define PVR_DRM_DISP_CMD 1
+#define PVR_DRM_BC_CMD 2
+#define PVR_DRM_IS_MASTER_CMD 3
+#define PVR_DRM_UNPRIV_CMD 4
+#define PVR_DRM_DBGDRV_CMD 5
+#endif
+
+#define PVR_DRM_UNPRIV_INIT_SUCCESFUL 0
+
+#endif
+
+#endif
+
+
#if !defined (__KERNELBUFFER_H__)
#define __KERNELBUFFER_H__
-typedef PVRSRV_ERROR (*PFN_OPEN_BC_DEVICE)(IMG_HANDLE*);
-typedef PVRSRV_ERROR (*PFN_CLOSE_BC_DEVICE)(IMG_HANDLE);
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef PVRSRV_ERROR (*PFN_OPEN_BC_DEVICE)(IMG_UINT32, IMG_HANDLE*);
+typedef PVRSRV_ERROR (*PFN_CLOSE_BC_DEVICE)(IMG_UINT32, IMG_HANDLE);
typedef PVRSRV_ERROR (*PFN_GET_BC_INFO)(IMG_HANDLE, BUFFER_INFO*);
typedef PVRSRV_ERROR (*PFN_GET_BC_BUFFER)(IMG_HANDLE, IMG_UINT32, PVRSRV_SYNC_DATA*, IMG_HANDLE*);
typedef PVRSRV_ERROR (*PFN_BC_REGISTER_BUFFER_DEV)(PVRSRV_BC_SRV2BUFFER_KMJTABLE*, IMG_UINT32*);
+typedef IMG_VOID (*PFN_BC_SCHEDULE_DEVICES)(IMG_VOID);
typedef PVRSRV_ERROR (*PFN_BC_REMOVE_BUFFER_DEV)(IMG_UINT32);
typedef struct PVRSRV_BC_BUFFER2SRV_KMJTABLE_TAG
{
IMG_UINT32 ui32TableSize;
PFN_BC_REGISTER_BUFFER_DEV pfnPVRSRVRegisterBCDevice;
+ PFN_BC_SCHEDULE_DEVICES pfnPVRSRVScheduleDevices;
PFN_BC_REMOVE_BUFFER_DEV pfnPVRSRVRemoveBCDevice;
} PVRSRV_BC_BUFFER2SRV_KMJTABLE, *PPVRSRV_BC_BUFFER2SRV_KMJTABLE;
typedef IMG_BOOL (*PFN_BC_GET_PVRJTABLE) (PPVRSRV_BC_BUFFER2SRV_KMJTABLE);
+IMG_IMPORT IMG_BOOL PVRGetBufferClassJTable(PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable);
+
+#if defined (__cplusplus)
+}
+#endif
+
#endif
#if !defined (__KERNELDISPLAY_H__)
#define __KERNELDISPLAY_H__
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
typedef PVRSRV_ERROR (*PFN_OPEN_DC_DEVICE)(IMG_UINT32, IMG_HANDLE*, PVRSRV_SYNC_DATA*);
typedef PVRSRV_ERROR (*PFN_CLOSE_DC_DEVICE)(IMG_HANDLE);
typedef PVRSRV_ERROR (*PFN_ENUM_DC_FORMATS)(IMG_HANDLE, IMG_UINT32*, DISPLAY_FORMAT*);
IMG_UINT32,
IMG_RECT*);
typedef PVRSRV_ERROR (*PFN_SWAP_TO_DC_SYSTEM)(IMG_HANDLE, IMG_HANDLE);
+typedef IMG_VOID (*PFN_QUERY_SWAP_COMMAND_ID)(IMG_HANDLE, IMG_HANDLE, IMG_HANDLE, IMG_HANDLE, IMG_UINT16*, IMG_BOOL*);
typedef IMG_VOID (*PFN_SET_DC_STATE)(IMG_HANDLE, IMG_UINT32);
typedef struct PVRSRV_DC_SRV2DISP_KMJTABLE_TAG
PFN_SWAP_TO_DC_BUFFER pfnSwapToDCBuffer;
PFN_SWAP_TO_DC_SYSTEM pfnSwapToDCSystem;
PFN_SET_DC_STATE pfnSetDCState;
+ PFN_QUERY_SWAP_COMMAND_ID pfnQuerySwapCommandID;
} PVRSRV_DC_SRV2DISP_KMJTABLE;
PFN_DC_CMD_COMPLETE pfnPVRSRVCmdComplete;
PFN_DC_REGISTER_SYS_ISR pfnPVRSRVRegisterSystemISRHandler;
PFN_DC_REGISTER_POWER pfnPVRSRVRegisterPowerDevice;
+ PFN_DC_CMD_COMPLETE pfnPVRSRVFreeCmdCompletePacket;
} PVRSRV_DC_DISP2SRV_KMJTABLE, *PPVRSRV_DC_DISP2SRV_KMJTABLE;
typedef IMG_BOOL (*PFN_DC_GET_PVRJTABLE)(PPVRSRV_DC_DISP2SRV_KMJTABLE);
+IMG_IMPORT IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
+#if defined (__cplusplus)
+}
+#endif
+
#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef _SERVICES_PDUMP_H_
+#define _SERVICES_PDUMP_H_
+
+#define PDUMP_FLAGS_NEVER 0x08000000U
+#define PDUMP_FLAGS_LASTFRAME 0x10000000U
+#define PDUMP_FLAGS_RESETLFBUFFER 0x20000000U
+#define PDUMP_FLAGS_CONTINUOUS 0x40000000U
+#define PDUMP_FLAGS_PERSISTENT 0x80000000U
+
+#endif
+
#error Unknown platform: Cannot define ioctls
- #define PVRSRV_IO(INDEX) (PVRSRV_IOC_GID + INDEX)
- #define PVRSRV_IOW(INDEX) (PVRSRV_IOC_GID + INDEX)
- #define PVRSRV_IOR(INDEX) (PVRSRV_IOC_GID + INDEX)
- #define PVRSRV_IOWR(INDEX) (PVRSRV_IOC_GID + INDEX)
+ #define PVRSRV_IO(INDEX) (PVRSRV_IOC_GID + (INDEX))
+ #define PVRSRV_IOW(INDEX) (PVRSRV_IOC_GID + (INDEX))
+ #define PVRSRV_IOR(INDEX) (PVRSRV_IOC_GID + (INDEX))
+ #define PVRSRV_IOWR(INDEX) (PVRSRV_IOC_GID + (INDEX))
#define PVRSRV_BRIDGE_BASE PVRSRV_IOC_GID
#endif
#define PVRSRV_BRIDGE_RELEASE_MISC_INFO PVRSRV_IOWR(PVRSRV_BRIDGE_MISC_CMD_FIRST+1)
#define PVRSRV_BRIDGE_MISC_CMD_LAST (PVRSRV_BRIDGE_MISC_CMD_FIRST+1)
-#define PVRSRV_BRIDGE_OVERLAY_CMD_FIRST (PVRSRV_BRIDGE_MISC_CMD_LAST+1)
#if defined (SUPPORT_OVERLAY_ROTATE_BLIT)
+#define PVRSRV_BRIDGE_OVERLAY_CMD_FIRST (PVRSRV_BRIDGE_MISC_CMD_LAST+1)
#define PVRSRV_BRIDGE_INIT_3D_OVL_BLT_RES PVRSRV_IOWR(PVRSRV_BRIDGE_OVERLAY_CMD_FIRST+0)
#define PVRSRV_BRIDGE_DEINIT_3D_OVL_BLT_RES PVRSRV_IOWR(PVRSRV_BRIDGE_OVERLAY_CMD_FIRST+1)
-#endif
#define PVRSRV_BRIDGE_OVERLAY_CMD_LAST (PVRSRV_BRIDGE_OVERLAY_CMD_FIRST+1)
+#else
+#define PVRSRV_BRIDGE_OVERLAY_CMD_LAST PVRSRV_BRIDGE_MISC_CMD_LAST
+#endif
#if defined(PDUMP)
-#define PVRSRV_BRIDGE_PDUMP_CMD_FIRST (PVRSRV_BRIDGE_OVERLAY_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_PDUMP_CMD_FIRST (PVRSRV_BRIDGE_OVERLAY_CMD_LAST+1)
#define PVRSRV_BRIDGE_PDUMP_INIT PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+0)
#define PVRSRV_BRIDGE_PDUMP_MEMPOL PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+1)
#define PVRSRV_BRIDGE_PDUMP_DUMPMEM PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+2)
#define PVRSRV_BRIDGE_PDUMP_DUMPSYNC PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+11)
#define PVRSRV_BRIDGE_PDUMP_MEMPAGES PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+12)
#define PVRSRV_BRIDGE_PDUMP_DRIVERINFO PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+13)
-#define PVRSRV_BRIDGE_PDUMP_PDREG PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+14)
#define PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+15)
#define PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+16)
#define PVRSRV_BRIDGE_PDUMP_STARTINITPHASE PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+17)
#define PVRSRV_BRIDGE_EVENT_OBJECT_CMD_LAST (PVRSRV_BRIDGE_EVENT_OBJECT_CMD_FIRST+2)
#define PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST (PVRSRV_BRIDGE_EVENT_OBJECT_CMD_LAST+1)
-#define PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+0)
-#define PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+1)
-#define PVRSRV_BRIDGE_SYNC_OPS_CMD_LAST (PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_CREATE_SYNC_INFO_MOD_OBJ PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_DESTROY_SYNC_INFO_MOD_OBJ PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+2)
+#define PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+3)
+#define PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_MOD_OBJ PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+4)
+#define PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_DELTA PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+5)
+#define PVRSRV_BRIDGE_ALLOC_SYNC_INFO PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+6)
+#define PVRSRV_BRIDGE_FREE_SYNC_INFO PVRSRV_IOWR(PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+7)
+#define PVRSRV_BRIDGE_SYNC_OPS_CMD_LAST (PVRSRV_BRIDGE_SYNC_OPS_CMD_FIRST+7)
#define PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD (PVRSRV_BRIDGE_SYNC_OPS_CMD_LAST+1)
+
+typedef struct PVRSRV_BRIDGE_IN_CONNECT_SERVICES_TAG
+{
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_UINT32 ui32Flags;
+} PVRSRV_BRIDGE_IN_CONNECT_SERVICES;
+
typedef struct PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO_TAG
{
IMG_UINT32 ui32BridgeFlags;
{
PVRSRV_ERROR eError;
PVRSRV_KERNEL_MEM_INFO *psDstKernelMemInfo;
- PVRSRV_KERNEL_SYNC_INFO *psDstKernelSyncInfo;
PVRSRV_CLIENT_MEM_INFO sDstClientMemInfo;
PVRSRV_CLIENT_SYNC_INFO sDstClientSyncInfo;
PVRSRV_CLIENT_MEM_INFO sClientMemInfo;
PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
- PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
IMG_HANDLE hMappingInfo;
}PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY;
IMG_UINT32 ui32Offset;
IMG_UINT32 ui32Value;
IMG_UINT32 ui32Mask;
+ PDUMP_POLL_OPERATOR eOperator;
IMG_UINT32 ui32Flags;
}PVRSRV_BRIDGE_IN_PDUMP_MEMPOL;
typedef struct PVRSRV_BRIDGE_IN_PDUMP_DUMPREG_TAG
{
- IMG_UINT32 ui32BridgeFlags;
- PVRSRV_HWREG sHWReg;
- IMG_UINT32 ui32Flags;
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
+ PVRSRV_HWREG sHWReg;
+ IMG_UINT32 ui32Flags;
+ IMG_CHAR szRegRegion[32];
}PVRSRV_BRIDGE_IN_PDUMP_DUMPREG;
typedef struct PVRSRV_BRIDGE_IN_PDUMP_REGPOL_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
PVRSRV_HWREG sHWReg;
IMG_UINT32 ui32Mask;
IMG_UINT32 ui32Flags;
+ IMG_CHAR szRegRegion[32];
}PVRSRV_BRIDGE_IN_PDUMP_REGPOL;
typedef struct PVRSRV_BRIDGE_IN_PDUMP_BITMAP_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
IMG_CHAR szFileName[PVRSRV_PDUMP_MAX_FILENAME_SIZE];
IMG_UINT32 ui32FileOffset;
IMG_UINT32 ui32Width;
IMG_UINT32 ui32Height;
IMG_UINT32 ui32StrideInBytes;
IMG_DEV_VIRTADDR sDevBaseAddr;
+ IMG_HANDLE hDevMemContext;
IMG_UINT32 ui32Size;
PDUMP_PIXEL_FORMAT ePixelFormat;
PDUMP_MEM_FORMAT eMemFormat;
typedef struct PVRSRV_BRIDGE_IN_PDUMP_READREG_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
IMG_CHAR szFileName[PVRSRV_PDUMP_MAX_FILENAME_SIZE];
IMG_UINT32 ui32FileOffset;
IMG_UINT32 ui32Address;
IMG_UINT32 ui32Size;
IMG_UINT32 ui32Flags;
+ IMG_CHAR szRegRegion[32];
}PVRSRV_BRIDGE_IN_PDUMP_READREG;
typedef struct PVRSRV_BRIDGE_PDUM_IN_CYCLE_COUNT_REG_READ_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
IMG_UINT32 ui32RegOffset;
IMG_BOOL bLastFrame;
}PVRSRV_BRIDGE_IN_PDUMP_CYCLE_COUNT_REG_READ;
IMG_BOOL bPhysContig;
IMG_UINT32 ui32NumPageTableEntries;
IMG_SYS_PHYADDR *psSysPAddr;
+ IMG_UINT32 ui32Flags;
}PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY;
{
PVRSRV_ERROR eError;
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
- PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
PVRSRV_CLIENT_MEM_INFO sClientMemInfo;
PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
PVRSRV_CLIENT_MEM_INFO sClientMemInfo;
PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
- PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
PVRSRV_ERROR eError;
}PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM;
IMG_HANDLE hOSEventKM;
} PVRSRV_BRIDGE_IN_EVENT_OBJECT_CLOSE;
+typedef struct PVRSRV_BRIDGE_OUT_CREATE_SYNC_INFO_MOD_OBJ_TAG
+{
+ PVRSRV_ERROR eError;
+
+ IMG_HANDLE hKernelSyncInfoModObj;
+
+} PVRSRV_BRIDGE_OUT_CREATE_SYNC_INFO_MOD_OBJ;
+
+typedef struct PVRSRV_BRIDGE_IN_DESTROY_SYNC_INFO_MOD_OBJ
+{
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hKernelSyncInfoModObj;
+} PVRSRV_BRIDGE_IN_DESTROY_SYNC_INFO_MOD_OBJ;
+
typedef struct PVRSRV_BRIDGE_IN_MODIFY_PENDING_SYNC_OPS_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hKernelSyncInfoModObj;
IMG_HANDLE hKernelSyncInfo;
IMG_UINT32 ui32ModifyFlags;
typedef struct PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS_TAG
{
IMG_UINT32 ui32BridgeFlags;
- IMG_HANDLE hKernelSyncInfo;
- IMG_UINT32 ui32ModifyFlags;
-
+ IMG_HANDLE hKernelSyncInfoModObj;
} PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS;
typedef struct PVRSRV_BRIDGE_OUT_MODIFY_PENDING_SYNC_OPS_TAG
} PVRSRV_BRIDGE_OUT_MODIFY_PENDING_SYNC_OPS;
+typedef struct PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_MOD_OBJ_TAG
+{
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hKernelSyncInfoModObj;
+} PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_MOD_OBJ;
+
+typedef struct PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_DELTA_TAG
+{
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hKernelSyncInfo;
+ IMG_UINT32 ui32Delta;
+} PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_DELTA;
+
+typedef struct PVRSRV_BRIDGE_IN_ALLOC_SYNC_INFO_TAG
+{
+ IMG_UINT32 ui32BridgeFlags;
+
+ IMG_HANDLE hDevCookie;
+} PVRSRV_BRIDGE_IN_ALLOC_SYNC_INFO;
+
+typedef struct PVRSRV_BRIDGE_OUT_ALLOC_SYNC_INFO_TAG
+{
+ PVRSRV_ERROR eError;
+
+ IMG_HANDLE hKernelSyncInfo;
+} PVRSRV_BRIDGE_OUT_ALLOC_SYNC_INFO;
+
+typedef struct PVRSRV_BRIDGE_IN_FREE_SYNC_INFO_TAG
+{
+ IMG_UINT32 ui32BridgeFlags;
+
+ IMG_HANDLE hKernelSyncInfo;
+} PVRSRV_BRIDGE_IN_FREE_SYNC_INFO;
+
+
#if defined (__cplusplus)
}
#endif
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psSysAddr,
IMG_VOID *pvLinAddr,
+ IMG_UINT32 ui32Flags,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo);
IMG_IMPORT
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfoKM(PVRSRV_MISC_INFO *psMiscInfo);
-PVRSRV_ERROR PVRSRVGetFBStatsKM(IMG_SIZE_T *pui32Total,
- IMG_SIZE_T *pui32Available);
-
IMG_IMPORT PVRSRV_ERROR
PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_UINT32 ui32Flags,
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined (__PVRSRV_ERRORS_H__)
+#define __PVRSRV_ERRORS_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+ switch (eError)
+ {
+ case PVRSRV_OK: return "No Errors";
+ case PVRSRV_ERROR_OUT_OF_MEMORY: return "PVRSRV_ERROR_OUT_OF_MEMORY - Unable to allocate required memory";
+ case PVRSRV_ERROR_TOO_FEW_BUFFERS: return "PVRSRV_ERROR_TOO_FEW_BUFFERS";
+ case PVRSRV_ERROR_INVALID_PARAMS: return "PVRSRV_ERROR_INVALID_PARAMS";
+ case PVRSRV_ERROR_INIT_FAILURE: return "PVRSRV_ERROR_INIT_FAILURE";
+ case PVRSRV_ERROR_CANT_REGISTER_CALLBACK: return "PVRSRV_ERROR_CANT_REGISTER_CALLBACK";
+ case PVRSRV_ERROR_INVALID_DEVICE: return "PVRSRV_ERROR_INVALID_DEVICE";
+ case PVRSRV_ERROR_NOT_OWNER: return "PVRSRV_ERROR_NOT_OWNER";
+ case PVRSRV_ERROR_BAD_MAPPING: return "PVRSRV_ERROR_BAD_MAPPING";
+ case PVRSRV_ERROR_TIMEOUT: return "PVRSRV_ERROR_TIMEOUT";
+ case PVRSRV_ERROR_FLIP_CHAIN_EXISTS: return "PVRSRV_ERROR_FLIP_CHAIN_EXISTS";
+ case PVRSRV_ERROR_INVALID_SWAPINTERVAL: return "PVRSRV_ERROR_INVALID_SWAPINTERVAL";
+ case PVRSRV_ERROR_SCENE_INVALID: return "PVRSRV_ERROR_SCENE_INVALID";
+ case PVRSRV_ERROR_STREAM_ERROR: return "PVRSRV_ERROR_STREAM_ERROR";
+ case PVRSRV_ERROR_FAILED_DEPENDENCIES: return "PVRSRV_ERROR_FAILED_DEPENDENCIES";
+ case PVRSRV_ERROR_CMD_NOT_PROCESSED: return "PVRSRV_ERROR_CMD_NOT_PROCESSED";
+ case PVRSRV_ERROR_CMD_TOO_BIG: return "PVRSRV_ERROR_CMD_TOO_BIG";
+ case PVRSRV_ERROR_DEVICE_REGISTER_FAILED: return "PVRSRV_ERROR_DEVICE_REGISTER_FAILED";
+ case PVRSRV_ERROR_TOOMANYBUFFERS: return "PVRSRV_ERROR_TOOMANYBUFFERS";
+ case PVRSRV_ERROR_NOT_SUPPORTED: return "PVRSRV_ERROR_NOT_SUPPORTED - fix";
+ case PVRSRV_ERROR_PROCESSING_BLOCKED: return "PVRSRV_ERROR_PROCESSING_BLOCKED";
+
+ case PVRSRV_ERROR_CANNOT_FLUSH_QUEUE: return "PVRSRV_ERROR_CANNOT_FLUSH_QUEUE";
+ case PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE: return "PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE";
+ case PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS: return "PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS";
+ case PVRSRV_ERROR_RETRY: return "PVRSRV_ERROR_RETRY";
+
+ case PVRSRV_ERROR_DDK_VERSION_MISMATCH: return "PVRSRV_ERROR_DDK_VERSION_MISMATCH";
+ case PVRSRV_ERROR_BUILD_MISMATCH: return "PVRSRV_ERROR_BUILD_MISMATCH";
+ case PVRSRV_ERROR_CORE_REVISION_MISMATCH: return "PVRSRV_ERROR_CORE_REVISION_MISMATCH";
+
+ case PVRSRV_ERROR_UPLOAD_TOO_BIG: return "PVRSRV_ERROR_UPLOAD_TOO_BIG";
+
+ case PVRSRV_ERROR_INVALID_FLAGS: return "PVRSRV_ERROR_INVALID_FLAGS";
+ case PVRSRV_ERROR_FAILED_TO_REGISTER_PROCESS: return "PVRSRV_ERROR_FAILED_TO_REGISTER_PROCESS";
+
+ case PVRSRV_ERROR_UNABLE_TO_LOAD_LIBRARY: return "PVRSRV_ERROR_UNABLE_TO_LOAD_LIBRARY";
+ case PVRSRV_ERROR_UNABLE_GET_FUNC_ADDR: return "PVRSRV_ERROR_UNABLE_GET_FUNC_ADDR";
+ case PVRSRV_ERROR_UNLOAD_LIBRARY_FAILED: return "PVRSRV_ERROR_UNLOAD_LIBRARY_FAILED";
+
+ case PVRSRV_ERROR_BRIDGE_CALL_FAILED: return "PVRSRV_ERROR_BRIDGE_CALL_FAILED";
+ case PVRSRV_ERROR_IOCTL_CALL_FAILED: return "PVRSRV_ERROR_IOCTL_CALL_FAILED";
+
+ case PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND: return "PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND";
+ case PVRSRV_ERROR_BUFFER_DEVICE_NOT_FOUND: return "PVRSRV_ERROR_BUFFER_DEVICE_NOT_FOUND";
+ case PVRSRV_ERROR_BUFFER_DEVICE_ALREADY_PRESENT:return "PVRSRV_ERROR_BUFFER_DEVICE_ALREADY_PRESENT";
+
+ case PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND: return "PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND";
+ case PVRSRV_ERROR_PCI_CALL_FAILED: return "PVRSRV_ERROR_PCI_CALL_FAILED";
+ case PVRSRV_ERROR_PCI_REGION_TOO_SMALL: return "PVRSRV_ERROR_PCI_REGION_TOO_SMALL";
+ case PVRSRV_ERROR_PCI_REGION_UNAVAILABLE: return "PVRSRV_ERROR_PCI_REGION_UNAVAILABLE";
+ case PVRSRV_ERROR_BAD_REGION_SIZE_MISMATCH: return "PVRSRV_ERROR_BAD_REGION_SIZE_MISMATCH";
+
+ case PVRSRV_ERROR_REGISTER_BASE_NOT_SET: return "PVRSRV_ERROR_REGISTER_BASE_NOT_SET";
+
+ case PVRSRV_ERROR_FAILED_TO_ALLOC_USER_MEM: return "PVRSRV_ERROR_FAILED_TO_ALLOC_USER_MEM";
+ case PVRSRV_ERROR_FAILED_TO_ALLOC_VP_MEMORY: return "PVRSRV_ERROR_FAILED_TO_ALLOC_VP_MEMORY";
+ case PVRSRV_ERROR_FAILED_TO_MAP_SHARED_PBDESC: return "PVRSRV_ERROR_FAILED_TO_MAP_SHARED_PBDESC";
+ case PVRSRV_ERROR_FAILED_TO_GET_PHYS_ADDR: return "PVRSRV_ERROR_FAILED_TO_GET_PHYS_ADDR";
+
+ case PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY: return "PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY";
+ case PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY: return "PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY";
+
+ case PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES: return "PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES";
+ case PVRSRV_ERROR_FAILED_TO_FREE_PAGES: return "PVRSRV_ERROR_FAILED_TO_FREE_PAGES";
+ case PVRSRV_ERROR_FAILED_TO_COPY_PAGES: return "PVRSRV_ERROR_FAILED_TO_COPY_PAGES";
+ case PVRSRV_ERROR_UNABLE_TO_LOCK_PAGES: return "PVRSRV_ERROR_UNABLE_TO_LOCK_PAGES";
+ case PVRSRV_ERROR_UNABLE_TO_UNLOCK_PAGES: return "PVRSRV_ERROR_UNABLE_TO_UNLOCK_PAGES";
+ case PVRSRV_ERROR_STILL_MAPPED: return "PVRSRV_ERROR_STILL_MAPPED";
+ case PVRSRV_ERROR_MAPPING_NOT_FOUND: return "PVRSRV_ERROR_MAPPING_NOT_FOUND";
+ case PVRSRV_ERROR_PHYS_ADDRESS_EXCEEDS_32BIT: return "PVRSRV_ERROR_PHYS_ADDRESS_EXCEEDS_32BIT";
+ case PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE: return "PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE";
+
+ case PVRSRV_ERROR_INVALID_SEGMENT_BLOCK: return "PVRSRV_ERROR_INVALID_SEGMENT_BLOCK";
+ case PVRSRV_ERROR_INVALID_SGXDEVDATA: return "PVRSRV_ERROR_INVALID_SGXDEVDATA";
+ case PVRSRV_ERROR_INVALID_DEVINFO: return "PVRSRV_ERROR_INVALID_DEVINFO";
+ case PVRSRV_ERROR_INVALID_MEMINFO: return "PVRSRV_ERROR_INVALID_MEMINFO";
+ case PVRSRV_ERROR_INVALID_MISCINFO: return "PVRSRV_ERROR_INVALID_MISCINFO";
+ case PVRSRV_ERROR_UNKNOWN_IOCTL: return "PVRSRV_ERROR_UNKNOWN_IOCTL";
+ case PVRSRV_ERROR_INVALID_CONTEXT: return "PVRSRV_ERROR_INVALID_CONTEXT";
+ case PVRSRV_ERROR_UNABLE_TO_DESTROY_CONTEXT: return "PVRSRV_ERROR_UNABLE_TO_DESTROY_CONTEXT";
+ case PVRSRV_ERROR_INVALID_HEAP: return "PVRSRV_ERROR_INVALID_HEAP";
+ case PVRSRV_ERROR_INVALID_KERNELINFO: return "PVRSRV_ERROR_INVALID_KERNELINFO";
+ case PVRSRV_ERROR_UNKNOWN_POWER_STATE: return "PVRSRV_ERROR_UNKNOWN_POWER_STATE";
+ case PVRSRV_ERROR_INVALID_HANDLE_TYPE: return "PVRSRV_ERROR_INVALID_HANDLE_TYPE";
+ case PVRSRV_ERROR_INVALID_WRAP_TYPE: return "PVRSRV_ERROR_INVALID_WRAP_TYPE";
+ case PVRSRV_ERROR_INVALID_PHYS_ADDR: return "PVRSRV_ERROR_INVALID_PHYS_ADDR";
+ case PVRSRV_ERROR_INVALID_CPU_ADDR: return "PVRSRV_ERROR_INVALID_CPU_ADDR";
+ case PVRSRV_ERROR_INVALID_HEAPINFO: return "PVRSRV_ERROR_INVALID_HEAPINFO";
+ case PVRSRV_ERROR_INVALID_PERPROC: return "PVRSRV_ERROR_INVALID_PERPROC";
+ case PVRSRV_ERROR_FAILED_TO_RETRIEVE_HEAPINFO: return "PVRSRV_ERROR_FAILED_TO_RETRIEVE_HEAPINFO";
+ case PVRSRV_ERROR_INVALID_MAP_REQUEST: return "PVRSRV_ERROR_INVALID_MAP_REQUEST";
+ case PVRSRV_ERROR_INVALID_UNMAP_REQUEST: return "PVRSRV_ERROR_INVALID_UNMAP_REQUEST";
+ case PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP: return "PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP";
+ case PVRSRV_ERROR_MAPPING_STILL_IN_USE: return "PVRSRV_ERROR_MAPPING_STILL_IN_USE";
+
+ case PVRSRV_ERROR_EXCEEDED_HW_LIMITS: return "PVRSRV_ERROR_EXCEEDED_HW_LIMITS";
+ case PVRSRV_ERROR_NO_STAGING_BUFFER_ALLOCATED: return "PVRSRV_ERROR_NO_STAGING_BUFFER_ALLOCATED";
+
+ case PVRSRV_ERROR_UNABLE_TO_CREATE_PERPROC_AREA:return "PVRSRV_ERROR_UNABLE_TO_CREATE_PERPROC_AREA";
+ case PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT: return "PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT";
+ case PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT: return "PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT";
+ case PVRSRV_ERROR_UNABLE_TO_REGISTER_EVENT: return "PVRSRV_ERROR_UNABLE_TO_REGISTER_EVENT";
+ case PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT: return "PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT";
+ case PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD: return "PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD";
+ case PVRSRV_ERROR_UNABLE_TO_CLOSE_THREAD: return "PVRSRV_ERROR_UNABLE_TO_CLOSE_THREAD";
+ case PVRSRV_ERROR_THREAD_READ_ERROR: return "PVRSRV_ERROR_THREAD_READ_ERROR";
+ case PVRSRV_ERROR_UNABLE_TO_REGISTER_ISR_HANDLER:return "PVRSRV_ERROR_UNABLE_TO_REGISTER_ISR_HANDLER";
+ case PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR: return "PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR";
+ case PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR: return "PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR";
+ case PVRSRV_ERROR_ISR_ALREADY_INSTALLED: return "PVRSRV_ERROR_ISR_ALREADY_INSTALLED";
+ case PVRSRV_ERROR_ISR_NOT_INSTALLED: return "PVRSRV_ERROR_ISR_NOT_INSTALLED";
+ case PVRSRV_ERROR_UNABLE_TO_INITIALISE_INTERRUPT:return "PVRSRV_ERROR_UNABLE_TO_INITIALISE_INTERRUPT";
+ case PVRSRV_ERROR_UNABLE_TO_RETRIEVE_INFO: return "PVRSRV_ERROR_UNABLE_TO_RETRIEVE_INFO";
+ case PVRSRV_ERROR_UNABLE_TO_DO_BACKWARDS_BLIT: return "PVRSRV_ERROR_UNABLE_TO_DO_BACKWARDS_BLIT";
+ case PVRSRV_ERROR_UNABLE_TO_CLOSE_SERVICES: return "PVRSRV_ERROR_UNABLE_TO_CLOSE_SERVICES";
+ case PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT: return "PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT";
+ case PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE: return "PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE";
+
+ case PVRSRV_ERROR_INVALID_CCB_COMMAND: return "PVRSRV_ERROR_INVALID_CCB_COMMAND";
+
+ case PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE: return "PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE";
+ case PVRSRV_ERROR_INVALID_LOCK_ID: return "PVRSRV_ERROR_INVALID_LOCK_ID";
+ case PVRSRV_ERROR_RESOURCE_NOT_LOCKED: return "PVRSRV_ERROR_RESOURCE_NOT_LOCKED";
+
+ case PVRSRV_ERROR_FLIP_FAILED: return "PVRSRV_ERROR_FLIP_FAILED";
+ case PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED: return "PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED";
+
+ case PVRSRV_ERROR_TIMEOUT_POLLING_FOR_VALUE: return "PVRSRV_ERROR_TIMEOUT_POLLING_FOR_VALUE";
+
+ case PVRSRV_ERROR_CREATE_RENDER_CONTEXT_FAILED: return "PVRSRV_ERROR_CREATE_RENDER_CONTEXT_FAILED";
+ case PVRSRV_ERROR_UNKNOWN_PRIMARY_FRAG: return "PVRSRV_ERROR_UNKNOWN_PRIMARY_FRAG";
+ case PVRSRV_ERROR_UNEXPECTED_SECONDARY_FRAG: return "PVRSRV_ERROR_UNEXPECTED_SECONDARY_FRAG";
+ case PVRSRV_ERROR_UNEXPECTED_PRIMARY_FRAG: return "PVRSRV_ERROR_UNEXPECTED_PRIMARY_FRAG";
+
+ case PVRSRV_ERROR_UNABLE_TO_INSERT_FENCE_ID: return "PVRSRV_ERROR_UNABLE_TO_INSERT_FENCE_ID";
+
+ case PVRSRV_ERROR_BLIT_SETUP_FAILED: return "PVRSRV_ERROR_BLIT_SETUP_FAILED";
+
+ case PVRSRV_ERROR_PDUMP_NOT_AVAILABLE: return "PVRSRV_ERROR_PDUMP_NOT_AVAILABLE";
+ case PVRSRV_ERROR_PDUMP_BUFFER_FULL: return "PVRSRV_ERROR_PDUMP_BUFFER_FULL";
+ case PVRSRV_ERROR_PDUMP_BUF_OVERFLOW: return "PVRSRV_ERROR_PDUMP_BUF_OVERFLOW";
+ case PVRSRV_ERROR_PDUMP_NOT_ACTIVE: return "PVRSRV_ERROR_PDUMP_NOT_ACTIVE";
+ case PVRSRV_ERROR_INCOMPLETE_LINE_OVERLAPS_PAGES:return "PVRSRV_ERROR_INCOMPLETE_LINE_OVERLAPS_PAGES";
+
+ case PVRSRV_ERROR_MUTEX_DESTROY_FAILED: return "PVRSRV_ERROR_MUTEX_DESTROY_FAILED";
+ case PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR: return "PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR";
+
+ case PVRSRV_ERROR_INSUFFICIENT_SCRIPT_SPACE: return "PVRSRV_ERROR_INSUFFICIENT_SCRIPT_SPACE";
+ case PVRSRV_ERROR_INSUFFICIENT_SPACE_FOR_COMMAND:return "PVRSRV_ERROR_INSUFFICIENT_SPACE_FOR_COMMAND";
+
+ case PVRSRV_ERROR_PROCESS_NOT_INITIALISED: return "PVRSRV_ERROR_PROCESS_NOT_INITIALISED";
+ case PVRSRV_ERROR_PROCESS_NOT_FOUND: return "PVRSRV_ERROR_PROCESS_NOT_FOUND";
+ case PVRSRV_ERROR_SRV_CONNECT_FAILED: return "PVRSRV_ERROR_SRV_CONNECT_FAILED";
+ case PVRSRV_ERROR_SRV_DISCONNECT_FAILED: return "PVRSRV_ERROR_SRV_DISCONNECT_FAILED";
+ case PVRSRV_ERROR_DEINT_PHASE_FAILED: return "PVRSRV_ERROR_DEINT_PHASE_FAILED";
+ case PVRSRV_ERROR_INIT2_PHASE_FAILED: return "PVRSRV_ERROR_INIT2_PHASE_FAILED";
+
+ case PVRSRV_ERROR_NO_DC_DEVICES_FOUND: return "PVRSRV_ERROR_NO_DC_DEVICES_FOUND";
+ case PVRSRV_ERROR_UNABLE_TO_OPEN_DC_DEVICE: return "PVRSRV_ERROR_UNABLE_TO_OPEN_DC_DEVICE";
+ case PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE: return "PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE";
+ case PVRSRV_ERROR_NO_DEVICEDATA_FOUND: return "PVRSRV_ERROR_NO_DEVICEDATA_FOUND";
+ case PVRSRV_ERROR_NO_DEVICENODE_FOUND: return "PVRSRV_ERROR_NO_DEVICENODE_FOUND";
+ case PVRSRV_ERROR_NO_CLIENTNODE_FOUND: return "PVRSRV_ERROR_NO_CLIENTNODE_FOUND";
+ case PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE: return "PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE";
+
+ case PVRSRV_ERROR_UNABLE_TO_INIT_TASK: return "PVRSRV_ERROR_UNABLE_TO_INIT_TASK";
+ case PVRSRV_ERROR_UNABLE_TO_SCHEDULE_TASK: return "PVRSRV_ERROR_UNABLE_TO_SCHEDULE_TASK";
+ case PVRSRV_ERROR_UNABLE_TO_KILL_TASK: return "PVRSRV_ERROR_UNABLE_TO_KILL_TASK";
+
+ case PVRSRV_ERROR_UNABLE_TO_ENABLE_TIMER: return "PVRSRV_ERROR_UNABLE_TO_ENABLE_TIMER";
+ case PVRSRV_ERROR_UNABLE_TO_DISABLE_TIMER: return "PVRSRV_ERROR_UNABLE_TO_DISABLE_TIMER";
+ case PVRSRV_ERROR_UNABLE_TO_REMOVE_TIMER: return "PVRSRV_ERROR_UNABLE_TO_REMOVE_TIMER";
+
+ case PVRSRV_ERROR_UNKNOWN_PIXEL_FORMAT: return "PVRSRV_ERROR_UNKNOWN_PIXEL_FORMAT";
+ case PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION: return "PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION";
+
+ case PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE: return "PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE";
+ case PVRSRV_ERROR_HANDLE_NOT_ALLOCATED: return "PVRSRV_ERROR_HANDLE_NOT_ALLOCATED";
+ case PVRSRV_ERROR_HANDLE_TYPE_MISMATCH: return "PVRSRV_ERROR_HANDLE_TYPE_MISMATCH";
+ case PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE: return "PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE";
+ case PVRSRV_ERROR_HANDLE_NOT_SHAREABLE: return "PVRSRV_ERROR_HANDLE_NOT_SHAREABLE";
+ case PVRSRV_ERROR_HANDLE_NOT_FOUND: return "PVRSRV_ERROR_HANDLE_NOT_FOUND";
+ case PVRSRV_ERROR_INVALID_SUBHANDLE: return "PVRSRV_ERROR_INVALID_SUBHANDLE";
+ case PVRSRV_ERROR_HANDLE_BATCH_IN_USE: return "PVRSRV_ERROR_HANDLE_BATCH_IN_USE";
+ case PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE: return "PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE";
+
+ case PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE: return "PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE";
+ case PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED:return "PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED";
+
+ case PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE: return "PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE";
+ case PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP: return "PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP";
+
+ case PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE: return "PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE";
+
+ case PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE: return "PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE";
+ case PVRSRV_ERROR_INVALID_DEVICEID: return "PVRSRV_ERROR_INVALID_DEVICEID";
+ case PVRSRV_ERROR_DEVICEID_NOT_FOUND: return "PVRSRV_ERROR_DEVICEID_NOT_FOUND";
+
+ case PVRSRV_ERROR_MEMORY_TEST_FAILED: return "PVRSRV_ERROR_MEMORY_TEST_FAILED";
+ case PVRSRV_ERROR_CPUPADDR_TEST_FAILED: return "PVRSRV_ERROR_CPUPADDR_TEST_FAILED";
+ case PVRSRV_ERROR_COPY_TEST_FAILED: return "PVRSRV_ERROR_COPY_TEST_FAILED";
+
+ case PVRSRV_ERROR_SEMAPHORE_NOT_INITIALISED: return "PVRSRV_ERROR_SEMAPHORE_NOT_INITIALISED";
+
+ case PVRSRV_ERROR_UNABLE_TO_RELEASE_CLOCK: return "PVRSRV_ERROR_UNABLE_TO_RELEASE_CLOCK";
+ case PVRSRV_ERROR_CLOCK_REQUEST_FAILED: return "PVRSRV_ERROR_CLOCK_REQUEST_FAILED";
+ case PVRSRV_ERROR_DISABLE_CLOCK_FAILURE: return "PVRSRV_ERROR_DISABLE_CLOCK_FAILURE";
+ case PVRSRV_ERROR_UNABLE_TO_SET_CLOCK_RATE: return "PVRSRV_ERROR_UNABLE_TO_SET_CLOCK_RATE";
+ case PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE: return "PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE";
+ case PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK: return "PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK";
+ case PVRSRV_ERROR_UNABLE_TO_GET_CLOCK: return "PVRSRV_ERROR_UNABLE_TO_GET_CLOCK";
+ case PVRSRV_ERROR_UNABLE_TO_GET_PARENT_CLOCK: return "PVRSRV_ERROR_UNABLE_TO_GET_PARENT_CLOCK";
+ case PVRSRV_ERROR_UNABLE_TO_GET_SYSTEM_CLOCK: return "PVRSRV_ERROR_UNABLE_TO_GET_SYSTEM_CLOCK";
+
+ case PVRSRV_ERROR_UNKNOWN_SGL_ERROR: return "PVRSRV_ERROR_UNKNOWN_SGL_ERROR";
+ case PVRSRV_ERROR_BAD_SYNC_STATE: return "PVRSRV_ERROR_BAD_SYNC_STATE";
+
+ case PVRSRV_ERROR_FORCE_I32: return "PVRSRV_ERROR_FORCE_I32";
+
+ default:
+ return "Unknown PVRSRV error number";
+ }
+
+#if defined (__cplusplus)
+}
+#endif
+#endif
+
#define DRIVERNAME_MAXLENGTH (100)
+#define ALIGNSIZE(size, alignshift) (((size) + ((1UL << (alignshift))-1)) & ~((1UL << (alignshift))-1))
+#ifndef MAX
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+#ifndef MIN
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+typedef enum _PVRSRV_MEMTYPE_
+{
+ PVRSRV_MEMTYPE_UNKNOWN = 0,
+ PVRSRV_MEMTYPE_DEVICE = 1,
+ PVRSRV_MEMTYPE_DEVICECLASS = 2,
+ PVRSRV_MEMTYPE_WRAPPED = 3,
+ PVRSRV_MEMTYPE_MAPPED = 4,
+} PVRSRV_MEMTYPE;
typedef struct _PVRSRV_KERNEL_MEM_INFO_
{
IMG_PVOID pvLinAddrKM;
-
+
IMG_DEV_VIRTADDR sDevVAddr;
-
-
- IMG_UINT32 ui32Flags;
-
+
- IMG_SIZE_T ui32AllocSize;
+ IMG_UINT32 ui32Flags;
-
- PVRSRV_MEMBLK sMemBlk;
+ IMG_SIZE_T ui32AllocSize;
+
- IMG_PVOID pvSysBackupBuffer;
+ PVRSRV_MEMBLK sMemBlk;
+
+ IMG_PVOID pvSysBackupBuffer;
+
IMG_UINT32 ui32RefCount;
IMG_BOOL bPendingFree;
- #if defined(ANDROID)
+#if defined(SUPPORT_MEMINFO_IDS)
#if !defined(USE_CODE)
IMG_UINT64 ui64Stamp;
IMG_UINT32 dummy1;
IMG_UINT32 dummy2;
#endif
- #endif
+#endif
struct _PVRSRV_KERNEL_SYNC_INFO_ *psKernelSyncInfo;
+ PVRSRV_MEMTYPE memType;
} PVRSRV_KERNEL_MEM_INFO;
{
PVRSRV_SYNC_DATA *psSyncData;
-
+
IMG_DEV_VIRTADDR sWriteOpsCompleteDevVAddr;
PVRSRV_KERNEL_MEM_INFO *psSyncDataMemInfoKM;
- IMG_HANDLE hResItem;
+ IMG_UINT32 ui32RefCount;
+
+
+ IMG_HANDLE hResItem;
} PVRSRV_KERNEL_SYNC_INFO;
typedef struct _PVRSRV_DEVICE_SYNC_OBJECT_
IMG_HANDLE hMemBlock[2];
- struct _PVRSRV_QUEUE_INFO_ *psNextKM;
+ struct _PVRSRV_QUEUE_INFO_ *psNextKM;
}PVRSRV_QUEUE_INFO;
-typedef PVRSRV_ERROR (*PFN_INSERT_CMD) (PVRSRV_QUEUE_INFO*,
+typedef PVRSRV_ERROR (*PFN_INSERT_CMD) (PVRSRV_QUEUE_INFO*,
PVRSRV_COMMAND**,
IMG_UINT32,
IMG_UINT16,
PVRSRV_KERNEL_SYNC_INFO*[],
IMG_UINT32,
PVRSRV_KERNEL_SYNC_INFO*[],
- IMG_UINT32);
+ IMG_UINT32);
typedef PVRSRV_ERROR (*PFN_SUBMIT_CMD) (PVRSRV_QUEUE_INFO*, PVRSRV_COMMAND*, IMG_BOOL);
typedef struct PVRSRV_DEVICECLASS_BUFFER_TAG
-{
+{
PFN_GET_BUFFER_ADDR pfnGetBufferAddr;
IMG_HANDLE hDevMemContext;
IMG_HANDLE hExtDevice;
} PVRSRV_DEVICECLASS_BUFFER;
-
+
typedef struct PVRSRV_CLIENT_DEVICECLASS_INFO_TAG
{
IMG_HANDLE hDeviceKM;
static INLINE
IMG_UINT32 PVRSRVGetWriteOpsPending(PVRSRV_KERNEL_SYNC_INFO *psSyncInfo, IMG_BOOL bIsReadOp)
{
- IMG_UINT32 ui32WriteOpsPending;
+ IMG_UINT32 ui32WriteOpsPending;
if(bIsReadOp)
{
static INLINE
IMG_UINT32 PVRSRVGetReadOpsPending(PVRSRV_KERNEL_SYNC_INFO *psSyncInfo, IMG_BOOL bIsReadOp)
{
- IMG_UINT32 ui32ReadOpsPending;
+ IMG_UINT32 ui32ReadOpsPending;
if(bIsReadOp)
{
}
IMG_IMPORT
-PVRSRV_ERROR PVRSRVQueueCommand(IMG_HANDLE hQueueInfo,
+PVRSRV_ERROR PVRSRVQueueCommand(IMG_HANDLE hQueueInfo,
PVRSRV_COMMAND *psCommand);
#define PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+28)
-#if defined(SUPPORT_SGX_HWPERF)
-#define PVRSRV_BRIDGE_SGX_READ_DIFF_COUNTERS PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+29)
#define PVRSRV_BRIDGE_SGX_READ_HWPERF_CB PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+30)
-#endif
#if defined(PDUMP)
#define PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+31)
#define PVRSRV_BRIDGE_SGX_PDUMP_COUNTER_REGISTERS PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+33)
#define PVRSRV_BRIDGE_SGX_PDUMP_TA_SIGNATURE_REGISTERS PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+34)
#define PVRSRV_BRIDGE_SGX_PDUMP_HWPERFCB PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+35)
+#define PVRSRV_BRIDGE_SGX_PDUMP_SAVEMEM PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+36)
#endif
-#define PVRSRV_BRIDGE_LAST_SGX_CMD (PVRSRV_BRIDGE_SGX_CMD_BASE+35)
+#define PVRSRV_BRIDGE_LAST_SGX_CMD (PVRSRV_BRIDGE_SGX_CMD_BASE+36)
typedef struct PVRSRV_BRIDGE_IN_GETPHYSPAGEADDR
typedef struct PVRSRV_BRIDGE_IN_PDUMPCOUNTER_REGISTERS_TAG
{
IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
IMG_UINT32 ui32DumpFrameNum;
IMG_BOOL bLastFrame;
IMG_UINT32 *pui32Registers;
}PVRSRV_BRIDGE_IN_PDUMP_HWPERFCB;
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_SAVEMEM
+{
+ IMG_UINT32 ui32BridgeFlags;
+ IMG_HANDLE hDevCookie;
+ IMG_CHAR szFileName[PVRSRV_PDUMP_MAX_FILENAME_SIZE];
+ IMG_UINT32 ui32FileOffset;
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_UINT32 ui32Size;
+ IMG_UINT32 ui32DataMaster;
+ IMG_UINT32 ui32PDumpFlags;
+
+}PVRSRV_BRIDGE_IN_PDUMP_SAVEMEM;
+
#endif
typedef struct PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_RENDER_CONTEXT_TAG
#endif
-typedef struct PVRSRV_BRIDGE_IN_SGX_READ_DIFF_COUNTERS_TAG
-{
- IMG_UINT32 ui32BridgeFlags;
- IMG_HANDLE hDevCookie;
- IMG_UINT32 ui32Reg;
- IMG_BOOL bNew;
- IMG_UINT32 ui32New;
- IMG_UINT32 ui32NewReset;
- IMG_UINT32 ui32CountersReg;
- IMG_UINT32 ui32Reg2;
-} PVRSRV_BRIDGE_IN_SGX_READ_DIFF_COUNTERS;
-
-typedef struct PVRSRV_BRIDGE_OUT_SGX_READ_DIFF_COUNTERS_TAG
-{
- PVRSRV_ERROR eError;
- IMG_UINT32 ui32Old;
- IMG_BOOL bActive;
- PVRSRV_SGXDEV_DIFF_INFO sDiffs;
-} PVRSRV_BRIDGE_OUT_SGX_READ_DIFF_COUNTERS;
-
-
-#if defined(SUPPORT_SGX_HWPERF)
typedef struct PVRSRV_BRIDGE_IN_SGX_READ_HWPERF_CB_TAG
{
IMG_UINT32 ui32BridgeFlags;
IMG_UINT32 ui32ClockSpeed;
IMG_UINT32 ui32HostTimeStamp;
} PVRSRV_BRIDGE_OUT_SGX_READ_HWPERF_CB;
-#endif
#if defined (__cplusplus)
}
{
IMG_UINT32 ui32ServiceAddress;
IMG_UINT32 ui32CacheControl;
- IMG_UINT32 ui32Data[2];
+ IMG_UINT32 ui32Data[4];
+ IMG_UINT32 ui32Padding[2];
} SGXMKIF_COMMAND;
volatile IMG_UINT32 ui32InitStatus;
volatile IMG_UINT32 ui32PowerStatus;
volatile IMG_UINT32 ui32CleanupStatus;
+#if defined(FIX_HW_BRN_28889)
+ volatile IMG_UINT32 ui32InvalStatus;
+#endif
#if defined(SUPPORT_HW_RECOVERY)
IMG_UINT32 ui32uKernelDetectedLockups;
IMG_UINT32 ui32HostDetectedLockups;
IMG_UINT32 ui32ActivePowManSampleRate;
IMG_UINT32 ui32InterruptFlags;
IMG_UINT32 ui32InterruptClearFlags;
-
+ IMG_UINT32 ui32BPSetClearSignal;
IMG_UINT32 ui32NumActivePowerEvents;
-#if defined(SUPPORT_SGX_HWPERF)
- IMG_UINT32 ui32HWPerfFlags;
-#endif
+ IMG_UINT32 ui32TimeWraps;
+ IMG_UINT32 ui32HostClock;
-
- IMG_UINT32 ui32TimeWraps;
+#if defined(SGX_FEATURE_EXTENDED_PERF_COUNTERS)
+ IMG_UINT32 aui32PerfGroup[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+ IMG_UINT32 aui32PerfBit[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+#else
+ IMG_UINT32 ui32PerfGroup;
+#endif
} SGXMKIF_HOST_CTL;
#define SGXMKIF_CMDTA_CTRLFLAGS_READY 0x00000001
typedef struct _SGXMKIF_TRANSFERCMD_SHARED_
{
-
- IMG_UINT32 ui32SrcReadOpPendingVal;
- IMG_DEV_VIRTADDR sSrcReadOpsCompleteDevAddr;
-
- IMG_UINT32 ui32SrcWriteOpPendingVal;
- IMG_DEV_VIRTADDR sSrcWriteOpsCompleteDevAddr;
+ IMG_UINT32 ui32NumSrcSyncs;
+ PVRSRV_DEVICE_SYNC_OBJECT asSrcSyncs[SGX_MAX_SRC_SYNCS];
+
+ IMG_UINT32 ui32NumDstSyncs;
+ PVRSRV_DEVICE_SYNC_OBJECT asDstSyncs[SGX_MAX_DST_SYNCS];
IMG_UINT32 ui32DstReadOpPendingVal;
IMG_DEV_VIRTADDR sDstReadOpsCompleteDevAddr;
#define PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE (1UL << 0)
+#if defined(FIX_HW_BRN_28889)
+#define PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE (1UL << 0)
+#endif
+
#define PVRSRV_USSE_MISCINFO_READY 0x1UL
#define PVRSRV_USSE_MISCINFO_GET_STRUCT_SIZES 0x2UL
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
#define PVRSRV_USSE_MISCINFO_MEMREAD 0x4UL
-
+#define PVRSRV_USSE_MISCINFO_MEMWRITE 0x8UL
#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
-#define PVRSRV_USSE_MISCINFO_MEMREAD_FAIL 0x1UL << 31;
+#define PVRSRV_USSE_MISCINFO_MEMREAD_FAIL 0x1UL << 31
#endif
#endif
#define SGX_BIF_DIR_LIST_INDEX_EDM (0)
#endif
-#define SGX_BIF_INVALIDATE_PTCACHE 0x1
-#define SGX_BIF_INVALIDATE_PDCACHE 0x2
-#define SGX_BIF_INVALIDATE_SLCACHE 0x4
+#define SGXMKIF_CC_INVAL_BIF_PT 0x1
+#define SGXMKIF_CC_INVAL_BIF_PD 0x2
+#define SGXMKIF_CC_INVAL_BIF_SL 0x4
+#define SGXMKIF_CC_INVAL_DATA 0x8
typedef struct _SGX_MISCINFO_STRUCT_SIZES_
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
-typedef struct _PVRSRV_SGX_MISCINFO_MEMREAD
+typedef struct _PVRSRV_SGX_MISCINFO_MEMACCESS
{
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_PHYADDR sPDDevPAddr;
-} PVRSRV_SGX_MISCINFO_MEMREAD;
+} PVRSRV_SGX_MISCINFO_MEMACCESS;
#endif
typedef struct _PVRSRV_SGX_MISCINFO_INFO
{
IMG_UINT32 ui32MiscInfoFlags;
- PVRSRV_SGX_MISCINFO_FEATURES sSGXFeatures;
+ PVRSRV_SGX_MISCINFO_FEATURES sSGXFeatures;
SGX_MISCINFO_STRUCT_SIZES sSGXStructSizes;
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
- PVRSRV_SGX_MISCINFO_MEMREAD sSGXMemReadData;
+ PVRSRV_SGX_MISCINFO_MEMACCESS sSGXMemAccessSrc;
+ PVRSRV_SGX_MISCINFO_MEMACCESS sSGXMemAccessDest;
#endif
} PVRSRV_SGX_MISCINFO_INFO;
#define SGXMKIF_HWPERF_CB_SIZE 0x100
-#if defined(SUPPORT_SGX_HWPERF)
typedef struct _SGXMKIF_HWPERF_CB_ENTRY_
{
IMG_UINT32 ui32FrameNo;
IMG_UINT32 ui32Type;
IMG_UINT32 ui32Ordinal;
+ IMG_UINT32 ui32Info;
IMG_UINT32 ui32TimeWraps;
IMG_UINT32 ui32Time;
- IMG_UINT32 ui32Counters[PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+ IMG_UINT32 ui32Counters[SGX_FEATURE_MP_CORE_COUNT][PVRSRV_SGX_HWPERF_NUM_COUNTERS];
} SGXMKIF_HWPERF_CB_ENTRY;
typedef struct _SGXMKIF_HWPERF_CB_
{
IMG_UINT32 ui32Woff;
IMG_UINT32 ui32Roff;
- IMG_UINT32 ui32OrdinalGRAPHICS;
- IMG_UINT32 ui32OrdinalMK_EXECUTION;
+ IMG_UINT32 ui32Ordinal;
SGXMKIF_HWPERF_CB_ENTRY psHWPerfCBData[SGXMKIF_HWPERF_CB_SIZE];
} SGXMKIF_HWPERF_CB;
-#endif
#endif
SGXMKIF_CMD_CLEANUP = 4,
SGXMKIF_CMD_GETMISCINFO = 5,
SGXMKIF_CMD_PROCESS_QUEUES = 6,
- SGXMKIF_CMD_MAX = 7,
+ SGXMKIF_CMD_DATABREAKPOINT = 7,
+ SGXMKIF_CMD_SETHWPERFSTATUS = 8,
+ SGXMKIF_CMD_MAX = 9,
SGXMKIF_CMD_FORCE_I32 = -1,
#endif
#if defined(SUPPORT_SGX_HWPERF)
IMG_HANDLE hKernelHWPerfCBMemInfo;
+#endif
+ IMG_HANDLE hKernelTASigBufferMemInfo;
+ IMG_HANDLE hKernel3DSigBufferMemInfo;
+
+#if defined(FIX_HW_BRN_29702)
+ IMG_HANDLE hKernelCFIMemInfo;
+#endif
+#if defined(FIX_HW_BRN_29823)
+ IMG_HANDLE hKernelDummyTermStreamMemInfo;
#endif
#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
IMG_HANDLE hKernelEDMStatusBufferMemInfo;
#if defined(SGX_FEATURE_MP)
IMG_UINT32 ui32MasterClkGateStatusReg;
IMG_UINT32 ui32MasterClkGateStatusMask;
+ IMG_UINT32 ui32MasterClkGateStatus2Reg;
+ IMG_UINT32 ui32MasterClkGateStatus2Mask;
#endif
IMG_UINT32 ui32CacheControl;
{
CTL_STATUS sCtlStatus;
IMG_HANDLE hKernelMemInfo;
-
- IMG_UINT32 ui32LastStatusUpdateDumpVal;
} SGX_INTERNEL_STATUS_UPDATE;
#if (defined(NO_HARDWARE) || defined(PDUMP))
IMG_BOOL bTerminateOrAbort;
#endif
-#if defined(SUPPORT_SGX_HWPERF)
- IMG_BOOL bKickRender;
-#endif
IMG_UINT32 ui32CCBOffset;
#endif
#endif
-#define PVRSRV_SGX_DIFF_NUM_COUNTERS 9
-
-typedef struct _PVRSRV_SGXDEV_DIFF_INFO_
-{
- IMG_UINT32 aui32Counters[PVRSRV_SGX_DIFF_NUM_COUNTERS];
- IMG_UINT32 ui32Time[3];
- IMG_UINT32 ui32Marker[2];
-} PVRSRV_SGXDEV_DIFF_INFO, *PPVRSRV_SGXDEV_DIFF_INFO;
-
-
#endif
#include "mmap.h"
#endif
+
#include "srvkm.h"
PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY g_BridgeDispatchTable[BRIDGE_DISPATCH_TABLE_ENTRY_COUNT];
#if defined(DEBUG_BRIDGE_KM)
PVRSRV_ERROR
-CopyFromUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
+CopyFromUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
IMG_UINT32 ui32BridgeID,
IMG_VOID *pvDest,
IMG_VOID *pvSrc,
return OSCopyFromUser(pProcData, pvDest, pvSrc, ui32Size);
}
PVRSRV_ERROR
-CopyToUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
+CopyToUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
IMG_UINT32 ui32BridgeID,
IMG_VOID *pvDest,
IMG_VOID *pvSrc,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO);
psAcquireDevInfoOUT->eError =
- PVRSRVAcquireDeviceDataKM(psAcquireDevInfoIN->uiDevIndex,
- psAcquireDevInfoIN->eDeviceType,
+ PVRSRVAcquireDeviceDataKM(psAcquireDevInfoIN->uiDevIndex,
+ psAcquireDevInfoIN->eDeviceType,
&hDevCookieInt);
if(psAcquireDevInfoOUT->eError != PVRSRV_OK)
{
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT);
- NEW_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS + 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS + 1)
psCreateDevMemContextOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
return 0;
}
- psCreateDevMemContextOUT->eError =
+ psCreateDevMemContextOUT->eError =
PVRSRVCreateDeviceMemContextKM(hDevCookieInt,
psPerProc,
&hDevMemContextInt,
PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
- PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+ PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
}
#if defined(PVR_SECURE_HANDLES)
else
psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap = hDevMemHeapExt;
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO);
- NEW_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS);
+ NEW_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS)
psGetDevMemHeapInfoOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
return 0;
}
- psGetDevMemHeapInfoOUT->eError =
+ psGetDevMemHeapInfoOUT->eError =
PVRSRVGetDeviceMemHeapInfoKM(hDevCookieInt,
hDevMemContextInt,
&psGetDevMemHeapInfoOUT->ui32ClientHeapCount,
PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
- PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+ PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
}
#if defined(PVR_SECURE_HANDLES)
else
psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap = hDevMemHeapExt;
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_DEVICEMEM);
- NEW_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc, 2);
+ NEW_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc, 2)
psAllocDeviceMemOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
return 0;
}
- psAllocDeviceMemOUT->eError =
+ psAllocDeviceMemOUT->eError =
PVRSRVAllocDeviceMemKM(hDevCookieInt,
psPerProc,
hDevMemHeapInt,
0,
sizeof (PVRSRV_CLIENT_SYNC_INFO));
psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo = IMG_NULL;
- psAllocDeviceMemOUT->psKernelSyncInfo = IMG_NULL;
}
else
{
- psAllocDeviceMemOUT->psKernelSyncInfo = psMemInfo->psKernelSyncInfo;
psAllocDeviceMemOUT->sClientSyncInfo.psSyncData =
psMemInfo->psKernelSyncInfo->psSyncData;
psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
psAllocDeviceMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
-
- psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo =
+
+ psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo =
psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
- PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
- &psAllocDeviceMemOUT->sClientSyncInfo.hKernelSyncInfo,
- psMemInfo->psKernelSyncInfo,
+ PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+ &psAllocDeviceMemOUT->sClientSyncInfo.hKernelSyncInfo,
+ psMemInfo->psKernelSyncInfo,
PVRSRV_HANDLE_TYPE_SYNC_INFO,
- PVRSRV_HANDLE_ALLOC_FLAG_NONE,
+ PVRSRV_HANDLE_ALLOC_FLAG_NONE,
psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo);
- psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo =
+ psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo =
&psAllocDeviceMemOUT->sClientSyncInfo;
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc)
return 0;
}
{
IMG_HANDLE hDevCookieInt;
IMG_VOID *pvKernelMemInfo;
- PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
-
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_DEVICEMEM);
return 0;
}
-
- psKernelMemInfo = (PVRSRV_KERNEL_MEM_INFO*)pvKernelMemInfo;
-
- if (psKernelMemInfo->ui32RefCount == 1)
- {
- psRetOUT->eError =
- PVRSRVFreeDeviceMemKM(hDevCookieInt, pvKernelMemInfo);
- }
- else
- {
- PVR_DPF((PVR_DBG_WARNING, "PVRSRVFreeDeviceMemBW: mappings are open "
- "in other processes, deferring free!"));
-
- psKernelMemInfo->bPendingFree = IMG_TRUE;
- psRetOUT->eError = PVRSRV_OK;
- }
+ psRetOUT->eError = PVRSRVFreeDeviceMemKM(hDevCookieInt, pvKernelMemInfo);
if(psRetOUT->eError != PVRSRV_OK)
{
PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDevMemOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- PVRSRV_KERNEL_MEM_INFO *psSrcKernelMemInfo = IMG_NULL;
- PVRSRV_KERNEL_MEM_INFO *psDstKernelMemInfo = IMG_NULL;
- IMG_HANDLE hDstDevMemHeap = IMG_NULL;
+ PVRSRV_KERNEL_MEM_INFO *psSrcKernelMemInfo = IMG_NULL;
+ PVRSRV_KERNEL_MEM_INFO *psDstKernelMemInfo = IMG_NULL;
+ IMG_HANDLE hDstDevMemHeap = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEV_MEMORY);
- NEW_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc, 2);
+ NEW_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc, 2)
psMapDevMemOUT->eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
}
- psMapDevMemOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ psMapDevMemOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDstDevMemHeap,
psMapDevMemIN->hDstDevMemHeap,
PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
0,
sizeof(psMapDevMemOUT->sDstClientSyncInfo));
- psMapDevMemOUT->sDstClientMemInfo.pvLinAddrKM =
+ psMapDevMemOUT->sDstClientMemInfo.pvLinAddrKM =
psDstKernelMemInfo->pvLinAddrKM;
psMapDevMemOUT->sDstClientMemInfo.pvLinAddr = 0;
PVRSRV_HANDLE_TYPE_MEM_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE);
psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo = IMG_NULL;
- psMapDevMemOUT->psDstKernelSyncInfo = IMG_NULL;
if(psDstKernelMemInfo->psKernelSyncInfo)
{
- psMapDevMemOUT->psDstKernelSyncInfo = psDstKernelMemInfo->psKernelSyncInfo;
-
psMapDevMemOUT->sDstClientSyncInfo.psSyncData =
psDstKernelMemInfo->psKernelSyncInfo->psSyncData;
psMapDevMemOUT->sDstClientSyncInfo.sWriteOpsCompleteDevVAddr =
psDstKernelMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
psMapDevMemOUT->sDstClientSyncInfo.sReadOpsCompleteDevVAddr =
psDstKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
-
- psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo =
+
+ psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo =
psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
psMapDevMemOUT->sDstClientMemInfo.psClientSyncInfo = &psMapDevMemOUT->sDstClientSyncInfo;
PVRSRV_HANDLE_TYPE_SYNC_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo);
- }
-
- COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc);
+ }
- return 0;
+ COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc)
+
+ return 0;
}
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = IMG_NULL;
+ PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEV_MEMORY);
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY);
- NEW_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc, 2);
+ NEW_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc, 2)
psMapDevClassMemOUT->eError =
}
- psMapDevClassMemOUT->eError =
+ psMapDevClassMemOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
psMapDevClassMemIN->hDevMemContext,
PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
#endif
break;
default:
- psMapDevClassMemOUT->eError = PVRSRV_ERROR_GENERIC;
+ psMapDevClassMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
return 0;
}
- psMapDevClassMemOUT->eError =
+ psMapDevClassMemOUT->eError =
PVRSRVMapDeviceClassMemoryKM(psPerProc,
hDevMemContextInt,
hDeviceClassBufferInt,
0,
sizeof(psMapDevClassMemOUT->sClientSyncInfo));
- psMapDevClassMemOUT->sClientMemInfo.pvLinAddrKM =
+ psMapDevClassMemOUT->sClientMemInfo.pvLinAddrKM =
psMemInfo->pvLinAddrKM;
psMapDevClassMemOUT->sClientMemInfo.pvLinAddr = 0;
psMapDevClassMemIN->hDeviceClassBuffer);
psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo = IMG_NULL;
- psMapDevClassMemOUT->psKernelSyncInfo = IMG_NULL;
if(psMemInfo->psKernelSyncInfo)
{
- psMapDevClassMemOUT->psKernelSyncInfo = psMemInfo->psKernelSyncInfo;
-
psMapDevClassMemOUT->sClientSyncInfo.psSyncData =
psMemInfo->psKernelSyncInfo->psSyncData;
psMapDevClassMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
psMapDevClassMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
-
- psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo =
+
+ psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo =
psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
psMapDevClassMemOUT->sClientMemInfo.psClientSyncInfo = &psMapDevClassMemOUT->sClientSyncInfo;
psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo);
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc)
return 0;
}
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
IMG_HANDLE hDevCookieInt;
- IMG_HANDLE hDevMemContextInt;
+ IMG_HANDLE hDevMemContextInt;
PVRSRV_KERNEL_MEM_INFO *psMemInfo;
- IMG_UINT32 ui32PageTableSize = 0;
IMG_SYS_PHYADDR *psSysPAddr = IMG_NULL;
-
+ IMG_UINT32 ui32PageTableSize = 0;
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_WRAP_EXT_MEMORY);
- NEW_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc, 2);
+ NEW_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc, 2)
psWrapExtMemOUT->eError =
}
- psWrapExtMemOUT->eError =
+ psWrapExtMemOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
psWrapExtMemIN->hDevMemContext,
PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
(IMG_VOID **)&psSysPAddr, 0,
"Page Table"));
- if(CopyFromUserWrapper(psPerProc,
+ if(CopyFromUserWrapper(psPerProc,
ui32BridgeID,
psSysPAddr,
psWrapExtMemIN->psSysPAddr,
return -EFAULT;
}
}
-
+
psWrapExtMemOUT->eError =
PVRSRVWrapExtMemoryKM(hDevCookieInt,
psPerProc,
psWrapExtMemIN->bPhysContig,
psSysPAddr,
psWrapExtMemIN->pvLinAddr,
+ psWrapExtMemIN->ui32Flags,
&psMemInfo);
+
if(psWrapExtMemIN->ui32NumPageTableEntries)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
(IMG_VOID *)psSysPAddr, 0);
}
+
if(psWrapExtMemOUT->eError != PVRSRV_OK)
{
return 0;
psWrapExtMemOUT->sClientMemInfo.ui32AllocSize = psMemInfo->ui32AllocSize;
psWrapExtMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
- PVRSRVAllocHandleNR(psPerProc->psHandleBase,
- &psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo,
+ PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+ &psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo,
psMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE);
psWrapExtMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
- psWrapExtMemOUT->sClientSyncInfo.hMappingInfo =
+ psWrapExtMemOUT->sClientSyncInfo.hMappingInfo =
psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
psWrapExtMemOUT->sClientMemInfo.psClientSyncInfo = &psWrapExtMemOUT->sClientSyncInfo;
- PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
- &psWrapExtMemOUT->sClientSyncInfo.hKernelSyncInfo,
+ PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+ &psWrapExtMemOUT->sClientSyncInfo.hKernelSyncInfo,
(IMG_HANDLE)psMemInfo->psKernelSyncInfo,
PVRSRV_HANDLE_TYPE_SYNC_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE,
psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo);
- COMMIT_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc)
return 0;
}
PVR_UNREFERENCED_PARAMETER(psPerProc);
- psGetFreeDeviceMemOUT->eError =
+ psGetFreeDeviceMemOUT->eError =
PVRSRVGetFreeDeviceMemKM(psGetFreeDeviceMemIN->ui32Flags,
&psGetFreeDeviceMemOUT->ui32Total,
&psGetFreeDeviceMemOUT->ui32Free,
&psMMapDataOUT->ui32ByteOffset,
&psMMapDataOUT->ui32RealByteSize,
&psMMapDataOUT->ui32UserVAddr);
-#else
+#else
PVR_UNREFERENCED_PARAMETER(psPerProc);
PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
-#endif
+#endif
return 0;
}
&psMMapDataOUT->ui32RealByteSize,
&psMMapDataOUT->ui32UserVAddr);
#else
+
PVR_UNREFERENCED_PARAMETER(psPerProc);
PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
-#endif
+#endif
return 0;
}
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REG);
- PVR_UNREFERENCED_PARAMETER(psPerProc);
psRetOUT->eError =
- PDumpRegWithFlagsKM(psPDumpRegDumpIN->sHWReg.ui32RegAddr,
- psPDumpRegDumpIN->sHWReg.ui32RegVal,
- psPDumpRegDumpIN->ui32Flags);
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID **)&psDeviceNode,
+ psPDumpRegDumpIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+ if(psRetOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
+ psRetOUT->eError = PDumpRegWithFlagsKM (psPDumpRegDumpIN->szRegRegion,
+ psPDumpRegDumpIN->sHWReg.ui32RegAddr,
+ psPDumpRegDumpIN->sHWReg.ui32RegVal,
+ psPDumpRegDumpIN->ui32Flags);
return 0;
}
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REGPOL);
- PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+ psRetOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID **)&psDeviceNode,
+ psPDumpRegPolIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+ if(psRetOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
psRetOUT->eError =
- PDumpRegPolWithFlagsKM(psPDumpRegPolIN->sHWReg.ui32RegAddr,
+ PDumpRegPolWithFlagsKM(psPDumpRegPolIN->szRegRegion,
+ psPDumpRegPolIN->sHWReg.ui32RegAddr,
psPDumpRegPolIN->sHWReg.ui32RegVal,
psPDumpRegPolIN->ui32Mask,
psPDumpRegPolIN->ui32Flags);
psPDumpMemPolIN->ui32Offset,
psPDumpMemPolIN->ui32Value,
psPDumpMemPolIN->ui32Mask,
- PDUMP_POLL_OPERATOR_EQUAL,
+ psPDumpMemPolIN->eOperator,
psPDumpMemPolIN->ui32Flags,
MAKEUNIQUETAG(pvMemInfo));
return 0;
}
- psRetOUT->eError =
+ psRetOUT->eError =
PDumpMemUM(psPerProc,
psPDumpMemDumpIN->pvAltLinAddr,
psPDumpMemDumpIN->pvLinAddr,
MAKEUNIQUETAG(pvMemInfo));
return 0;
-}
+}
static IMG_INT
PDumpBitmapBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- PVR_UNREFERENCED_PARAMETER(psPerProc);
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_HANDLE hDevMemContextInt;
+
PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
psRetOUT->eError =
- PDumpBitmapKM(&psPDumpBitmapIN->szFileName[0],
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID **)&psDeviceNode,
+ psPDumpBitmapIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+ psRetOUT->eError =
+ PVRSRVLookupHandle( psPerProc->psHandleBase,
+ &hDevMemContextInt,
+ psPDumpBitmapIN->hDevMemContext,
+ PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+ if(psRetOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
+ psRetOUT->eError =
+ PDumpBitmapKM(psDeviceNode,
+ &psPDumpBitmapIN->szFileName[0],
psPDumpBitmapIN->ui32FileOffset,
psPDumpBitmapIN->ui32Width,
psPDumpBitmapIN->ui32Height,
psPDumpBitmapIN->ui32StrideInBytes,
psPDumpBitmapIN->sDevBaseAddr,
+ hDevMemContextInt,
psPDumpBitmapIN->ui32Size,
psPDumpBitmapIN->ePixelFormat,
psPDumpBitmapIN->eMemFormat,
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPREADREG);
- PVR_UNREFERENCED_PARAMETER(psPerProc);
psRetOUT->eError =
- PDumpReadRegKM(&psPDumpReadRegIN->szFileName[0],
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID **)&psDeviceNode,
+ psPDumpReadRegIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+ psRetOUT->eError =
+ PDumpReadRegKM(&psPDumpReadRegIN->szRegRegion[0],
+ &psPDumpReadRegIN->szFileName[0],
psPDumpReadRegIN->ui32FileOffset,
psPDumpReadRegIN->ui32Address,
psPDumpReadRegIN->ui32Size,
return 0;
}
-static IMG_INT
-PDumpPDRegBW(IMG_UINT32 ui32BridgeID,
- PVRSRV_BRIDGE_IN_PDUMP_DUMPPDREG *psPDumpPDRegDumpIN,
- PVRSRV_BRIDGE_RETURN *psRetOUT,
- PVRSRV_PER_PROCESS_DATA *psPerProc)
-{
- PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_PDREG);
- PVR_UNREFERENCED_PARAMETER(psPerProc);
-
- PDumpPDReg(psPDumpPDRegDumpIN->sHWReg.ui32RegAddr,
- psPDumpPDRegDumpIN->sHWReg.ui32RegVal,
- PDUMP_PD_UNIQUETAG);
-
- psRetOUT->eError = PVRSRV_OK;
- return 0;
-}
static IMG_INT
PDumpCycleCountRegReadBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_RETURN *psRetOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ);
- PVR_UNREFERENCED_PARAMETER(psPerProc);
- PDumpCycleCountRegRead(psPDumpCycleCountRegReadIN->ui32RegOffset,
+ psRetOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID **)&psDeviceNode,
+ psPDumpCycleCountRegReadIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+ if(psRetOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
+ PDumpCycleCountRegRead(&psDeviceNode->sDevId,
+ psPDumpCycleCountRegReadIN->ui32RegOffset,
psPDumpCycleCountRegReadIN->bLastFrame);
psRetOUT->eError = PVRSRV_OK;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR);
- psRetOUT->eError =
+ psRetOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase, &pvMemInfo,
psPDumpPDDevPAddrIN->hKernelMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
PVRSRV_ERROR eError;
-
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_MISC_INFO);
OSMemCopy(&psGetMiscInfoOUT->sMiscInfo,
sizeof(PVRSRV_MISC_INFO));
if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) &&
- ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0))
+ ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0) &&
+ ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_FREEMEM_PRESENT) != 0))
{
psGetMiscInfoOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) ||
- ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0))
+ ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0) ||
+ ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_FREEMEM_PRESENT) != 0))
{
ASSIGN_AND_EXIT_ON_ERROR(psGetMiscInfoOUT->eError,
"Output string buffer"));
psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
-
+
eError = CopyToUserWrapper(psPerProc, ui32BridgeID,
psGetMiscInfoIN->sMiscInfo.pszMemoryStr,
psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
(IMG_VOID *)psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0);
psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = IMG_NULL;
-
+
- psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
+ psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
if(eError != PVRSRV_OK)
{
}
if (psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle)
- {
+ {
psGetMiscInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
&psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle,
static IMG_INT
PVRSRVConnectBW(IMG_UINT32 ui32BridgeID,
- IMG_VOID *psBridgeIn,
+ PVRSRV_BRIDGE_IN_CONNECT_SERVICES *psConnectServicesIN,
PVRSRV_BRIDGE_OUT_CONNECT_SERVICES *psConnectServicesOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- PVR_UNREFERENCED_PARAMETER(psBridgeIn);
-
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CONNECT_SERVICES);
+
+#if defined(PDUMP)
+
+ psPerProc->bPDumpPersistent |= ( (psConnectServicesIN->ui32Flags & SRV_FLAGS_PERSIST) != 0) ? IMG_TRUE : IMG_FALSE;
+
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ psPerProc->bPDumpActive |= ( (psConnectServicesIN->ui32Flags & SRV_FLAGS_PDUMP_ACTIVE) != 0) ? IMG_TRUE : IMG_FALSE;
+#endif
+#else
+ PVR_UNREFERENCED_PARAMETER(psConnectServicesIN);
+#endif
psConnectServicesOUT->hKernelServices = psPerProc->hPerProcData;
psConnectServicesOUT->eError = PVRSRV_OK;
{
PVR_UNREFERENCED_PARAMETER(psPerProc);
PVR_UNREFERENCED_PARAMETER(psBridgeIn);
-
+
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DISCONNECT_SERVICES);
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE);
- NEW_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc, 1)
psOpenDispClassDeviceOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &hDevCookieInt,
- psOpenDispClassDeviceIN->hDevCookie,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &hDevCookieInt,
+ psOpenDispClassDeviceIN->hDevCookie,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
{
psOpenDispClassDeviceOUT->eError =
PVRSRVOpenDCDeviceKM(psPerProc,
- psOpenDispClassDeviceIN->ui32DeviceID,
+ psOpenDispClassDeviceIN->ui32DeviceID,
hDevCookieInt,
&hDispClassInfoInt);
return 0;
}
- PVRSRVAllocHandleNR(psPerProc->psHandleBase,
- &psOpenDispClassDeviceOUT->hDeviceKM,
- hDispClassInfoInt,
- PVRSRV_HANDLE_TYPE_DISP_INFO,
+ PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+ &psOpenDispClassDeviceOUT->hDeviceKM,
+ hDispClassInfoInt,
+ PVRSRV_HANDLE_TYPE_DISP_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE);
- COMMIT_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc)
return 0;
-}
+}
static IMG_INT
PVRSRVCloseDCDeviceBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfoInt,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfoInt,
psCloseDispClassDeviceIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
psCloseDispClassDeviceIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
return 0;
-}
+}
static IMG_INT
PVRSRVEnumDCFormatsBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS);
- psEnumDispClassFormatsOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfoInt,
+ psEnumDispClassFormatsOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfoInt,
psEnumDispClassFormatsIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psEnumDispClassFormatsOUT->eError != PVRSRV_OK)
return 0;
}
- psEnumDispClassFormatsOUT->eError =
+ psEnumDispClassFormatsOUT->eError =
PVRSRVEnumDCFormatsKM(pvDispClassInfoInt,
&psEnumDispClassFormatsOUT->ui32Count,
psEnumDispClassFormatsOUT->asFormat);
return 0;
-}
+}
static IMG_INT
PVRSRVEnumDCDimsBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS);
- psEnumDispClassDimsOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfoInt,
- psEnumDispClassDimsIN->hDeviceKM,
+ psEnumDispClassDimsOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfoInt,
+ psEnumDispClassDimsIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psEnumDispClassDimsOUT->eError != PVRSRV_OK)
return 0;
}
- psEnumDispClassDimsOUT->eError =
- PVRSRVEnumDCDimsKM(pvDispClassInfoInt,
- &psEnumDispClassDimsIN->sFormat,
+ psEnumDispClassDimsOUT->eError =
+ PVRSRVEnumDCDimsKM(pvDispClassInfoInt,
+ &psEnumDispClassDimsIN->sFormat,
&psEnumDispClassDimsOUT->ui32Count,
psEnumDispClassDimsOUT->asDim);
return 0;
-}
+}
static IMG_INT
PVRSRVGetDCSystemBufferBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER);
- NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc, 1)
- psGetDispClassSysBufferOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfoInt,
+ psGetDispClassSysBufferOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfoInt,
psGetDispClassSysBufferIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
return 0;
}
- psGetDispClassSysBufferOUT->eError =
- PVRSRVGetDCSystemBufferKM(pvDispClassInfoInt,
+ psGetDispClassSysBufferOUT->eError =
+ PVRSRVGetDCSystemBufferKM(pvDispClassInfoInt,
&hBufferInt);
if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
(PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
psGetDispClassSysBufferIN->hDeviceKM);
- COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc)
return 0;
-}
+}
static IMG_INT
PVRSRVGetDCInfoBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_INFO);
- psGetDispClassInfoOUT->eError =
+ psGetDispClassInfoOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
&pvDispClassInfo,
psGetDispClassInfoIN->hDeviceKM,
&psGetDispClassInfoOUT->sDisplayInfo);
return 0;
-}
+}
static IMG_INT
PVRSRVCreateDCSwapChainBW(IMG_UINT32 ui32BridgeID,
{
IMG_VOID *pvDispClassInfo;
IMG_HANDLE hSwapChainInt;
+ IMG_UINT32 ui32SwapChainID;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN);
- NEW_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc, 1)
- psCreateDispClassSwapChainOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfo,
- psCreateDispClassSwapChainIN->hDeviceKM,
+ psCreateDispClassSwapChainOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfo,
+ psCreateDispClassSwapChainIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
return 0;
}
- psCreateDispClassSwapChainOUT->eError =
- PVRSRVCreateDCSwapChainKM(psPerProc, pvDispClassInfo,
+
+ ui32SwapChainID = psCreateDispClassSwapChainIN->ui32SwapChainID;
+
+ psCreateDispClassSwapChainOUT->eError =
+ PVRSRVCreateDCSwapChainKM(psPerProc, pvDispClassInfo,
psCreateDispClassSwapChainIN->ui32Flags,
&psCreateDispClassSwapChainIN->sDstSurfAttrib,
&psCreateDispClassSwapChainIN->sSrcSurfAttrib,
psCreateDispClassSwapChainIN->ui32BufferCount,
psCreateDispClassSwapChainIN->ui32OEMFlags,
&hSwapChainInt,
- &psCreateDispClassSwapChainOUT->ui32SwapChainID);
+ &ui32SwapChainID);
if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
{
return 0;
}
- PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
- &psCreateDispClassSwapChainOUT->hSwapChain,
+
+ psCreateDispClassSwapChainOUT->ui32SwapChainID = ui32SwapChainID;
+
+ PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+ &psCreateDispClassSwapChainOUT->hSwapChain,
hSwapChainInt,
PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
PVRSRV_HANDLE_ALLOC_FLAG_NONE,
psCreateDispClassSwapChainIN->hDeviceKM);
- COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSwapChain,
- psDestroyDispClassSwapChainIN->hSwapChain,
+ PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSwapChain,
+ psDestroyDispClassSwapChainIN->hSwapChain,
PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
if(psRetOUT->eError != PVRSRV_OK)
{
return 0;
}
- psRetOUT->eError =
+ psRetOUT->eError =
PVRSRVDestroyDCSwapChainKM(pvSwapChain);
if(psRetOUT->eError != PVRSRV_OK)
}
psRetOUT->eError =
- PVRSRVReleaseHandle(psPerProc->psHandleBase,
- psDestroyDispClassSwapChainIN->hSwapChain,
+ PVRSRVReleaseHandle(psPerProc->psHandleBase,
+ psDestroyDispClassSwapChainIN->hSwapChain,
PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
return 0;
-}
+}
static IMG_INT
PVRSRVSetDCDstRectBW(IMG_UINT32 ui32BridgeID,
&psSetDispClassDstRectIN->sRect);
return 0;
-}
+}
static IMG_INT
PVRSRVSetDCSrcRectBW(IMG_UINT32 ui32BridgeID,
&psSetDispClassSrcRectIN->sRect);
return 0;
-}
+}
static IMG_INT
PVRSRVSetDCDstColourKeyBW(IMG_UINT32 ui32BridgeID,
psSetDispClassColKeyIN->ui32CKColour);
return 0;
-}
+}
static IMG_INT
PVRSRVSetDCSrcColourKeyBW(IMG_UINT32 ui32BridgeID,
psRetOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
&pvSwapChain,
- psSetDispClassColKeyIN->hSwapChain,
+ psSetDispClassColKeyIN->hSwapChain,
PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
if(psRetOUT->eError != PVRSRV_OK)
{
psSetDispClassColKeyIN->ui32CKColour);
return 0;
-}
+}
static IMG_INT
PVRSRVGetDCBuffersBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS);
- NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc, PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
+ NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc, PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS)
psGetDispClassBuffersOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
}
psGetDispClassBuffersOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvSwapChain,
- psGetDispClassBuffersIN->hSwapChain,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvSwapChain,
+ psGetDispClassBuffersIN->hSwapChain,
PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
if(psGetDispClassBuffersOUT->eError != PVRSRV_OK)
{
return 0;
}
- psGetDispClassBuffersOUT->eError =
- PVRSRVGetDCBuffersKM(pvDispClassInfo,
+ psGetDispClassBuffersOUT->eError =
+ PVRSRVGetDCBuffersKM(pvDispClassInfo,
pvSwapChain,
&psGetDispClassBuffersOUT->ui32BufferCount,
psGetDispClassBuffersOUT->ahBuffer);
psGetDispClassBuffersOUT->ahBuffer[i] = hBufferExt;
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc)
return 0;
-}
+}
static IMG_INT
PVRSRVSwapToDCBufferBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfo,
- psSwapDispClassBufferIN->hDeviceKM,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfo,
+ psSwapDispClassBufferIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psRetOUT->eError != PVRSRV_OK)
{
}
psRetOUT->eError =
- PVRSRVLookupSubHandle(psPerProc->psHandleBase,
- &pvSwapChainBuf,
- psSwapDispClassBufferIN->hBuffer,
+ PVRSRVLookupSubHandle(psPerProc->psHandleBase,
+ &pvSwapChainBuf,
+ psSwapDispClassBufferIN->hBuffer,
PVRSRV_HANDLE_TYPE_DISP_BUFFER,
psSwapDispClassBufferIN->hDeviceKM);
if(psRetOUT->eError != PVRSRV_OK)
return 0;
}
- psRetOUT->eError =
- PVRSRVSwapToDCBufferKM(pvDispClassInfo,
+ psRetOUT->eError =
+ PVRSRVSwapToDCBufferKM(pvDispClassInfo,
pvSwapChainBuf,
psSwapDispClassBufferIN->ui32SwapInterval,
psSwapDispClassBufferIN->hPrivateTag,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvDispClassInfo,
- psSwapDispClassSystemIN->hDeviceKM,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvDispClassInfo,
+ psSwapDispClassSystemIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_DISP_INFO);
if(psRetOUT->eError != PVRSRV_OK)
{
{
return 0;
}
- psRetOUT->eError =
- PVRSRVSwapToDCSystemKM(pvDispClassInfo,
+ psRetOUT->eError =
+ PVRSRVSwapToDCSystemKM(pvDispClassInfo,
pvSwapChain);
return 0;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE);
- NEW_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc, 1)
psOpenBufferClassDeviceOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
return 0;
}
- psOpenBufferClassDeviceOUT->eError =
+ psOpenBufferClassDeviceOUT->eError =
PVRSRVOpenBCDeviceKM(psPerProc,
psOpenBufferClassDeviceIN->ui32DeviceID,
hDevCookieInt,
PVRSRV_HANDLE_TYPE_BUF_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE);
- COMMIT_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvBufClassInfo,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvBufClassInfo,
psCloseBufferClassDeviceIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_BUF_INFO);
if(psRetOUT->eError != PVRSRV_OK)
return 0;
}
- psRetOUT->eError =
+ psRetOUT->eError =
PVRSRVCloseBCDeviceKM(pvBufClassInfo, IMG_FALSE);
if(psRetOUT->eError != PVRSRV_OK)
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO);
psGetBufferClassInfoOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvBufClassInfo,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvBufClassInfo,
psGetBufferClassInfoIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_BUF_INFO);
if(psGetBufferClassInfoOUT->eError != PVRSRV_OK)
}
psGetBufferClassInfoOUT->eError =
- PVRSRVGetBCInfoKM(pvBufClassInfo,
+ PVRSRVGetBCInfoKM(pvBufClassInfo,
&psGetBufferClassInfoOUT->sBufferInfo);
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER);
- NEW_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc, 1)
psGetBufferClassBufferOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase,
- &pvBufClassInfo,
- psGetBufferClassBufferIN->hDeviceKM,
+ PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &pvBufClassInfo,
+ psGetBufferClassBufferIN->hDeviceKM,
PVRSRV_HANDLE_TYPE_BUF_INFO);
if(psGetBufferClassBufferOUT->eError != PVRSRV_OK)
{
return 0;
}
- psGetBufferClassBufferOUT->eError =
- PVRSRVGetBCBufferKM(pvBufClassInfo,
+ psGetBufferClassBufferOUT->eError =
+ PVRSRVGetBCBufferKM(pvBufClassInfo,
psGetBufferClassBufferIN->ui32BufferIndex,
&hBufferInt);
(PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
psGetBufferClassBufferIN->hDeviceKM);
- COMMIT_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM);
- NEW_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc, 1)
psAllocSharedSysMemOUT->eError =
PVRSRVAllocSharedSysMemoryKM(psPerProc,
psAllocSharedSysMemOUT->sClientMemInfo.ui32Flags =
psKernelMemInfo->ui32Flags;
psAllocSharedSysMemOUT->sClientMemInfo.ui32AllocSize =
- psKernelMemInfo->ui32AllocSize;
+ psKernelMemInfo->ui32AllocSize;
psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
PVRSRVAllocHandleNR(psPerProc->psHandleBase,
PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
PVRSRV_HANDLE_ALLOC_FLAG_NONE);
- COMMIT_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc)
return 0;
}
if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
return 0;
-
+
psFreeSharedSysMemOUT->eError =
PVRSRVFreeSharedSysMemoryKM(psKernelMemInfo);
if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
IMG_HANDLE hParent;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_MEMINFO_MEM);
- NEW_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc, 2);
+ NEW_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc, 2)
psMapMemInfoMemOUT->eError =
PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
#endif
break;
default:
- psMapMemInfoMemOUT->eError = PVRSRV_ERROR_GENERIC;
+ psMapMemInfoMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
return 0;
}
psMapMemInfoMemOUT->sClientMemInfo.ui32Flags =
psKernelMemInfo->ui32Flags;
psMapMemInfoMemOUT->sClientMemInfo.ui32AllocSize =
- psKernelMemInfo->ui32AllocSize;
+ psKernelMemInfo->ui32AllocSize;
psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
OSMemSet(&psMapMemInfoMemOUT->sClientSyncInfo,
0,
sizeof (PVRSRV_CLIENT_SYNC_INFO));
- psMapMemInfoMemOUT->psKernelSyncInfo = IMG_NULL;
}
else
{
psMapMemInfoMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
psKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
- psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo =
+ psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo =
psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
psMapMemInfoMemOUT->sClientMemInfo.psClientSyncInfo = &psMapMemInfoMemOUT->sClientSyncInfo;
psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo);
}
- COMMIT_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc)
return 0;
}
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR);
- psGetMmuPDDevPAddrOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+ psGetMmuPDDevPAddrOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
psGetMmuPDDevPAddrIN->hDevMemContext,
PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
if(psGetMmuPDDevPAddrOUT->eError != PVRSRV_OK)
return 0;
}
- psGetMmuPDDevPAddrOUT->sPDDevPAddr =
+ psGetMmuPDDevPAddrOUT->sPDDevPAddr =
BM_GetDeviceNode(hDevMemContextInt)->pfnMMUGetPDDevPAddr(BM_GetMMUContextFromMemContext(hDevMemContextInt));
if(psGetMmuPDDevPAddrOUT->sPDDevPAddr.uiAddr)
{
}
else
{
- psGetMmuPDDevPAddrOUT->eError = PVRSRV_ERROR_GENERIC;
+ psGetMmuPDDevPAddrOUT->eError = PVRSRV_ERROR_INVALID_PHYS_ADDR;
}
return 0;
}
IMG_VOID *psBridgeOut,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
-#if !defined(DEBUG_PVR)
+#if !defined(DEBUG)
PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
#endif
PVR_UNREFERENCED_PARAMETER(psBridgeIn);
PVR_UNREFERENCED_PARAMETER(psPerProc);
#if defined(DEBUG_BRIDGE_KM)
- PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %lu (%s) mapped to "
+ PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %u (%s) mapped to "
"Dummy Wrapper (probably not what you want!)",
__FUNCTION__, ui32BridgeID, g_BridgeDispatchTable[ui32BridgeID].pszIOCName));
#else
- PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %lu mapped to "
+ PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %u mapped to "
"Dummy Wrapper (probably not what you want!)",
__FUNCTION__, ui32BridgeID));
#endif
const IMG_CHAR *pszFunctionName)
{
static IMG_UINT32 ui32PrevIndex = ~0UL;
-#if !defined(DEBUG_PVR)
+#if !defined(DEBUG)
PVR_UNREFERENCED_PARAMETER(pszIOCName);
#endif
#if !defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE) && !defined(DEBUG_BRIDGE_KM)
__FUNCTION__, pszIOCName, g_BridgeDispatchTable[ui32Index].pszIOCName));
#else
PVR_DPF((PVR_DBG_ERROR,
- "%s: BUG!: Adding dispatch table entry for %s clobbers an existing entry (index=%lu)",
+ "%s: BUG!: Adding dispatch table entry for %s clobbers an existing entry (index=%u)",
__FUNCTION__, pszIOCName, ui32Index));
#endif
- PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue.",
- __FUNCTION__));
+ PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue."));
}
{
#if defined(DEBUG_BRIDGE_KM)
PVR_DPF((PVR_DBG_WARNING,
- "%s: There is a gap in the dispatch table between indices %lu (%s) and %lu (%s)",
+ "%s: There is a gap in the dispatch table between indices %u (%s) and %u (%s)",
__FUNCTION__, ui32PrevIndex, g_BridgeDispatchTable[ui32PrevIndex].pszIOCName,
ui32Index, pszIOCName));
#else
"%s: There is a gap in the dispatch table between indices %u and %u (%s)",
__FUNCTION__, (IMG_UINT)ui32PrevIndex, (IMG_UINT)ui32Index, pszIOCName));
#endif
- PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue.",
- __FUNCTION__));
+ PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue."));
}
g_BridgeDispatchTable[ui32Index].pfFunction = pfFunction;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_CONNECT);
PVR_UNREFERENCED_PARAMETER(psBridgeIn);
- if(!OSProcHasPrivSrvInit() || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
+
+ if((OSProcHasPrivSrvInit() == IMG_FALSE) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
{
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_SRV_CONNECT_FAILED;
return 0;
}
if(!psPerProc->bInitProcess)
{
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_SRV_DISCONNECT_FAILED;
return 0;
}
psPerProc->bInitProcess = IMG_FALSE;
-
+
PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_FALSE);
PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RAN, IMG_TRUE);
psRetOUT->eError = PVRSRVFinaliseSystem(psInitSrvDisconnectIN->bInitSuccesful);
- PVRSRVSetInitServerState( PVRSRV_INIT_SERVER_SUCCESSFUL,
- (((psRetOUT->eError == PVRSRV_OK) && (psInitSrvDisconnectIN->bInitSuccesful)))
+ PVRSRVSetInitServerState( PVRSRV_INIT_SERVER_SUCCESSFUL ,
+ ((psRetOUT->eError == PVRSRV_OK) && (psInitSrvDisconnectIN->bInitSuccesful))
? IMG_TRUE : IMG_FALSE);
return 0;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_OPEN);
- NEW_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc, 1);
+ NEW_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc, 1)
psEventObjectOpenOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
- &psEventObjectOpenIN->sEventObject.hOSEventKM,
- psEventObjectOpenIN->sEventObject.hOSEventKM,
+ &psEventObjectOpenIN->sEventObject.hOSEventKM,
+ psEventObjectOpenIN->sEventObject.hOSEventKM,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
if(psEventObjectOpenOUT->eError != PVRSRV_OK)
&psEventObjectOpenOUT->hOSEvent,
psEventObjectOpenOUT->hOSEvent,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
- PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
+ PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
- COMMIT_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc);
+ COMMIT_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc)
return 0;
}
IMG_HANDLE hOSEventKM;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE);
-
+
psRetOUT->eError =
PVRSRVLookupHandle(psPerProc->psHandleBase,
- &psEventObjectCloseIN->sEventObject.hOSEventKM,
- psEventObjectCloseIN->sEventObject.hOSEventKM,
+ &psEventObjectCloseIN->sEventObject.hOSEventKM,
+ psEventObjectCloseIN->sEventObject.hOSEventKM,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
if(psRetOUT->eError != PVRSRV_OK)
{
return 0;
}
- psRetOUT->eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
- &hOSEventKM,
- psEventObjectCloseIN->hOSEventKM,
+ psRetOUT->eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+ &hOSEventKM,
+ psEventObjectCloseIN->hOSEventKM,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
if(psRetOUT->eError != PVRSRV_OK)
typedef struct _MODIFY_SYNC_OP_INFO
{
+ IMG_HANDLE hResItem;
PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
IMG_UINT32 ui32ModifyFlags;
IMG_UINT32 ui32ReadOpsPendingSnapShot;
} MODIFY_SYNC_OP_INFO;
-static PVRSRV_ERROR ModifyCompleteSyncOpsCallBack(IMG_PVOID pvParam,
- IMG_UINT32 ui32Param)
+static PVRSRV_ERROR DoQuerySyncOpsSatisfied(MODIFY_SYNC_OP_INFO *psModSyncOpInfo)
{
- MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
- PVR_UNREFERENCED_PARAMETER(ui32Param);
-
- if (!pvParam)
+ psKernelSyncInfo = psModSyncOpInfo->psKernelSyncInfo;
+
+ if (!psKernelSyncInfo)
{
- PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: invalid parameter"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
-
- psModSyncOpInfo = (MODIFY_SYNC_OP_INFO*)pvParam;
+
+ if((psModSyncOpInfo->ui32WriteOpsPendingSnapShot == psKernelSyncInfo->psSyncData->ui32WriteOpsComplete)
+ && (psModSyncOpInfo->ui32ReadOpsPendingSnapShot == psKernelSyncInfo->psSyncData->ui32ReadOpsComplete))
+ {
+#if defined(PDUMP)
+
+
+
+ PDumpComment("Poll for read ops complete to reach value (%u)", psModSyncOpInfo->ui32ReadOpsPendingSnapShot);
+ PDumpMemPolKM(psKernelSyncInfo->psSyncDataMemInfoKM,
+ offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+ psModSyncOpInfo->ui32ReadOpsPendingSnapShot,
+ 0xFFFFFFFF,
+ PDUMP_POLL_OPERATOR_EQUAL,
+ 0,
+ MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
+
+
+ PDumpComment("Poll for write ops complete to reach value (%u)", psModSyncOpInfo->ui32WriteOpsPendingSnapShot);
+ PDumpMemPolKM(psKernelSyncInfo->psSyncDataMemInfoKM,
+ offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+ psModSyncOpInfo->ui32WriteOpsPendingSnapShot,
+ 0xFFFFFFFF,
+ PDUMP_POLL_OPERATOR_EQUAL,
+ 0,
+ MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
+#endif
+ return PVRSRV_OK;
+ }
+ else
+ {
+ return PVRSRV_ERROR_RETRY;
+ }
+}
+
+static PVRSRV_ERROR DoModifyCompleteSyncOps(MODIFY_SYNC_OP_INFO *psModSyncOpInfo)
+{
+ PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+
psKernelSyncInfo = psModSyncOpInfo->psKernelSyncInfo;
- LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+ if (!psKernelSyncInfo)
{
- if((psModSyncOpInfo->ui32WriteOpsPendingSnapShot == psKernelSyncInfo->psSyncData->ui32WriteOpsComplete)
- && (psModSyncOpInfo->ui32ReadOpsPendingSnapShot == psKernelSyncInfo->psSyncData->ui32ReadOpsComplete))
- {
- goto OpFlushedComplete;
- }
- PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: waiting for old Ops to flush"));
- OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
- } END_LOOP_UNTIL_TIMEOUT();
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
- PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: waiting for old Ops to flush timed out"));
- return PVRSRV_ERROR_TIMEOUT;
-
-OpFlushedComplete:
+ if((psModSyncOpInfo->ui32WriteOpsPendingSnapShot != psKernelSyncInfo->psSyncData->ui32WriteOpsComplete)
+ || (psModSyncOpInfo->ui32ReadOpsPendingSnapShot != psKernelSyncInfo->psSyncData->ui32ReadOpsComplete))
+ {
+ return PVRSRV_ERROR_BAD_SYNC_STATE;
+ }
if(psModSyncOpInfo->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC)
{
psKernelSyncInfo->psSyncData->ui32WriteOpsComplete++;
}
-
+
if(psModSyncOpInfo->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC)
{
psKernelSyncInfo->psSyncData->ui32ReadOpsComplete++;
}
+
+ return PVRSRV_OK;
+}
+
+
+static PVRSRV_ERROR ModifyCompleteSyncOpsCallBack(IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param)
+{
+ MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
+
+ PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+ if (!pvParam)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: invalid parameter"));
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ psModSyncOpInfo = (MODIFY_SYNC_OP_INFO*)pvParam;
+
+ if (psModSyncOpInfo->psKernelSyncInfo)
+ {
+
+ LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+ {
+ if (DoQuerySyncOpsSatisfied(psModSyncOpInfo) == PVRSRV_OK)
+ {
+ goto OpFlushedComplete;
+ }
+ PVR_DPF((PVR_DBG_WARNING, "ModifyCompleteSyncOpsCallBack: waiting for current Ops to flush"));
+ OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+ } END_LOOP_UNTIL_TIMEOUT();
+
+ PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: timeout whilst waiting for current Ops to flush."));
+ PVR_DPF((PVR_DBG_ERROR, " Write ops pending snapshot = %d, write ops complete = %d",
+ psModSyncOpInfo->ui32WriteOpsPendingSnapShot,
+ psModSyncOpInfo->psKernelSyncInfo->psSyncData->ui32WriteOpsComplete));
+ PVR_DPF((PVR_DBG_ERROR, " Read ops pending snapshot = %d, write ops complete = %d",
+ psModSyncOpInfo->ui32ReadOpsPendingSnapShot,
+ psModSyncOpInfo->psKernelSyncInfo->psSyncData->ui32ReadOpsComplete));
+
+ return PVRSRV_ERROR_TIMEOUT;
+
+ OpFlushedComplete:
+ DoModifyCompleteSyncOps(psModSyncOpInfo);
+ }
+
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(MODIFY_SYNC_OP_INFO), (IMG_VOID *)psModSyncOpInfo, 0);
-
- PVRSRVCommandCompleteCallbacks();
+ PVRSRVScheduleDeviceCallbacks();
+
return PVRSRV_OK;
}
+static IMG_INT
+PVRSRVCreateSyncInfoModObjBW(IMG_UINT32 ui32BridgeID,
+ IMG_VOID *psBridgeIn,
+ PVRSRV_BRIDGE_OUT_CREATE_SYNC_INFO_MOD_OBJ *psCreateSyncInfoModObjOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
+
+ PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_SYNC_INFO_MOD_OBJ);
+
+ NEW_HANDLE_BATCH_OR_ERROR(psCreateSyncInfoModObjOUT->eError, psPerProc, 1)
+
+ ASSIGN_AND_EXIT_ON_ERROR(psCreateSyncInfoModObjOUT->eError,
+ OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(MODIFY_SYNC_OP_INFO),
+ (IMG_VOID **)&psModSyncOpInfo, 0,
+ "ModSyncOpInfo (MODIFY_SYNC_OP_INFO)"));
+
+ psModSyncOpInfo->psKernelSyncInfo = IMG_NULL;
+
+ psCreateSyncInfoModObjOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
+ &psCreateSyncInfoModObjOUT->hKernelSyncInfoModObj,
+ psModSyncOpInfo,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ,
+ PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE);
+
+ if (psCreateSyncInfoModObjOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
+ psModSyncOpInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+ RESMAN_TYPE_MODIFY_SYNC_OPS,
+ psModSyncOpInfo,
+ 0,
+ &ModifyCompleteSyncOpsCallBack);
+
+ COMMIT_HANDLE_BATCH_OR_ERROR(psCreateSyncInfoModObjOUT->eError, psPerProc)
+
+ return 0;
+}
+
+
+static IMG_INT
+PVRSRVDestroySyncInfoModObjBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_DESTROY_SYNC_INFO_MOD_OBJ *psDestroySyncInfoModObjIN,
+ PVRSRV_BRIDGE_RETURN *psDestroySyncInfoModObjOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_SYNC_INFO_MOD_OBJ);
+
+ psDestroySyncInfoModObjOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID**)&psModSyncOpInfo,
+ psDestroySyncInfoModObjIN->hKernelSyncInfoModObj,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
+ if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: PVRSRVLookupHandle failed"));
+ return 0;
+ }
+
+ if(psModSyncOpInfo->psKernelSyncInfo != IMG_NULL)
+ {
+
+ psDestroySyncInfoModObjOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+ return 0;
+ }
+
+ psDestroySyncInfoModObjOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+ psDestroySyncInfoModObjIN->hKernelSyncInfoModObj,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
+
+ if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: PVRSRVReleaseHandle failed"));
+ return 0;
+ }
+
+ psDestroySyncInfoModObjOUT->eError = ResManFreeResByPtr(psModSyncOpInfo->hResItem);
+ if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: ResManFreeResByPtr failed"));
+ return 0;
+ }
+
+ return 0;
+}
+
+
static IMG_INT
PVRSRVModifyPendingSyncOpsBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_MODIFY_PENDING_SYNC_OPS *psModifySyncOpsIN,
PVRSRV_BRIDGE_OUT_MODIFY_PENDING_SYNC_OPS *psModifySyncOpsOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- IMG_HANDLE hKernelSyncInfo;
PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS);
psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
- &hKernelSyncInfo,
+ (IMG_VOID**)&psModSyncOpInfo,
+ psModifySyncOpsIN->hKernelSyncInfoModObj,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
+ if (psModifySyncOpsOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
+ return 0;
+ }
+
+ psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID**)&psKernelSyncInfo,
psModifySyncOpsIN->hKernelSyncInfo,
PVRSRV_HANDLE_TYPE_SYNC_INFO);
if (psModifySyncOpsOUT->eError != PVRSRV_OK)
return 0;
}
- psKernelSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)hKernelSyncInfo;
-
- if(psKernelSyncInfo->hResItem != IMG_NULL)
+ if(psModSyncOpInfo->psKernelSyncInfo)
{
psModifySyncOpsOUT->eError = PVRSRV_ERROR_RETRY;
+ PVR_DPF((PVR_DBG_VERBOSE, "PVRSRVModifyPendingSyncOpsBW: SyncInfo Modification object is not empty"));
return 0;
}
- ASSIGN_AND_EXIT_ON_ERROR(psModifySyncOpsOUT->eError,
- OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- sizeof(MODIFY_SYNC_OP_INFO),
- (IMG_VOID **)&psModSyncOpInfo, 0,
- "ModSyncOpInfo (MODIFY_SYNC_OP_INFO)"));
-
psModSyncOpInfo->psKernelSyncInfo = psKernelSyncInfo;
psModSyncOpInfo->ui32ModifyFlags = psModifySyncOpsIN->ui32ModifyFlags;
psModSyncOpInfo->ui32ReadOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
psModSyncOpInfo->ui32WriteOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
-
+
psModifySyncOpsOUT->ui32ReadOpsPending = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
psKernelSyncInfo->psSyncData->ui32ReadOpsPending++;
}
- psKernelSyncInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
- RESMAN_TYPE_MODIFY_SYNC_OPS,
- psModSyncOpInfo,
- 0,
- ModifyCompleteSyncOpsCallBack);
+
+ psModifySyncOpsOUT->eError = ResManDissociateRes(psModSyncOpInfo->hResItem,
+ psPerProc->hResManContext);
+
+ if (psModifySyncOpsOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
+ return 0;
+ }
+
return 0;
}
PVRSRV_BRIDGE_RETURN *psModifySyncOpsOUT,
PVRSRV_PER_PROCESS_DATA *psPerProc)
{
- PVRSRV_ERROR eError;
- PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+ MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS);
psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
- (IMG_VOID**)&psKernelSyncInfo,
- psModifySyncOpsIN->hKernelSyncInfo,
- PVRSRV_HANDLE_TYPE_SYNC_INFO);
+ (IMG_VOID**)&psModSyncOpInfo,
+ psModifySyncOpsIN->hKernelSyncInfoModObj,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
if (psModifySyncOpsOUT->eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyCompleteSyncOpsBW: PVRSRVLookupHandle failed"));
return 0;
}
- if(psKernelSyncInfo->hResItem == IMG_NULL)
+ if(psModSyncOpInfo->psKernelSyncInfo == IMG_NULL)
{
psModifySyncOpsOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
return 0;
}
+ psModifySyncOpsOUT->eError = DoModifyCompleteSyncOps(psModSyncOpInfo);
+
+ if (psModifySyncOpsOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyCompleteSyncOpsBW: DoModifyCompleteSyncOps failed"));
+ return 0;
+ }
+
+ psModSyncOpInfo->psKernelSyncInfo = IMG_NULL;
+
+
+ PVRSRVScheduleDeviceCallbacks();
+
+ return 0;
+}
+
+
+static IMG_INT
+PVRSRVSyncOpsFlushToModObjBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_MOD_OBJ *psSyncOpsFlushToModObjIN,
+ PVRSRV_BRIDGE_RETURN *psSyncOpsFlushToModObjOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ MODIFY_SYNC_OP_INFO *psModSyncOpInfo;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_MOD_OBJ);
+
+ psSyncOpsFlushToModObjOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID**)&psModSyncOpInfo,
+ psSyncOpsFlushToModObjIN->hKernelSyncInfoModObj,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
+ if (psSyncOpsFlushToModObjOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToModObjBW: PVRSRVLookupHandle failed"));
+ return 0;
+ }
+
+ if(psModSyncOpInfo->psKernelSyncInfo == IMG_NULL)
+ {
+
+ psSyncOpsFlushToModObjOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+ return 0;
+ }
+
+ psSyncOpsFlushToModObjOUT->eError = DoQuerySyncOpsSatisfied(psModSyncOpInfo);
+
+ if (psSyncOpsFlushToModObjOUT->eError != PVRSRV_OK && psSyncOpsFlushToModObjOUT->eError != PVRSRV_ERROR_RETRY)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToModObjBW: DoQuerySyncOpsSatisfied failed"));
+ return 0;
+ }
+
+ return 0;
+}
+
+
+static IMG_INT
+PVRSRVSyncOpsFlushToDeltaBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_DELTA *psSyncOpsFlushToDeltaIN,
+ PVRSRV_BRIDGE_RETURN *psSyncOpsFlushToDeltaOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+ IMG_UINT32 ui32DeltaRead;
+ IMG_UINT32 ui32DeltaWrite;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_DELTA);
+
+ psSyncOpsFlushToDeltaOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID**)&psSyncInfo,
+ psSyncOpsFlushToDeltaIN->hKernelSyncInfo,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO);
+ if (psSyncOpsFlushToDeltaOUT->eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToDeltaBW: PVRSRVLookupHandle failed"));
+ return 0;
+ }
+
+ ui32DeltaRead = psSyncInfo->psSyncData->ui32ReadOpsPending - psSyncInfo->psSyncData->ui32ReadOpsComplete;
+ ui32DeltaWrite = psSyncInfo->psSyncData->ui32WriteOpsPending - psSyncInfo->psSyncData->ui32WriteOpsComplete;
+
+ if (ui32DeltaRead <= psSyncOpsFlushToDeltaIN->ui32Delta && ui32DeltaWrite <= psSyncOpsFlushToDeltaIN->ui32Delta)
+ {
+#if defined(PDUMP)
+ IMG_UINT32 ui32MinimumReadOpsComplete;
+
+ ui32MinimumReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
+ if (ui32MinimumReadOpsComplete < psSyncOpsFlushToDeltaIN->ui32Delta)
+ {
+ ui32MinimumReadOpsComplete = 0;
+ }
+ else
+ {
+ ui32MinimumReadOpsComplete = ui32MinimumReadOpsComplete - psSyncOpsFlushToDeltaIN->ui32Delta;
+ }
+
+
+ PDumpComment("Poll for read ops complete to delta (%u)",
+ psSyncOpsFlushToDeltaIN->ui32Delta);
+ psSyncOpsFlushToDeltaOUT->eError =
+ PDumpMemPolKM(psSyncInfo->psSyncDataMemInfoKM,
+ offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+ psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+ 0xFFFFFFFF,
+ PDUMP_POLL_OPERATOR_GREATEREQUAL,
+ 0,
+ MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+
+
+ PDumpComment("Poll for write ops complete to delta (%u)",
+ psSyncOpsFlushToDeltaIN->ui32Delta);
+ psSyncOpsFlushToDeltaOUT->eError =
+ PDumpMemPolKM(psSyncInfo->psSyncDataMemInfoKM,
+ offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+ psSyncInfo->psSyncData->ui32LastOpDumpVal,
+ 0xFFFFFFFF,
+ PDUMP_POLL_OPERATOR_GREATEREQUAL,
+ 0,
+ MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+#endif
+
+ psSyncOpsFlushToDeltaOUT->eError = PVRSRV_OK;
+ }
+ else
+ {
+ psSyncOpsFlushToDeltaOUT->eError = PVRSRV_ERROR_RETRY;
+ }
+
+ return 0;
+}
+
+
+static PVRSRV_ERROR
+FreeSyncInfoCallback(IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param)
+{
+ PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+ PVRSRV_ERROR eError;
+
+ PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)pvParam;
+
+ eError = PVRSRVFreeSyncInfoKM(psSyncInfo);
+ if (eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+
+ return PVRSRV_OK;
+}
+
+
+static IMG_INT
+PVRSRVAllocSyncInfoBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_ALLOC_SYNC_INFO *psAllocSyncInfoIN,
+ PVRSRV_BRIDGE_OUT_ALLOC_SYNC_INFO *psAllocSyncInfoOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+ PVRSRV_ERROR eError;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_HANDLE hDevMemContext;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_SYNC_INFO);
+
+ NEW_HANDLE_BATCH_OR_ERROR(psAllocSyncInfoOUT->eError, psPerProc, 1)
+
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_HANDLE *)&psDeviceNode,
+ psAllocSyncInfoIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+ if(eError != PVRSRV_OK)
+ {
+ goto allocsyncinfo_errorexit;
+ }
+
+ hDevMemContext = psDeviceNode->sDevMemoryInfo.pBMKernelContext;
+
+ eError = PVRSRVAllocSyncInfoKM(psDeviceNode,
+ hDevMemContext,
+ &psSyncInfo);
+
+ if (eError != PVRSRV_OK)
+ {
+ goto allocsyncinfo_errorexit;
+ }
+
+ eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
+ &psAllocSyncInfoOUT->hKernelSyncInfo,
+ psSyncInfo,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO,
+ PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE);
+
+ if(eError != PVRSRV_OK)
+ {
+ goto allocsyncinfo_errorexit_freesyncinfo;
+ }
+
+ psSyncInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+ RESMAN_TYPE_SYNC_INFO,
+ psSyncInfo,
+ 0,
+ FreeSyncInfoCallback);
+
+
+ goto allocsyncinfo_commit;
+
+ allocsyncinfo_errorexit_freesyncinfo:
+ PVRSRVFreeSyncInfoKM(psSyncInfo);
+ allocsyncinfo_errorexit:
+
+ allocsyncinfo_commit:
+ psAllocSyncInfoOUT->eError = eError;
+ COMMIT_HANDLE_BATCH_OR_ERROR(eError, psPerProc);
+
+ return 0;
+}
+static IMG_INT
+PVRSRVFreeSyncInfoBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_FREE_SYNC_INFO *psFreeSyncInfoIN,
+ PVRSRV_BRIDGE_RETURN *psFreeSyncInfoOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+ PVRSRV_ERROR eError;
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_SYNC_INFO);
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_VOID**)&psSyncInfo,
+ psFreeSyncInfoIN->hKernelSyncInfo,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: PVRSRVLookupHandle failed"));
+ psFreeSyncInfoOUT->eError = eError;
+ return 0;
+ }
+ eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+ psFreeSyncInfoIN->hKernelSyncInfo,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO);
- eError = ResManFreeResByPtr(psKernelSyncInfo->hResItem);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyCompleteSyncOpsBW: ResManFreeResByPtr failed"));
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: PVRSRVReleaseHandle failed"));
+ psFreeSyncInfoOUT->eError = eError;
return 0;
}
- psKernelSyncInfo->hResItem = IMG_NULL;
+ eError = ResManFreeResByPtr(psSyncInfo->hResItem);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: ResManFreeResByPtr failed"));
+ psFreeSyncInfoOUT->eError = eError;
+ return 0;
+ }
return 0;
}
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SYNCPOL, PDumpSyncPolBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPSYNC, PDumpSyncDumpBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DRIVERINFO, PDumpDriverInfoBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_PDREG, PDumpPDRegBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR, PDumpPDDevPAddrBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ, PDumpCycleCountRegReadBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STARTINITPHASE, PDumpStartInitPhaseBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR, MMU_GetPDDevPAddrBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_CONNECT, PVRSRVInitSrvConnectBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_DISCONNECT, PVRSRVInitSrvDisconnectBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_CONNECT, &PVRSRVInitSrvConnectBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_DISCONNECT, &PVRSRVInitSrvDisconnectBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_WAIT, PVRSRVEventObjectWaitBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_OPEN, PVRSRVEventObjectOpenBW);
- SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE, PVRSRVEventObjectCloseBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_WAIT, &PVRSRVEventObjectWaitBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_OPEN, &PVRSRVEventObjectOpenBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE, &PVRSRVEventObjectCloseBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_SYNC_INFO_MOD_OBJ, PVRSRVCreateSyncInfoModObjBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_SYNC_INFO_MOD_OBJ, PVRSRVDestroySyncInfoModObjBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS, PVRSRVModifyPendingSyncOpsBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS, PVRSRVModifyCompleteSyncOpsBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_MOD_OBJ, PVRSRVSyncOpsFlushToModObjBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_DELTA, PVRSRVSyncOpsFlushToDeltaBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_SYNC_INFO, PVRSRVAllocSyncInfoBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_SYNC_INFO, PVRSRVFreeSyncInfoBW);
#if defined (SUPPORT_SGX)
SetSGXDispatchTableEntry();
{
if(!g_BridgeDispatchTable[i].pfFunction)
{
- g_BridgeDispatchTable[i].pfFunction = DummyBW;
+ g_BridgeDispatchTable[i].pfFunction = &DummyBW;
#if defined(DEBUG_BRIDGE_KM)
g_BridgeDispatchTable[i].pszIOCName = "_PVRSRV_BRIDGE_DUMMY";
g_BridgeDispatchTable[i].pszFunctionName = "DummyBW";
return PVRSRV_OK;
}
-
IMG_INT BridgedDispatchKM(PVRSRV_PER_PROCESS_DATA * psPerProc,
PVRSRV_BRIDGE_PACKAGE * psBridgePackageKM)
{
psBridgeIn = ((ENV_DATA *)psSysData->pvEnvSpecificData)->pvBridgeData;
psBridgeOut = (IMG_PVOID)((IMG_PBYTE)psBridgeIn + PVRSRV_MAX_BRIDGE_IN_SIZE);
+
+#if defined(DEBUG)
+ PVR_ASSERT(psBridgePackageKM->ui32InBufferSize < PVRSRV_MAX_BRIDGE_IN_SIZE);
+ PVR_ASSERT(psBridgePackageKM->ui32OutBufferSize < PVRSRV_MAX_BRIDGE_OUT_SIZE);
+#endif
+
if(psBridgePackageKM->ui32InBufferSize > 0)
{
if(!OSAccessOK(PVR_VERIFY_READ,
}
-#if defined(__linux__)
+#if defined(__linux__)
- if(CopyToUserWrapper(psPerProc,
+ if(CopyToUserWrapper(psPerProc,
ui32BridgeID,
psBridgePackageKM->pvParamOut,
psBridgeOut,
#if defined(__linux__)
#define PVRSRV_GET_BRIDGE_ID(X) _IOC_NR(X)
#else
-#define PVRSRV_GET_BRIDGE_ID(X) (X - PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST))
+#define PVRSRV_GET_BRIDGE_ID(X) ((X) - PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST))
#endif
#ifndef ENOMEM
{ \
return (res); \
} \
- } while (error != PVRSRV_OK)
+ } while ((error) != PVRSRV_OK);
#define ASSIGN_AND_EXIT_ON_ERROR(error, src) \
ASSIGN_AND_RETURN_ON_ERROR(error, src, 0)
const IMG_CHAR *pszFunctionName);
+
#define SetDispatchTableEntry(ui32Index, pfFunction) \
_SetDispatchTableEntry(PVRSRV_GET_BRIDGE_ID(ui32Index), #ui32Index, (BridgeWrapperFunction)pfFunction, #pfFunction)
{
goto PVRSRV_BRIDGE_SGX_DOKICK_RETURN_RESULT;
}
-
+
}
psRetOUT->eError =
return -EFAULT;
}
-#ifdef SUPPORT_SGX_HWPERF
- if (sMiscInfo.eRequest == SGX_MISC_INFO_REQUEST_HWPERF_RETRIEVE_CB)
- {
-
- IMG_VOID * pAllocated;
- IMG_HANDLE hAllocatedHandle;
- IMG_VOID * psTmpUserData;
- IMG_UINT32 allocatedSize;
-
- allocatedSize = (IMG_UINT32)(sMiscInfo.uData.sRetrieveCB.ui32ArraySize * sizeof(PVRSRV_SGX_HWPERF_CBDATA));
-
- ASSIGN_AND_EXIT_ON_ERROR(psRetOUT->eError,
- OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- allocatedSize,
- &pAllocated,
- &hAllocatedHandle,
- "Array of Hardware Performance Circular Buffer Data"));
-
-
- psTmpUserData = sMiscInfo.uData.sRetrieveCB.psHWPerfData;
- sMiscInfo.uData.sRetrieveCB.psHWPerfData = pAllocated;
-
- psRetOUT->eError = SGXGetMiscInfoKM(psDevInfo, &sMiscInfo, psDeviceNode, 0);
- if (psRetOUT->eError != PVRSRV_OK)
- {
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- allocatedSize,
- pAllocated,
- hAllocatedHandle);
-
- return 0;
- }
-
-
- psRetOUT->eError = CopyToUserWrapper(psPerProc,
- ui32BridgeID,
- psTmpUserData,
- sMiscInfo.uData.sRetrieveCB.psHWPerfData,
- allocatedSize);
-
- sMiscInfo.uData.sRetrieveCB.psHWPerfData = psTmpUserData;
-
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- allocatedSize,
- pAllocated,
- hAllocatedHandle);
-
- if (psRetOUT->eError != PVRSRV_OK)
- {
- return -EFAULT;
- }
- }
- else
-#endif
{
psRetOUT->eError = SGXGetMiscInfoKM(psDevInfo, &sMiscInfo, psDeviceNode, hDevMemContextInt);
}
-#if defined(SUPPORT_SGX_HWPERF)
-static IMG_INT
-SGXReadDiffCountersBW(IMG_UINT32 ui32BridgeID,
- PVRSRV_BRIDGE_IN_SGX_READ_DIFF_COUNTERS *psSGXReadDiffCountersIN,
- PVRSRV_BRIDGE_OUT_SGX_READ_DIFF_COUNTERS *psSGXReadDiffCountersOUT,
- PVRSRV_PER_PROCESS_DATA *psPerProc)
-{
- IMG_HANDLE hDevCookieInt;
-
- PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_READ_DIFF_COUNTERS);
-
- psSGXReadDiffCountersOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
- &hDevCookieInt,
- psSGXReadDiffCountersIN->hDevCookie,
- PVRSRV_HANDLE_TYPE_DEV_NODE);
-
- if(psSGXReadDiffCountersOUT->eError != PVRSRV_OK)
- {
- return 0;
- }
-
- psSGXReadDiffCountersOUT->eError = SGXReadDiffCountersKM(hDevCookieInt,
- psSGXReadDiffCountersIN->ui32Reg,
- &psSGXReadDiffCountersOUT->ui32Old,
- psSGXReadDiffCountersIN->bNew,
- psSGXReadDiffCountersIN->ui32New,
- psSGXReadDiffCountersIN->ui32NewReset,
- psSGXReadDiffCountersIN->ui32CountersReg,
- psSGXReadDiffCountersIN->ui32Reg2,
- &psSGXReadDiffCountersOUT->bActive,
- &psSGXReadDiffCountersOUT->sDiffs);
-
- return 0;
-}
-
-
static IMG_INT
SGXReadHWPerfCBBW(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SGX_READ_HWPERF_CB *psSGXReadHWPerfCBIN,
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_READ_HWPERF_CB);
- psSGXReadHWPerfCBOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ psSGXReadHWPerfCBOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDevCookieInt,
psSGXReadHWPerfCBIN->hDevCookie,
PVRSRV_HANDLE_TYPE_DEV_NODE);
psAllocated,
ui32AllocatedSize);
}
-
+
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- ui32AllocatedSize,
+ ui32AllocatedSize,
psAllocated,
hAllocatedHandle);
return 0;
}
-#endif
static IMG_INT
if(!psPerProc->bInitProcess)
{
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_PROCESS_NOT_INITIALISED;
return 0;
}
}
-
-
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
#if defined(SGX_SUPPORT_HWPROFILING)
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
#endif
#if defined(SUPPORT_SGX_HWPERF)
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
+#endif
+
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &hDummy,
+ psSGXDevInitPart2IN->sInitInfo.hKernelTASigBufferMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
+
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &hDummy,
+ psSGXDevInitPart2IN->sInitInfo.hKernel3DSigBufferMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
+
+#if defined(FIX_HW_BRN_29702)
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &hDummy,
+ psSGXDevInitPart2IN->sInitInfo.hKernelCFIMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
+#endif
+
+#if defined(FIX_HW_BRN_29823)
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &hDummy,
+ psSGXDevInitPart2IN->sInitInfo.hKernelDummyTermStreamMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
#endif
#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
#endif
#if defined(SGX_FEATURE_SPM_MODE_0)
&hDummy,
psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
#endif
for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
&hDummy,
hHandle,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bLookupFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
}
if (bLookupFailed)
{
PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A handle lookup failed"));
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
return 0;
}
&psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
&psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
&psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
&psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
&psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
&psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
#if defined(SGX_SUPPORT_HWPROFILING)
&psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
#endif
#if defined(SUPPORT_SGX_HWPERF)
&psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
+#endif
+
+ eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+ &psSGXDevInitPart2IN->sInitInfo.hKernelTASigBufferMemInfo,
+ psSGXDevInitPart2IN->sInitInfo.hKernelTASigBufferMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
+
+ eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+ &psSGXDevInitPart2IN->sInitInfo.hKernel3DSigBufferMemInfo,
+ psSGXDevInitPart2IN->sInitInfo.hKernel3DSigBufferMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
+
+#if defined(FIX_HW_BRN_29702)
+ eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+ &psSGXDevInitPart2IN->sInitInfo.hKernelCFIMemInfo,
+ psSGXDevInitPart2IN->sInitInfo.hKernelCFIMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bLookupFailed = IMG_TRUE;
+ }
+#endif
+
+#if defined(FIX_HW_BRN_29823)
+ eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+ &psSGXDevInitPart2IN->sInitInfo.hKernelDummyTermStreamMemInfo,
+ psSGXDevInitPart2IN->sInitInfo.hKernelDummyTermStreamMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
#endif
#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
&psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
#endif
#if defined(SGX_FEATURE_SPM_MODE_0)
&psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
#endif
phHandle,
*phHandle,
PVRSRV_HANDLE_TYPE_MEM_INFO);
- bReleaseFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bReleaseFailed = IMG_TRUE;
+ }
}
if (bReleaseFailed)
{
PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A handle release failed"));
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
PVR_DBG_BREAK;
return 0;
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
#if defined(SGX_SUPPORT_HWPROFILING)
#if defined(SUPPORT_SGX_HWPERF)
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
+#endif
+
+ eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelTASigBufferMemInfo);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
+
+ eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernel3DSigBufferMemInfo);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
+
+#if defined(FIX_HW_BRN_29702)
+ eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCFIMemInfo);
+ bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+#endif
+
+#if defined(FIX_HW_BRN_29823)
+ eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelDummyTermStreamMemInfo);
bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
#endif
#if defined(SGX_FEATURE_SPM_MODE_0)
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
#endif
for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
continue;
eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, hHandle);
- bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+ if (eError != PVRSRV_OK)
+ {
+ bDissociateFailed = IMG_TRUE;
+ }
}
-
-
if(bDissociateFailed)
{
PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A dissociate failed"));
- psRetOUT->eError = PVRSRV_ERROR_GENERIC;
+ psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
PVR_DBG_BREAK;
if (hHWRenderContextInt == IMG_NULL)
{
- psSGXRegHWRenderContextOUT->eError = PVRSRV_ERROR_GENERIC;
+ psSGXRegHWRenderContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
return 0;
}
if (hHWTransferContextInt == IMG_NULL)
{
- psSGXRegHWTransferContextOUT->eError = PVRSRV_ERROR_GENERIC;
+ psSGXRegHWTransferContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
return 0;
}
if (hHW2DContextInt == IMG_NULL)
{
- psSGXRegHW2DContextOUT->eError = PVRSRV_ERROR_GENERIC;
+ psSGXRegHW2DContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
return 0;
}
PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
psSGXFindSharedPBDescOUT->hSharedPBDesc);
-
+
PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
&psSGXFindSharedPBDescOUT->hHWBlockKernelMemInfoHandle,
psHWBlockKernelMemInfo,
psSGXAddSharedPBDescIN->hBlockKernelMemInfo,
PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
PVR_ASSERT(eError == PVRSRV_OK);
-
+
eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
psSGXAddSharedPBDescIN->hHWBlockKernelMemInfo,
if(!psPerProc->bInitProcess)
{
- psSGXInfoForSrvinitOUT->eError = PVRSRV_ERROR_GENERIC;
+ psSGXInfoForSrvinitOUT->eError = PVRSRV_ERROR_PROCESS_NOT_INITIALISED;
return 0;
}
psPDumpBufferArrayIN->ui32BufferArrayLength;
IMG_UINT32 ui32BufferArraySize =
ui32BufferArrayLength * sizeof(SGX_KICKTA_DUMP_BUFFER);
- PVRSRV_ERROR eError = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError = PVRSRV_ERROR_TOO_FEW_BUFFERS;
PVR_UNREFERENCED_PARAMETER(psBridgeOut);
{
IMG_UINT32 ui32RegisterArraySize = psPDump3DSignatureRegistersIN->ui32NumRegisters * sizeof(IMG_UINT32);
IMG_UINT32 *pui32Registers = IMG_NULL;
-#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
PVRSRV_SGXDEV_INFO *psDevInfo = IMG_NULL;
- IMG_HANDLE hDevCookieInt;
+#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
IMG_UINT32 ui32RegVal = 0;
#endif
+ PVRSRV_DEVICE_NODE *psDeviceNode;
IMG_INT ret = -EFAULT;
PVR_UNREFERENCED_PARAMETER(psRetOUT);
goto ExitNoError;
}
-#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
psPDump3DSignatureRegistersIN->hDevCookie,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRetOUT->eError != PVRSRV_OK)
PVR_DPF((PVR_DBG_ERROR, "PDumpTASignatureRegistersBW: hDevCookie lookup failed"));
goto Exit;
}
-
- psDevInfo = ((PVRSRV_DEVICE_NODE *)hDevCookieInt)->pvDevice;
+ psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+
+#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT);
#if defined(PDUMP)
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT,
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT,
psPDump3DSignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
#endif
-#endif
+#endif
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
goto Exit;
}
- PDump3DSignatureRegisters(psPDump3DSignatureRegistersIN->ui32DumpFrameNum,
+ PDump3DSignatureRegisters(&psDeviceNode->sDevId,
+ psPDump3DSignatureRegistersIN->ui32DumpFrameNum,
psPDump3DSignatureRegistersIN->bLastFrame,
pui32Registers,
psPDump3DSignatureRegistersIN->ui32NumRegisters);
+ PDumpSignatureBuffer(&psDeviceNode->sDevId,
+ "out.tasig", "TA", 0,
+ psDevInfo->psKernelTASigBufferMemInfo->sDevVAddr,
+ psDevInfo->psKernelTASigBufferMemInfo->ui32AllocSize,
+ 0 );
+ PDumpSignatureBuffer(&psDeviceNode->sDevId,
+ "out.3dsig", "3D", 0,
+ psDevInfo->psKernel3DSigBufferMemInfo->sDevVAddr,
+ psDevInfo->psKernel3DSigBufferMemInfo->ui32AllocSize,
+ 0 );
+
ExitNoError:
psRetOUT->eError = PVRSRV_OK;
ret = 0;
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32RegisterArraySize, pui32Registers, 0);
}
-
+
#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
if (psDevInfo != IMG_NULL)
{
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE, ui32RegVal);
#if defined(PDUMP)
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_CORE, ui32RegVal,
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, ui32RegVal,
psPDump3DSignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
#endif
}
{
IMG_UINT32 ui32RegisterArraySize = psPDumpCounterRegistersIN->ui32NumRegisters * sizeof(IMG_UINT32);
IMG_UINT32 *pui32Registers = IMG_NULL;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
IMG_INT ret = -EFAULT;
PVR_UNREFERENCED_PARAMETER(psBridgeOut);
goto ExitNoError;
}
+ if(PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
+ psPDumpCounterRegistersIN->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SGXPDumpCounterRegistersBW: hDevCookie lookup failed"));
+ ret = -ENOMEM;
+ goto Exit;
+ }
+
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
(IMG_PVOID *)&pui32Registers, 0,
goto Exit;
}
- PDumpCounterRegisters(psPDumpCounterRegistersIN->ui32DumpFrameNum,
+ PDumpCounterRegisters(&psDeviceNode->sDevId,
+ psPDumpCounterRegistersIN->ui32DumpFrameNum,
psPDumpCounterRegistersIN->bLastFrame,
pui32Registers,
psPDumpCounterRegistersIN->ui32NumRegisters);
IMG_UINT32 *pui32Registers = IMG_NULL;
#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
PVRSRV_SGXDEV_INFO *psDevInfo = IMG_NULL;
- IMG_HANDLE hDevCookieInt;
IMG_UINT32 ui32RegVal = 0;
#endif
+ PVRSRV_DEVICE_NODE *psDeviceNode;
IMG_INT ret = -EFAULT;
PVR_UNREFERENCED_PARAMETER(psRetOUT);
{
goto ExitNoError;
}
-
-#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
+
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
psPDumpTASignatureRegistersIN->hDevCookie,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRetOUT->eError != PVRSRV_OK)
PVR_DPF((PVR_DBG_ERROR, "PDumpTASignatureRegistersBW: hDevCookie lookup failed"));
goto Exit;
}
-
- psDevInfo = ((PVRSRV_DEVICE_NODE *)hDevCookieInt)->pvDevice;
+
+#if defined(SGX_FEATURE_MP) && defined(FIX_HW_BRN_27270)
+
+ psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT);
#if defined(PDUMP)
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT,
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, (SGX_FEATURE_MP_CORE_COUNT - 1) << EUR_CR_MASTER_CORE_ENABLE_SHIFT,
psPDumpTASignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
#endif
-#endif
+#endif
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32RegisterArraySize,
goto Exit;
}
- PDumpTASignatureRegisters(psPDumpTASignatureRegistersIN->ui32DumpFrameNum,
+ PDumpTASignatureRegisters(&psDeviceNode->sDevId,
+ psPDumpTASignatureRegistersIN->ui32DumpFrameNum,
psPDumpTASignatureRegistersIN->ui32TAKickCount,
psPDumpTASignatureRegistersIN->bLastFrame,
pui32Registers,
{
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_CORE, ui32RegVal);
#if defined(PDUMP)
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_CORE, ui32RegVal,
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, ui32RegVal,
psPDumpTASignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
#endif
}
#if defined(SUPPORT_SGX_HWPERF)
#if defined(__linux__)
PVRSRV_SGXDEV_INFO *psDevInfo;
- IMG_HANDLE hDevCookieInt;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_HWPERFCB);
psRetOUT->eError =
- PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
psPDumpHWPerfCBIN->hDevCookie,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRetOUT->eError != PVRSRV_OK)
return 0;
}
- psDevInfo = ((PVRSRV_DEVICE_NODE *)hDevCookieInt)->pvDevice;
+ psDevInfo = psDeviceNode->pvDevice;
- PDumpHWPerfCBKM(&psPDumpHWPerfCBIN->szFileName[0],
+ PDumpHWPerfCBKM(&psDeviceNode->sDevId,
+ &psPDumpHWPerfCBIN->szFileName[0],
psPDumpHWPerfCBIN->ui32FileOffset,
psDevInfo->psKernelHWPerfCBMemInfo->sDevVAddr,
psDevInfo->psKernelHWPerfCBMemInfo->ui32AllocSize,
psPDumpHWPerfCBIN->ui32PDumpFlags);
-
+
return 0;
#else
PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
#endif
}
+
+static IMG_INT
+SGXPDumpSaveMemBW(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_PDUMP_SAVEMEM *psPDumpSaveMem,
+ PVRSRV_BRIDGE_RETURN *psRetOUT,
+ PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_SAVEMEM);
+
+ psRetOUT->eError =
+ PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
+ psPDumpSaveMem->hDevCookie,
+ PVRSRV_HANDLE_TYPE_DEV_NODE);
+ if(psRetOUT->eError != PVRSRV_OK)
+ {
+ return 0;
+ }
+
+ PDumpSaveMemKM(&psDeviceNode->sDevId,
+ &psPDumpSaveMem->szFileName[0],
+ psPDumpSaveMem->ui32FileOffset,
+ psPDumpSaveMem->sDevVAddr,
+ psPDumpSaveMem->ui32Size,
+ psPDumpSaveMem->ui32DataMaster,
+ psPDumpSaveMem->ui32PDumpFlags);
+ return 0;
+}
+
#endif
+
IMG_VOID SetSGXDispatchTableEntry(IMG_VOID)
{
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES, SGXScheduleProcessQueuesBW);
-#if defined(SUPPORT_SGX_HWPERF)
- SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_READ_DIFF_COUNTERS, SGXReadDiffCountersBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_READ_HWPERF_CB, SGXReadHWPerfCBBW);
-#endif
#if defined(PDUMP)
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY, SGXPDumpBufferArrayBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_COUNTER_REGISTERS, SGXPDumpCounterRegistersBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_TA_SIGNATURE_REGISTERS, SGXPDumpTASignatureRegistersBW);
SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_HWPERFCB, SGXPDumpHWPerfCBBW);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_SAVEMEM, SGXPDumpSaveMemBW);
#endif
}
+
#endif
#include "hash.h"
#include "ra.h"
#include "pdump_km.h"
-
-#define MIN(a,b) (a > b ? b : a)
-
-
#include "lists.h"
-DECLARE_LIST_ANY_VA(BM_HEAP);
-DECLARE_LIST_ANY_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
-DECLARE_LIST_ANY_VA_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
-DECLARE_LIST_FOR_EACH_VA(BM_HEAP);
-DECLARE_LIST_INSERT(BM_HEAP);
-DECLARE_LIST_REMOVE(BM_HEAP);
-
-DECLARE_LIST_FOR_EACH(BM_CONTEXT);
-DECLARE_LIST_ANY_VA(BM_CONTEXT);
-DECLARE_LIST_ANY_VA_2(BM_CONTEXT, IMG_HANDLE, IMG_NULL);
-DECLARE_LIST_INSERT(BM_CONTEXT);
-DECLARE_LIST_REMOVE(BM_CONTEXT);
-
-
static IMG_BOOL
ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags);
static IMG_VOID
static IMG_BOOL
DevMemoryAlloc (BM_CONTEXT *pBMContext,
- BM_MAPPING *pMapping,
+ BM_MAPPING *pMapping,
IMG_SIZE_T *pActualSize,
IMG_UINT32 uFlags,
IMG_UINT32 dev_vaddr_alignment,
RA_ARENA *pArena = IMG_NULL;
PVR_DPF ((PVR_DBG_MESSAGE,
- "AllocMemory (pBMContext=%08X, uSize=0x%x, uFlags=0x%x, align=0x%x, pBuf=%08X)",
- pBMContext, uSize, uFlags, uDevVAddrAlignment, pBuf));
+ "AllocMemory (uSize=0x%x, uFlags=0x%x, align=0x%x)",
+ uSize, uFlags, uDevVAddrAlignment));
if(uFlags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR)
{
- PVR_DPF ((PVR_DBG_ERROR, "AllocMemory: combination of DevVAddr management and RAM backing mode unsupported"));
+ PVR_DPF ((PVR_DBG_ERROR, "AllocMemory: combination of DevVAddr management and RAM backing mode unsupported"));
return IMG_FALSE;
}
{
pArena = psBMHeap->pImportArena;
+ PVR_ASSERT(psBMHeap->sDevArena.psDeviceMemoryHeapInfo->ui32Attribs & PVRSRV_MEM_RAM_BACKED_ALLOCATION);
}
else
{
(IMG_PVOID *)&pMapping, IMG_NULL,
"Buffer Manager Mapping") != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "AllocMemory: OSAllocMem(0x%x) FAILED"));
+ PVR_DPF((PVR_DBG_ERROR, "AllocMemory: OSAllocMem(0x%x) FAILED", sizeof(*pMapping)));
return IMG_FALSE;
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "AllocMemory: pMapping=%08X: DevV=%08X CpuV=%08X CpuP=%08X uSize=0x%x",
- pMapping,
+ "AllocMemory: pMapping=%08x: DevV=%08X CpuV=%08x CpuP=%08X uSize=0x%x",
+ (IMG_UINTPTR_T)pMapping,
pMapping->DevVAddr.uiAddr,
- pMapping->CpuVAddr,
+ (IMG_UINTPTR_T)pMapping->CpuVAddr,
pMapping->CpuPAddr.uiAddr,
pMapping->uSize));
PVR_DPF ((PVR_DBG_MESSAGE,
- "AllocMemory: pBuf=%08X: DevV=%08X CpuV=%08X CpuP=%08X uSize=0x%x",
- pBuf,
+ "AllocMemory: pBuf=%08x: DevV=%08X CpuV=%08x CpuP=%08X uSize=0x%x",
+ (IMG_UINTPTR_T)pBuf,
pBuf->DevVAddr.uiAddr,
- pBuf->CpuVAddr,
+ (IMG_UINTPTR_T)pBuf->CpuVAddr,
pBuf->CpuPAddr.uiAddr,
uSize));
IMG_SIZE_T const ui32PageSize = HOST_PAGESIZE();
PVR_DPF ((PVR_DBG_MESSAGE,
- "WrapMemory(psBMHeap=%08X, size=0x%x, offset=0x%x, bPhysContig=0x%x, pvCPUVAddr = 0x%x, flags=0x%x, pBuf=%08X)",
- psBMHeap, uSize, ui32BaseOffset, bPhysContig, pvCPUVAddr, uFlags, pBuf));
+ "WrapMemory(psBMHeap=%08X, size=0x%x, offset=0x%x, bPhysContig=0x%x, pvCPUVAddr = 0x%08x, flags=0x%x)",
+ (IMG_UINTPTR_T)psBMHeap, uSize, ui32BaseOffset, bPhysContig, (IMG_UINTPTR_T)pvCPUVAddr, uFlags));
PVR_ASSERT((psAddr->uiAddr & (ui32PageSize - 1)) == 0);
}
OSMemSet(pMapping, 0, sizeof (*pMapping));
-
+
pMapping->uSize = uSize;
pMapping->pBMHeap = psBMHeap;
if(pvCPUVAddr)
{
pMapping->CpuVAddr = pvCPUVAddr;
-
+
if (bPhysContig)
{
pMapping->eCpuMemoryOrigin = hm_wrapped_virtaddr;
pMapping->CpuPAddr = SysSysPAddrToCpuPAddr(psAddr[0]);
- if(OSRegisterMem(pMapping->CpuPAddr,
+ if(OSRegisterMem(pMapping->CpuPAddr,
pMapping->CpuVAddr,
pMapping->uSize,
uFlags,
&pMapping->hOSMemHandle) != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterMem Phys=0x%08X, CpuVAddr = 0x%08X, Size=%d) failed",
- pMapping->CpuPAddr, pMapping->CpuVAddr, pMapping->uSize));
+ PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterMem Phys=0x%08X, Size=%d) failed",
+ pMapping->CpuPAddr.uiAddr, pMapping->uSize));
goto fail_cleanup;
}
}
pMapping->eCpuMemoryOrigin = hm_wrapped_scatter_virtaddr;
pMapping->psSysAddr = psAddr;
- if(OSRegisterDiscontigMem(pMapping->psSysAddr,
+ if(OSRegisterDiscontigMem(pMapping->psSysAddr,
pMapping->CpuVAddr,
pMapping->uSize,
uFlags,
&pMapping->hOSMemHandle) != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterDiscontigMem CpuVAddr = 0x%08X, Size=%d) failed",
- pMapping->CpuVAddr, pMapping->uSize));
+ PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterDiscontigMem Size=%d) failed",
+ pMapping->uSize));
goto fail_cleanup;
}
}
&pMapping->hOSMemHandle) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSReservePhys Phys=0x%08X, Size=%d) failed",
- pMapping->CpuPAddr, pMapping->uSize));
+ pMapping->CpuPAddr.uiAddr, pMapping->uSize));
goto fail_cleanup;
}
}
PVR_DPF ((PVR_DBG_MESSAGE, "DevVaddr.uiAddr=%08X", DevVAddr.uiAddr));
PVR_DPF ((PVR_DBG_MESSAGE,
- "WrapMemory: pMapping=%08X: DevV=%08X CpuV=%08X CpuP=%08X uSize=0x%x",
- pMapping, pMapping->DevVAddr.uiAddr,
- pMapping->CpuVAddr, pMapping->CpuPAddr.uiAddr, pMapping->uSize));
+ "WrapMemory: DevV=%08X CpuP=%08X uSize=0x%x",
+ pMapping->DevVAddr.uiAddr, pMapping->CpuPAddr.uiAddr, pMapping->uSize));
PVR_DPF ((PVR_DBG_MESSAGE,
- "WrapMemory: pBuf=%08X: DevV=%08X CpuV=%08X CpuP=%08X uSize=0x%x",
- pBuf, pBuf->DevVAddr.uiAddr,
- pBuf->CpuVAddr, pBuf->CpuPAddr.uiAddr, uSize));
+ "WrapMemory: DevV=%08X CpuP=%08X uSize=0x%x",
+ pBuf->DevVAddr.uiAddr, pBuf->CpuPAddr.uiAddr, uSize));
pBuf->pMapping = pMapping;
return IMG_TRUE;
if(CpuPAddr.uiAddr & (HOST_PAGESIZE() -1))
{
ui32BlockBytes =
- MIN(ui32BytesRemaining, HOST_PAGEALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
+ MIN(ui32BytesRemaining, (IMG_UINT32)(HOST_PAGEALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr));
}
pvCpuVAddr = OSMapPhysToLin(CpuPAddr,
}
static IMG_VOID
-FreeBuf (BM_BUF *pBuf, IMG_UINT32 ui32Flags)
+FreeBuf (BM_BUF *pBuf, IMG_UINT32 ui32Flags, IMG_BOOL bFromAllocator)
{
BM_MAPPING *pMapping;
PVR_DPF ((PVR_DBG_MESSAGE,
- "FreeBuf: pBuf=%08X: DevVAddr=%08X CpuVAddr=%08X CpuPAddr=%08X",
- pBuf, pBuf->DevVAddr.uiAddr, pBuf->CpuVAddr, pBuf->CpuPAddr.uiAddr));
+ "FreeBuf: pBuf=0x%x: DevVAddr=%08X CpuVAddr=0x%x CpuPAddr=%08X",
+ (IMG_UINTPTR_T)pBuf, pBuf->DevVAddr.uiAddr,
+ (IMG_UINTPTR_T)pBuf->CpuVAddr, pBuf->CpuPAddr.uiAddr));
pMapping = pBuf->pMapping;
if(ui32Flags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR)
{
- if(ui32Flags & PVRSRV_MEM_RAM_BACKED_ALLOCATION)
- {
-
- PVR_DPF ((PVR_DBG_ERROR, "FreeBuf: combination of DevVAddr management and RAM backing mode unsupported"));
- }
- else
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
{
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
- pBuf->pMapping = IMG_NULL;
+ if(ui32Flags & PVRSRV_MEM_RAM_BACKED_ALLOCATION)
+ {
+
+ PVR_DPF ((PVR_DBG_ERROR, "FreeBuf: combination of DevVAddr management and RAM backing mode unsupported"));
+ }
+ else
+ {
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+ pBuf->pMapping = IMG_NULL;
+ }
}
}
else
if(pBuf->hOSMemHandle != pMapping->hOSMemHandle)
{
- OSReleaseSubMemHandle(pBuf->hOSMemHandle, ui32Flags);
+
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+ {
+
+ OSReleaseSubMemHandle(pBuf->hOSMemHandle, ui32Flags);
+ }
}
if(ui32Flags & PVRSRV_MEM_RAM_BACKED_ALLOCATION)
{
+
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+ {
+
- RA_Free (pBuf->pMapping->pArena, pBuf->DevVAddr.uiAddr, IMG_FALSE);
+ PVR_ASSERT(pBuf->ui32ExportCount == 0)
+ RA_Free (pBuf->pMapping->pArena, pBuf->DevVAddr.uiAddr, IMG_FALSE);
+ }
}
else
{
- switch (pMapping->eCpuMemoryOrigin)
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
{
- case hm_wrapped:
- OSUnReservePhys(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
- break;
- case hm_wrapped_virtaddr:
- OSUnRegisterMem(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
- break;
- case hm_wrapped_scatter:
- OSUnReserveDiscontigPhys(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
- break;
- case hm_wrapped_scatter_virtaddr:
- OSUnRegisterDiscontigMem(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
- break;
- default:
- break;
+ switch (pMapping->eCpuMemoryOrigin)
+ {
+ case hm_wrapped:
+ OSUnReservePhys(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
+ break;
+ case hm_wrapped_virtaddr:
+ OSUnRegisterMem(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
+ break;
+ case hm_wrapped_scatter:
+ OSUnReserveDiscontigPhys(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
+ break;
+ case hm_wrapped_scatter_virtaddr:
+ OSUnRegisterDiscontigMem(pMapping->CpuVAddr, pMapping->uSize, ui32Flags, pMapping->hOSMemHandle);
+ break;
+ default:
+ break;
+ }
}
-
- DevMemoryFree (pMapping);
+ if (bFromAllocator)
+ DevMemoryFree (pMapping);
-
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
- pBuf->pMapping = IMG_NULL;
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+ {
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+ pBuf->pMapping = IMG_NULL;
+ }
}
}
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_BUF), pBuf, IMG_NULL);
-
+
+ if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+ {
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_BUF), pBuf, IMG_NULL);
+
+ }
}
-PVRSRV_ERROR BM_DestroyContext_AnyCb(BM_HEAP *psBMHeap)
+static PVRSRV_ERROR BM_DestroyContext_AnyCb(BM_HEAP *psBMHeap)
{
- if(psBMHeap->ui32Attribs
+ if(psBMHeap->ui32Attribs
& (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
|PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
{
if (!bTestDelete)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext_AnyCb: RA_TestDelete failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP;
}
}
}
- eError = List_BM_HEAP_PVRSRV_ERROR_Any(pBMContext->psBMHeap, BM_DestroyContext_AnyCb);
+ eError = List_BM_HEAP_PVRSRV_ERROR_Any(pBMContext->psBMHeap, &BM_DestroyContext_AnyCb);
if(eError != PVRSRV_OK)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: List_BM_HEAP_PVRSRV_ERROR_Any failed"));
}
#endif
- return eError;
+ return eError;
}
else
{
if(eError != PVRSRV_OK)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeResByPtr failed %d",eError));
- return eError;
+ return eError;
}
-
+
if (pbDestroyed != IMG_NULL)
{
*pbDestroyed = IMG_TRUE;
}
}
-
+
return PVRSRV_OK;
}
-PVRSRV_ERROR BM_DestroyContextCallBack_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
+static PVRSRV_ERROR BM_DestroyContextCallBack_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
psDeviceNode = va_arg(va, PVRSRV_DEVICE_NODE*);
+
-
- if(psBMHeap->ui32Attribs
+ if(psBMHeap->ui32Attribs
& (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
|PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
{
else
{
PVR_DPF((PVR_DBG_ERROR, "BM_DestroyContext: backing store type unsupported"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE;
}
-
+
psDeviceNode->pfnMMUDelete(psBMHeap->pMMUHeap);
{
BM_CONTEXT *pBMContext = pvParam;
PVRSRV_DEVICE_NODE *psDeviceNode;
+ PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(ui32Param);
- if(List_BM_HEAP_PVRSRV_ERROR_Any_va(pBMContext->psBMHeap,
- BM_DestroyContextCallBack_AnyVaCb,
- psDeviceNode) != PVRSRV_OK)
+ eError = List_BM_HEAP_PVRSRV_ERROR_Any_va(pBMContext->psBMHeap,
+ &BM_DestroyContextCallBack_AnyVaCb,
+ psDeviceNode);
+ if (eError != PVRSRV_OK)
{
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
{
psDeviceNode->pfnMMUFinalise(pBMContext->psMMUContext);
}
-
+
if (pBMContext->pBufferHash)
}
-IMG_HANDLE BM_CreateContext_IncRefCount_AnyVaCb(BM_CONTEXT *pBMContext, va_list va)
+static IMG_HANDLE BM_CreateContext_IncRefCount_AnyVaCb(BM_CONTEXT *pBMContext, va_list va)
{
PRESMAN_CONTEXT hResManContext;
hResManContext = va_arg(va, PRESMAN_CONTEXT);
return IMG_NULL;
}
-IMG_VOID BM_CreateContext_InsertHeap_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
+static IMG_VOID BM_CreateContext_InsertHeap_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
BM_CONTEXT *pBMContext;
}
}
-IMG_HANDLE
+IMG_HANDLE
BM_CreateContext(PVRSRV_DEVICE_NODE *psDeviceNode,
IMG_DEV_PHYADDR *psPDDevPAddr,
PVRSRV_PER_PROCESS_DATA *psPerProc,
if (bKernelContext == IMG_FALSE)
{
IMG_HANDLE res = (IMG_HANDLE) List_BM_CONTEXT_Any_va(psDevMemoryInfo->pBMContext,
- BM_CreateContext_IncRefCount_AnyVaCb,
+ &BM_CreateContext_IncRefCount_AnyVaCb,
hResManContext);
if (res)
{
pBMContext->psBMSharedHeap = psDevMemoryInfo->pBMKernelContext->psBMHeap;
-
+
List_BM_HEAP_ForEach_va(pBMContext->psBMSharedHeap,
- BM_CreateContext_InsertHeap_ForEachVaCb,
+ &BM_CreateContext_InsertHeap_ForEachVaCb,
psDeviceNode,
pBMContext);
RESMAN_TYPE_DEVICEMEM_CONTEXT,
pBMContext,
0,
- BM_DestroyContextCallBack);
+ &BM_DestroyContextCallBack);
if (pBMContext->hResItem == IMG_NULL)
{
PVR_DPF ((PVR_DBG_ERROR, "BM_CreateContext: ResManRegisterRes failed"));
}
-IMG_VOID *BM_CreateHeap_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
+static IMG_VOID *BM_CreateHeap_AnyVaCb(BM_HEAP *psBMHeap, va_list va)
{
DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo;
psDevMemHeapInfo = va_arg(va, DEVICE_MEMORY_HEAP_INFO*);
DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo)
{
BM_CONTEXT *pBMContext = (BM_CONTEXT*)hBMContext;
- PVRSRV_DEVICE_NODE *psDeviceNode = pBMContext->psDeviceNode;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
BM_HEAP *psBMHeap;
PVR_DPF((PVR_DBG_MESSAGE, "BM_CreateHeap"));
if(!pBMContext)
{
+ PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: BM_CONTEXT null"));
return IMG_NULL;
}
+ psDeviceNode = pBMContext->psDeviceNode;
+
if(pBMContext->ui32RefCount > 0)
{
psBMHeap = (BM_HEAP*)List_BM_HEAP_Any_va(pBMContext->psBMHeap,
- BM_CreateHeap_AnyVaCb,
+ &BM_CreateHeap_AnyVaCb,
psDevMemHeapInfo);
if (psBMHeap)
psBMHeap->pMMUHeap = psDeviceNode->pfnMMUCreate (pBMContext->psMMUContext,
&psBMHeap->sDevArena,
- &psBMHeap->pVMArena);
+ &psBMHeap->pVMArena,
+ &psBMHeap->psMMUAttrib);
if (!psBMHeap->pMMUHeap)
{
PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: MMUCreate failed"));
psBMHeap->pImportArena = RA_Create (psDevMemHeapInfo->pszBSName,
0, 0, IMG_NULL,
- psBMHeap->sDevArena.ui32DataPageSize,
- BM_ImportMemory,
- BM_FreeMemory,
+ MAX(HOST_PAGESIZE(), psBMHeap->sDevArena.ui32DataPageSize),
+ &BM_ImportMemory,
+ &BM_FreeMemory,
IMG_NULL,
psBMHeap);
if(psBMHeap->pImportArena == IMG_NULL)
PVR_DPF((PVR_DBG_MESSAGE, "BM_DestroyHeap"));
if(psBMHeap)
- {
+ {
- if(psBMHeap->ui32Attribs
+ if(psBMHeap->ui32Attribs
& (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
|PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
{
psDeviceNode->pfnMMUDelete (psBMHeap->pMMUHeap);
-
+
List_BM_HEAP_Remove(psBMHeap);
}
-IMG_BOOL
+IMG_BOOL
BM_Reinitialise (PVRSRV_DEVICE_NODE *psDeviceNode)
{
PVR_DBG_BREAK;
return IMG_FALSE;
}
-
+
uFlags = *pui32Flags;
PVR_DPF ((PVR_DBG_MESSAGE,
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_Alloc (uSize=0x%x, uFlags=0x%x)=%08X",
- uSize, uFlags, pBuf));
+ "BM_Alloc (uSize=0x%x, uFlags=0x%x)",
+ uSize, uFlags));
pBuf->ui32RefCount = 1;
PVR_DPF ((PVR_DBG_MESSAGE,
"BM_Wrap (uSize=0x%x, uOffset=0x%x, bPhysContig=0x%x, pvCPUVAddr=0x%x, uFlags=0x%x)",
- ui32Size, ui32Offset, bPhysContig, pvCPUVAddr, uFlags));
+ ui32Size, ui32Offset, bPhysContig, (IMG_UINTPTR_T)pvCPUVAddr, uFlags));
SysAcquireData(&psSysData);
}
else
{
- IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
+ IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
if (!ValidSysPAddrArrayForDev(psBMContext->psDeviceNode, psSysAddr, WRAP_PAGE_COUNT(ui32Size, ui32Offset, ui32HostPageSize), ui32HostPageSize))
{
#endif
sHashAddress = psSysAddr[0];
-
+
sHashAddress.uiAddr += ui32Offset;
- pBuf = (BM_BUF *)HASH_Retrieve(psBMContext->pBufferHash, (IMG_UINTPTR_T) sHashAddress.uiAddr);
+ pBuf = (BM_BUF *)HASH_Retrieve(psBMContext->pBufferHash, sHashAddress.uiAddr);
if(pBuf)
{
PVR_ASSERT(SysSysPAddrToCpuPAddr(sHashAddress).uiAddr == pBuf->CpuPAddr.uiAddr);
- if (!HASH_Insert (psBMContext->pBufferHash, (IMG_UINTPTR_T) sHashAddress.uiAddr, (IMG_UINTPTR_T)pBuf))
+ if (!HASH_Insert (psBMContext->pBufferHash, sHashAddress.uiAddr, (IMG_UINTPTR_T)pBuf))
{
- FreeBuf (pBuf, uFlags);
+ FreeBuf (pBuf, uFlags, IMG_TRUE);
PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: HASH_Insert FAILED"));
return IMG_FALSE;
}
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_Wrap (uSize=0x%x, uFlags=0x%x)=%08X(devVAddr=%08X)",
- ui32Size, uFlags, pBuf, pBuf->DevVAddr.uiAddr));
+ "BM_Wrap (uSize=0x%x, uFlags=0x%x, devVAddr=%08X)",
+ ui32Size, uFlags, pBuf->DevVAddr.uiAddr));
pBuf->ui32RefCount = 1;
return IMG_TRUE;
}
+IMG_VOID
+BM_Export (BM_HANDLE hBuf)
+{
+ BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+ pBuf->ui32ExportCount++;
+}
+
+IMG_VOID
+BM_FreeExport(BM_HANDLE hBuf,
+ IMG_UINT32 ui32Flags)
+{
+ BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+ pBuf->ui32ExportCount--;
+ FreeBuf (pBuf, ui32Flags, IMG_FALSE);
+}
IMG_VOID
BM_Free (BM_HANDLE hBuf,
SYS_DATA *psSysData;
IMG_SYS_PHYADDR sHashAddr;
- PVR_DPF ((PVR_DBG_MESSAGE, "BM_Free (h=%08X)", hBuf));
+ PVR_DPF ((PVR_DBG_MESSAGE, "BM_Free (h=0x%x)", (IMG_UINTPTR_T)hBuf));
PVR_ASSERT (pBuf!=IMG_NULL);
if (pBuf == IMG_NULL)
HASH_Remove (pBuf->pMapping->pBMHeap->pBMContext->pBufferHash, (IMG_UINTPTR_T)sHashAddr.uiAddr);
}
- FreeBuf (pBuf, ui32Flags);
+ FreeBuf (pBuf, ui32Flags, IMG_TRUE);
}
}
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_HandleToCpuVaddr(h=%08X)=%08X",
- hBuf, pBuf->CpuVAddr));
+ "BM_HandleToCpuVaddr(h=0x%x)=0x%x",
+ (IMG_UINTPTR_T)hBuf, (IMG_UINTPTR_T)pBuf->CpuVAddr));
return pBuf->CpuVAddr;
}
return DevVAddr;
}
- PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToDevVaddr(h=%08X)=%08X", hBuf, pBuf->DevVAddr));
+ PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToDevVaddr(h=0x%x)=%08X", (IMG_UINTPTR_T)hBuf, pBuf->DevVAddr.uiAddr));
return pBuf->DevVAddr;
}
return PhysAddr;
}
- PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToSysPaddr(h=%08X)=%08X", hBuf, pBuf->CpuPAddr.uiAddr));
+ PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToSysPaddr(h=0x%x)=%08X", (IMG_UINTPTR_T)hBuf, pBuf->CpuPAddr.uiAddr));
return SysCpuPAddrToSysPAddr (pBuf->CpuPAddr);
}
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_HandleToOSMemHandle(h=%08X)=%08X",
- hBuf, pBuf->hOSMemHandle));
+ "BM_HandleToOSMemHandle(h=0x%x)=0x%x",
+ (IMG_UINTPTR_T)hBuf, (IMG_UINTPTR_T)pBuf->hOSMemHandle));
return pBuf->hOSMemHandle;
}
-IMG_BOOL
-BM_ContiguousStatistics (IMG_UINT32 uFlags,
- IMG_UINT32 *pTotalBytes,
- IMG_UINT32 *pAvailableBytes)
-{
- if (pAvailableBytes || pTotalBytes || uFlags);
- return IMG_FALSE;
-}
-
-
static IMG_BOOL
DevMemoryAlloc (BM_CONTEXT *pBMContext,
- BM_MAPPING *pMapping,
+ BM_MAPPING *pMapping,
IMG_SIZE_T *pActualSize,
IMG_UINT32 uFlags,
IMG_UINT32 dev_vaddr_alignment,
pMapping->uSize *= 2;
}
-
+
#ifdef PDUMP
if(uFlags & PVRSRV_MEM_DUMMY)
{
#endif
- if (!psDeviceNode->pfnMMUAlloc (pMapping->pBMHeap->pMMUHeap,
- pMapping->uSize,
- pActualSize,
+ if (!psDeviceNode->pfnMMUAlloc (pMapping->pBMHeap->pMMUHeap,
+ pMapping->uSize,
+ pActualSize,
0,
- dev_vaddr_alignment,
+ dev_vaddr_alignment,
&(pMapping->DevVAddr)))
{
PVR_DPF((PVR_DBG_ERROR, "DevMemoryAlloc ERROR MMU_Alloc"));
EnableHostAccess(pBMContext->psMMUContext);
#endif
-
-
- PDUMPMALLOCPAGES(psDeviceNode->sDevId.eDeviceType, pMapping->DevVAddr.uiAddr, pMapping->CpuVAddr, pMapping->hOSMemHandle, ui32PDumpSize, pMapping->pBMHeap->sDevArena.ui32DataPageSize, (IMG_HANDLE)pMapping);
+#if defined(PDUMP)
+
+ PDUMPMALLOCPAGES(&psDeviceNode->sDevId,
+ pMapping->DevVAddr.uiAddr,
+ pMapping->CpuVAddr,
+ pMapping->hOSMemHandle,
+ ui32PDumpSize,
+ pMapping->pBMHeap->sDevArena.ui32DataPageSize,
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ psDeviceNode->pfnMMUIsHeapShared(pMapping->pBMHeap->pMMUHeap),
+#else
+ IMG_FALSE,
+#endif
+ (IMG_HANDLE)pMapping);
+#endif
switch (pMapping->eCpuMemoryOrigin)
{
PDUMPFREEPAGES(pMapping->pBMHeap,
pMapping->DevVAddr,
- ui32PSize,
+ ui32PSize,
pMapping->pBMHeap->sDevArena.ui32DataPageSize,
(IMG_HANDLE)pMapping,
(pMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED) ? IMG_TRUE : IMG_FALSE);
IMG_UINT32 uDevVAddrAlignment = 0;
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_ImportMemory (pBMContext=%08X, uRequestSize=0x%x, uFlags=0x%x, uAlign=0x%x)",
- pBMContext, uRequestSize, uFlags, uDevVAddrAlignment));
+ "BM_ImportMemory (pBMContext=0x%x, uRequestSize=0x%x, uFlags=0x%x, uAlign=0x%x)",
+ (IMG_UINTPTR_T)pBMContext, uRequestSize, uFlags, uDevVAddrAlignment));
PVR_ASSERT (ppsMapping != IMG_NULL);
PVR_ASSERT (pBMContext != IMG_NULL);
{
*pActualSize = uSize;
}
-
+
if(pMapping->ui32Flags & PVRSRV_MEM_DUMMY)
{
IMG_UINT32 ui32Attribs = pBMHeap->ui32Attribs;
+ PVR_ASSERT(pBMHeap->pLocalDevMemArena != IMG_NULL);
+
+
if (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
{
ui32Attribs &= ~PVRSRV_HAP_CACHETYPE_MASK;
ui32Attribs |= (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK);
}
-
- PVR_ASSERT(pBMHeap->pLocalDevMemArena != IMG_NULL);
-
if (!RA_Alloc (pBMHeap->pLocalDevMemArena,
uPSize,
IMG_NULL,
bResult = DevMemoryAlloc (pBMContext,
- pMapping,
- IMG_NULL,
+ pMapping,
+ IMG_NULL,
uFlags,
- uDevVAddrAlignment,
+ uDevVAddrAlignment,
&pMapping->DevVAddr);
if (!bResult)
{
}
-
+
PVR_ASSERT (uDevVAddrAlignment>1?(pMapping->DevVAddr.uiAddr%uDevVAddrAlignment)==0:1);
*pBase = pMapping->DevVAddr.uiAddr;
if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
{
- OSFreePages(pBMHeap->ui32Attribs,
- uPSize,
+ OSFreePages(pBMHeap->ui32Attribs,
+ uPSize,
(IMG_VOID *)pMapping->CpuVAddr,
pMapping->hOSMemHandle);
}
pBMHeap->ui32Attribs,
pMapping->hOSMemHandle);
}
- sSysPAddr = SysCpuPAddrToSysPAddr(pMapping->CpuPAddr);
- RA_Free (pBMHeap->pLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+ sSysPAddr = SysCpuPAddrToSysPAddr(pMapping->CpuPAddr);
+ RA_Free (pBMHeap->pLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
}
}
fail_mapping_alloc:
PVR_UNREFERENCED_PARAMETER (_base);
PVR_DPF ((PVR_DBG_MESSAGE,
- "BM_FreeMemory (h=%08X, base=0x%x, psMapping=0x%x)", h, _base, psMapping));
+ "BM_FreeMemory (h=0x%x, base=0x%x, psMapping=0x%x)",
+ (IMG_UINTPTR_T)h, _base, (IMG_UINTPTR_T)psMapping));
PVR_ASSERT (psMapping != IMG_NULL);
{
psMapping->uSize /= 2;
}
-
+
if(psMapping->ui32Flags & PVRSRV_MEM_DUMMY)
{
uPSize = psMapping->pBMHeap->sDevArena.ui32DataPageSize;
{
uPSize = psMapping->uSize;
}
-
+
if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
{
OSFreePages(pBMHeap->ui32Attribs,
PVR_DPF((PVR_DBG_MESSAGE,
- "..BM_FreeMemory (h=%08X, base=0x%x, psMapping=0x%x)",
- h, _base, psMapping));
+ "..BM_FreeMemory (h=0x%x, base=0x%x)",
+ (IMG_UINTPTR_T)h, _base));
}
IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
psDeviceNode = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pBMContext->psDeviceNode;
- *psDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pMMUHeap,
+ *psDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pMMUHeap,
sDevVPageAddr);
}
-PVRSRV_ERROR BM_GetHeapInfo(IMG_HANDLE hDevMemHeap, PVRSRV_HEAP_INFO *psHeapInfo)
-{
- BM_HEAP *psBMHeap = (BM_HEAP *)hDevMemHeap;
-
- PVR_DPF((PVR_DBG_VERBOSE, "BM_GetHeapInfo"));
-
- psHeapInfo->hDevMemHeap = hDevMemHeap;
- psHeapInfo->sDevVAddrBase = psBMHeap->sDevArena.BaseDevVAddr;
- psHeapInfo->ui32HeapByteSize = psBMHeap->sDevArena.ui32Size;
- psHeapInfo->ui32Attribs = psBMHeap->ui32Attribs;
-
- return PVRSRV_OK;
-}
-
-
MMU_CONTEXT* BM_GetMMUContext(IMG_HANDLE hDevMemHeap)
{
BM_HEAP *pBMHeap = (BM_HEAP*)hDevMemHeap;
#include "services_headers.h"
#include "buffer_manager.h"
#include "kernelbuffer.h"
+#include "kerneldisplay.h"
#include "pvr_bridge_km.h"
+#include "pdump_km.h"
+#include "deviceid.h"
#include "lists.h"
-DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_INSERT(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_REMOVE(PVRSRV_DEVICE_NODE);
-
-IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va);
PVRSRV_ERROR AllocateDeviceID(SYS_DATA *psSysData, IMG_UINT32 *pui32DevID);
PVRSRV_ERROR FreeDeviceID(SYS_DATA *psSysData, IMG_UINT32 ui32DevID);
void OSVSyncMISR(IMG_HANDLE, IMG_BOOL);
#endif
-
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+IMG_VOID PVRSRVFreeCommandCompletePacketKM(IMG_HANDLE hCmdCookie,
+ IMG_BOOL bScheduleMISR);
+#endif
typedef struct PVRSRV_DC_SRV2DISP_KMJTABLE_TAG *PPVRSRV_DC_SRV2DISP_KMJTABLE;
typedef struct PVRSRV_DC_BUFFER_TAG
typedef struct PVRSRV_DC_SWAPCHAIN_TAG
{
IMG_HANDLE hExtSwapChain;
+ IMG_UINT32 ui32SwapChainID;
+ IMG_UINT32 ui32RefCount;
+ IMG_UINT32 ui32Flags;
PVRSRV_QUEUE_INFO *psQueue;
PVRSRV_DC_BUFFER asBuffer[PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS];
IMG_UINT32 ui32BufferCount;
PVRSRV_DC_BUFFER *psLastFlipBuffer;
+ IMG_UINT32 ui32MinSwapInterval;
+ IMG_UINT32 ui32MaxSwapInterval;
struct PVRSRV_DISPLAYCLASS_INFO_TAG *psDCInfo;
- IMG_HANDLE hResItem;
+ struct PVRSRV_DC_SWAPCHAIN_TAG *psNext;
} PVRSRV_DC_SWAPCHAIN;
+
+typedef struct PVRSRV_DC_SWAPCHAIN_REF_TAG
+{
+ struct PVRSRV_DC_SWAPCHAIN_TAG *psSwapChain;
+ IMG_HANDLE hResItem;
+} PVRSRV_DC_SWAPCHAIN_REF;
+
+
typedef struct PVRSRV_DISPLAYCLASS_INFO_TAG
{
IMG_UINT32 ui32RefCount;
PPVRSRV_DC_SRV2DISP_KMJTABLE psFuncTable;
IMG_HANDLE hDevMemContext;
PVRSRV_DC_BUFFER sSystemBuffer;
+ struct PVRSRV_DC_SWAPCHAIN_TAG *psDCSwapChainShared;
} PVRSRV_DISPLAYCLASS_INFO;
return psBCPerContextInfo->psBCInfo;
}
-IMG_VOID PVRSRVEnumerateDCKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+static IMG_VOID PVRSRVEnumerateDCKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
IMG_UINT *pui32DevCount;
IMG_UINT32 **ppui32DevID;
(*pui32DevCount)++;
if(*ppui32DevID)
{
- *(*ppui32DevID++) = psDeviceNode->sDevId.ui32DeviceIndex;
+ *(*ppui32DevID)++ = psDeviceNode->sDevId.ui32DeviceIndex;
}
}
}
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
- PVRSRVEnumerateDCKM_ForEachVaCb,
+ &PVRSRVEnumerateDCKM_ForEachVaCb,
&ui32DevCount,
&pui32DevID,
DeviceClass);
}
+static
PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable,
IMG_UINT32 *pui32DeviceID)
{
-
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*psDCInfo),
(IMG_VOID **)&psDCInfo, IMG_NULL,
sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE),
(IMG_VOID **)&psDCInfo->psFuncTable, IMG_NULL,
"Function table for SRVKM->DISPLAY") != PVRSRV_OK)
- {
+ {
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psFuncTable alloc"));
goto ErrorExit;
}
{
*pui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
}
-
+
SysRegisterExternalDevice(psDeviceNode);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE), psDCInfo->psFuncTable, IMG_NULL);
psDCInfo->psFuncTable = IMG_NULL;
}
-
+
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_INFO), psDCInfo, IMG_NULL);
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
-PVRSRV_ERROR PVRSRVRemoveDCDeviceKM(IMG_UINT32 ui32DevIndex)
+static PVRSRV_ERROR PVRSRVRemoveDCDeviceKM(IMG_UINT32 ui32DevIndex)
{
SYS_DATA *psSysData;
PVRSRV_DEVICE_NODE *psDeviceNode;
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_FALSE,
PVRSRV_DEVICE_CLASS_DISPLAY);
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: requested device %d not present", ui32DevIndex));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
}
List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
-
+
SysRemoveExternalDevice(psDeviceNode);
-
+
else
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: failed as %d Services DC API connections are still open", psDCInfo->ui32RefCount));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE;
}
-
+
return PVRSRV_OK;
}
+static
PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTable,
IMG_UINT32 *pui32DeviceID)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psBCInfo alloc"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
- OSMemSet (psBCInfo, 0, sizeof(*psBCInfo));
+ OSMemSet (psBCInfo, 0, sizeof(*psBCInfo));
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_INFO), psBCInfo, IMG_NULL);
- return PVRSRV_ERROR_OUT_OF_MEMORY;
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
}
-PVRSRV_ERROR PVRSRVRemoveBCDeviceKM(IMG_UINT32 ui32DevIndex)
+static PVRSRV_ERROR PVRSRVRemoveBCDeviceKM(IMG_UINT32 ui32DevIndex)
{
SYS_DATA *psSysData;
PVRSRV_DEVICE_NODE *psDevNode;
psDevNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_FALSE,
PVRSRV_DEVICE_CLASS_BUFFER);
-
+
if (!psDevNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: requested device %d not present", ui32DevIndex));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
}
List_PVRSRV_DEVICE_NODE_Remove(psDevNode);
-
+
else
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: failed as %d Services BC API connections are still open", psBCInfo->ui32RefCount));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE;
}
return PVRSRV_OK;
eError = ResManFreeResByPtr(psDCPerContextInfo->hResItem);
-
+
return eError;
}
-
+
static PVRSRV_ERROR CloseDCDeviceCallBack(IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
psDCInfo->ui32RefCount--;
if(psDCInfo->ui32RefCount == 0)
- {
+ {
psDCInfo->psFuncTable->pfnCloseDCDevice(psDCInfo->hExtDevice);
- PVRSRVFreeSyncInfoKM(psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
-
+ if (--psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+ {
+ PVRSRVFreeSyncInfoKM(psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
+ }
+
psDCInfo->hDevMemContext = IMG_NULL;
psDCInfo->hExtDevice = IMG_NULL;
}
if(!phDeviceKM || !hDevCookie)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Invalid params"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
-
+
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DeviceID,
IMG_FALSE,
PVRSRV_DEVICE_CLASS_DISPLAY);
if (!psDeviceNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: no devnode matching index %d", ui32DeviceID));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
}
psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
psDCInfo->hDevMemContext = (IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext;
- eError = PVRSRVAllocSyncInfoKM(IMG_NULL,
+ eError = PVRSRVAllocSyncInfoKM(IMG_NULL,
(IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext,
&psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
if(eError != PVRSRV_OK)
PVRSRVFreeSyncInfoKM(psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
return eError;
}
+
+ psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
}
psDCPerContextInfo->psDCInfo = psDCInfo;
RESMAN_TYPE_DISPLAYCLASS_DEVICE,
psDCPerContextInfo,
0,
- CloseDCDeviceCallBack);
+ &CloseDCDeviceCallBack);
*phDeviceKM = (IMG_HANDLE)psDCPerContextInfo;
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCSystemBufferKM: Failed to get valid buffer handle from external driver"));
- return eError;
+ return eError;
}
IMG_EXPORT
-PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(IMG_HANDLE hSwapChain)
+PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(IMG_HANDLE hSwapChainRef)
{
PVRSRV_ERROR eError;
- PVRSRV_DC_SWAPCHAIN *psSwapChain;
+ PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef;
- if(!hSwapChain)
+ if(!hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDestroyDCSwapChainKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
- psSwapChain = hSwapChain;
+ psSwapChainRef = hSwapChainRef;
- eError = ResManFreeResByPtr(psSwapChain->hResItem);
+ eError = ResManFreeResByPtr(psSwapChainRef->hResItem);
return eError;
}
-static PVRSRV_ERROR DestroyDCSwapChainCallBack(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+static PVRSRV_ERROR DestroyDCSwapChain(PVRSRV_DC_SWAPCHAIN *psSwapChain)
{
PVRSRV_ERROR eError;
- PVRSRV_DC_SWAPCHAIN *psSwapChain = pvParam;
PVRSRV_DISPLAYCLASS_INFO *psDCInfo = psSwapChain->psDCInfo;
IMG_UINT32 i;
- PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+
+ if( psDCInfo->psDCSwapChainShared )
+ {
+ if( psDCInfo->psDCSwapChainShared == psSwapChain )
+ {
+ psDCInfo->psDCSwapChainShared = psSwapChain->psNext;
+ }
+ else
+ {
+ PVRSRV_DC_SWAPCHAIN *psCurrentSwapChain;
+ psCurrentSwapChain = psDCInfo->psDCSwapChainShared;
+ while( psCurrentSwapChain->psNext )
+ {
+ if( psCurrentSwapChain->psNext != psSwapChain )
+ {
+ psCurrentSwapChain = psCurrentSwapChain->psNext;
+ continue;
+ }
+ psCurrentSwapChain->psNext = psSwapChain->psNext;
+ break;
+ }
+ }
+ }
PVRSRVDestroyCommandQueueKM(psSwapChain->psQueue);
{
if(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
{
- PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ if (--psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+ {
+ PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ }
}
}
}
+static PVRSRV_ERROR DestroyDCSwapChainRefCallBack(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+{
+ PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef = (PVRSRV_DC_SWAPCHAIN_REF *) pvParam;
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+ if(--psSwapChainRef->psSwapChain->ui32RefCount == 0)
+ {
+ eError = DestroyDCSwapChain(psSwapChainRef->psSwapChain);
+ }
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN_REF), psSwapChainRef, IMG_NULL);
+ return eError;
+}
+
+static PVRSRV_DC_SWAPCHAIN* PVRSRVFindSharedDCSwapChainKM(PVRSRV_DISPLAYCLASS_INFO *psDCInfo,
+ IMG_UINT32 ui32SwapChainID)
+{
+ PVRSRV_DC_SWAPCHAIN *psCurrentSwapChain;
+
+ for(psCurrentSwapChain = psDCInfo->psDCSwapChainShared;
+ psCurrentSwapChain;
+ psCurrentSwapChain = psCurrentSwapChain->psNext)
+ {
+ if(psCurrentSwapChain->ui32SwapChainID == ui32SwapChainID)
+ return psCurrentSwapChain;
+ }
+ return IMG_NULL;
+}
+
+static PVRSRV_ERROR PVRSRVCreateDCSwapChainRefKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
+ PVRSRV_DC_SWAPCHAIN *psSwapChain,
+ PVRSRV_DC_SWAPCHAIN_REF **ppsSwapChainRef)
+{
+ PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef = IMG_NULL;
+
+
+ if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(PVRSRV_DC_SWAPCHAIN_REF),
+ (IMG_VOID **)&psSwapChainRef, IMG_NULL,
+ "Display Class Swapchain Reference") != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainRefKM: Failed psSwapChainRef alloc"));
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
+ OSMemSet (psSwapChainRef, 0, sizeof(PVRSRV_DC_SWAPCHAIN_REF));
+
+
+ psSwapChain->ui32RefCount++;
+
+
+ psSwapChainRef->psSwapChain = psSwapChain;
+ psSwapChainRef->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+ RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN_REF,
+ psSwapChainRef,
+ 0,
+ &DestroyDCSwapChainRefCallBack);
+ *ppsSwapChainRef = psSwapChainRef;
+
+ return PVRSRV_OK;
+}
+
IMG_EXPORT
PVRSRV_ERROR PVRSRVCreateDCSwapChainKM (PVRSRV_PER_PROCESS_DATA *psPerProc,
DISPLAY_SURF_ATTRIBUTES *psSrcSurfAttrib,
IMG_UINT32 ui32BufferCount,
IMG_UINT32 ui32OEMFlags,
- IMG_HANDLE *phSwapChain,
+ IMG_HANDLE *phSwapChainRef,
IMG_UINT32 *pui32SwapChainID)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain = IMG_NULL;
+ PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef = IMG_NULL;
PVRSRV_SYNC_DATA *apsSyncData[PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS];
PVRSRV_QUEUE_INFO *psQueue = IMG_NULL;
PVRSRV_ERROR eError;
IMG_UINT32 i;
+ DISPLAY_INFO sDisplayInfo;
if(!hDeviceKM
|| !psDstSurfAttrib
|| !psSrcSurfAttrib
- || !phSwapChain
+ || !phSwapChainRef
|| !pui32SwapChainID)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Invalid parameters"));
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+ if( ui32Flags & PVRSRV_CREATE_SWAPCHAIN_QUERY )
+ {
+
+ psSwapChain = PVRSRVFindSharedDCSwapChainKM(psDCInfo, *pui32SwapChainID );
+ if( psSwapChain )
+ {
+
+ eError = PVRSRVCreateDCSwapChainRefKM(psPerProc,
+ psSwapChain,
+ &psSwapChainRef);
+ if( eError != PVRSRV_OK )
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Couldn't create swap chain reference"));
+ return eError;
+ }
+
+ *phSwapChainRef = (IMG_HANDLE)psSwapChainRef;
+ return PVRSRV_OK;
+ }
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: No shared SwapChain found for query"));
+ return PVRSRV_ERROR_FLIP_CHAIN_EXISTS;
+ }
+
if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_DC_SWAPCHAIN),
(IMG_VOID **)&psSwapChain, IMG_NULL,
- "Display Class Swapchain") != PVRSRV_OK)
+ "Display Class Swapchain") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed psSwapChain alloc"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ErrorExit;
}
+ psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
+
psSwapChain->asBuffer[i].sDeviceClassBuffer.pfnGetBufferAddr = psDCInfo->psFuncTable->pfnGetBufferAddr;
psSwapChain->asBuffer[i].sDeviceClassBuffer.hDevMemContext = psDCInfo->hDevMemContext;
psSwapChain->ui32BufferCount = ui32BufferCount;
psSwapChain->psDCInfo = psDCInfo;
+#if defined(PDUMP)
+ PDUMPCOMMENT("Allocate DC swap chain (SwapChainID == %u, BufferCount == %u)",
+ *pui32SwapChainID,
+ ui32BufferCount);
+ PDUMPCOMMENT(" Src surface dimensions == %u x %u",
+ psSrcSurfAttrib->sDims.ui32Width,
+ psSrcSurfAttrib->sDims.ui32Height);
+ PDUMPCOMMENT(" Dst surface dimensions == %u x %u",
+ psDstSurfAttrib->sDims.ui32Width,
+ psDstSurfAttrib->sDims.ui32Height);
+#endif
+
+ eError = psDCInfo->psFuncTable->pfnGetDCInfo(psDCInfo->hExtDevice, &sDisplayInfo);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed to get DC info"));
+ return eError;
+ }
+
+ psSwapChain->ui32MinSwapInterval = sDisplayInfo.ui32MinSwapInterval;
+ psSwapChain->ui32MaxSwapInterval = sDisplayInfo.ui32MaxSwapInterval;
+
eError = psDCInfo->psFuncTable->pfnCreateDCSwapChain(psDCInfo->hExtDevice,
ui32Flags,
apsSyncData,
ui32OEMFlags,
&psSwapChain->hExtSwapChain,
- pui32SwapChainID);
+ &psSwapChain->ui32SwapChainID);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed to create 3rd party SwapChain"));
+ PDUMPCOMMENT("Swapchain allocation failed.");
goto ErrorExit;
}
+
+
+ eError = PVRSRVCreateDCSwapChainRefKM(psPerProc,
+ psSwapChain,
+ &psSwapChainRef);
+ if( eError != PVRSRV_OK )
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Couldn't create swap chain reference"));
+ PDUMPCOMMENT("Swapchain allocation failed.");
+ goto ErrorExit;
+ }
+
+ psSwapChain->ui32RefCount = 1;
+ psSwapChain->ui32Flags = ui32Flags;
+
-
- *phSwapChain = (IMG_HANDLE)psSwapChain;
+ if( ui32Flags & PVRSRV_CREATE_SWAPCHAIN_SHARED )
+ {
+ if(! psDCInfo->psDCSwapChainShared )
+ {
+ psDCInfo->psDCSwapChainShared = psSwapChain;
+ }
+ else
+ {
+ PVRSRV_DC_SWAPCHAIN *psOldHead = psDCInfo->psDCSwapChainShared;
+ psDCInfo->psDCSwapChainShared = psSwapChain;
+ psSwapChain->psNext = psOldHead;
+ }
+ }
+
+ *pui32SwapChainID = psSwapChain->ui32SwapChainID;
- psSwapChain->hResItem = ResManRegisterRes(psPerProc->hResManContext,
- RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN,
- psSwapChain,
- 0,
- DestroyDCSwapChainCallBack);
+ *phSwapChainRef= (IMG_HANDLE)psSwapChainRef;
return eError;
{
if(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
{
- PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ if (--psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+ {
+ PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ }
}
}
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDCDstRectKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain,
+ IMG_HANDLE hSwapChainRef,
IMG_RECT *psRect)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
- if(!hDeviceKM || !hSwapChain)
+ if(!hDeviceKM || !hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCDstRectKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
return psDCInfo->psFuncTable->pfnSetDCDstRect(psDCInfo->hExtDevice,
psSwapChain->hExtSwapChain,
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDCSrcRectKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain,
+ IMG_HANDLE hSwapChainRef,
IMG_RECT *psRect)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
- if(!hDeviceKM || !hSwapChain)
+ if(!hDeviceKM || !hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCSrcRectKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
return psDCInfo->psFuncTable->pfnSetDCSrcRect(psDCInfo->hExtDevice,
psSwapChain->hExtSwapChain,
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDCDstColourKeyKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain,
+ IMG_HANDLE hSwapChainRef,
IMG_UINT32 ui32CKColour)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
- if(!hDeviceKM || !hSwapChain)
+ if(!hDeviceKM || !hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCDstColourKeyKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
return psDCInfo->psFuncTable->pfnSetDCDstColourKey(psDCInfo->hExtDevice,
psSwapChain->hExtSwapChain,
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDCSrcColourKeyKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain,
+ IMG_HANDLE hSwapChainRef,
IMG_UINT32 ui32CKColour)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
- if(!hDeviceKM || !hSwapChain)
+ if(!hDeviceKM || !hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCSrcColourKeyKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
return psDCInfo->psFuncTable->pfnSetDCSrcColourKey(psDCInfo->hExtDevice,
psSwapChain->hExtSwapChain,
IMG_EXPORT
PVRSRV_ERROR PVRSRVGetDCBuffersKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain,
+ IMG_HANDLE hSwapChainRef,
IMG_UINT32 *pui32BufferCount,
IMG_HANDLE *phBuffer)
{
PVRSRV_ERROR eError;
IMG_UINT32 i;
- if(!hDeviceKM || !hSwapChain || !phBuffer)
+ if(!hDeviceKM || !hSwapChainRef || !phBuffer)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCBuffersKM: Invalid parameters"));
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCBuffersKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
eError = psDCInfo->psFuncTable->pfnGetDCBuffers(psDCInfo->hExtDevice,
PVRSRV_QUEUE_INFO *psQueue;
DISPLAYCLASS_FLIP_COMMAND *psFlipCmd;
IMG_UINT32 i;
+ IMG_BOOL bAddReferenceToLast = IMG_TRUE;
+ IMG_UINT16 ui16SwapCommandID = DC_FLIP_COMMAND;
IMG_UINT32 ui32NumSrcSyncs = 1;
PVRSRV_KERNEL_SYNC_INFO *apsSrcSync[2];
PVRSRV_COMMAND *psCommand;
return eError;
}
#endif
-
- psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
psBuffer = (PVRSRV_DC_BUFFER*)hBuffer;
+ psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
+
+ if(ui32SwapInterval < psBuffer->psSwapChain->ui32MinSwapInterval ||
+ ui32SwapInterval > psBuffer->psSwapChain->ui32MaxSwapInterval)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Invalid swap interval. Requested %u, Allowed range %u-%u",
+ ui32SwapInterval, psBuffer->psSwapChain->ui32MinSwapInterval, psBuffer->psSwapChain->ui32MaxSwapInterval));
+ return PVRSRV_ERROR_INVALID_SWAPINTERVAL;
+ }
+
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+
+ if(psDCInfo->psFuncTable->pfnQuerySwapCommandID != IMG_NULL)
+ {
+ psDCInfo->psFuncTable->pfnQuerySwapCommandID(psDCInfo->hExtDevice,
+ psBuffer->psSwapChain->hExtSwapChain,
+ psBuffer->sDeviceClassBuffer.hExtBuffer,
+ hPrivateTag,
+ &ui16SwapCommandID,
+ &bAddReferenceToLast);
+
+ }
+
+#endif
psQueue = psBuffer->psSwapChain->psQueue;
apsSrcSync[0] = psBuffer->sDeviceClassBuffer.psKernelSyncInfo;
- if(psBuffer->psSwapChain->psLastFlipBuffer &&
+
+
+
+ if(bAddReferenceToLast && psBuffer->psSwapChain->psLastFlipBuffer &&
psBuffer != psBuffer->psSwapChain->psLastFlipBuffer)
{
apsSrcSync[1] = psBuffer->psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo;
+
+
+
ui32NumSrcSyncs++;
}
eError = PVRSRVInsertCommandKM (psQueue,
&psCommand,
psDCInfo->ui32DeviceID,
- DC_FLIP_COMMAND,
+ ui16SwapCommandID,
0,
IMG_NULL,
ui32NumSrcSyncs,
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to get space in queue"));
goto Exit;
}
-
+
psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)psCommand->pvData;
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to submit command"));
goto Exit;
}
-
+
+
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
{
if(PVRSRVProcessQueues(KERNEL_ID, IMG_FALSE) != PVRSRV_ERROR_PROCESSING_BLOCKED)
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to process queues"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE;
goto Exit;
ProcessedQueues:
psBuffer->psSwapChain->psLastFlipBuffer = psBuffer;
Exit:
+
+ if(eError == PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE)
+ {
+ eError = PVRSRV_ERROR_RETRY;
+ }
+
#if defined(SUPPORT_LMA)
PVRSRVPowerUnlock(KERNEL_ID);
-#endif
+#endif
return eError;
}
IMG_EXPORT
PVRSRV_ERROR PVRSRVSwapToDCSystemKM(IMG_HANDLE hDeviceKM,
- IMG_HANDLE hSwapChain)
+ IMG_HANDLE hSwapChainRef)
{
PVRSRV_ERROR eError;
PVRSRV_QUEUE_INFO *psQueue;
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
+ PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef;
DISPLAYCLASS_FLIP_COMMAND *psFlipCmd;
IMG_UINT32 ui32NumSrcSyncs = 1;
PVRSRV_KERNEL_SYNC_INFO *apsSrcSync[2];
PVRSRV_COMMAND *psCommand;
+ IMG_BOOL bAddReferenceToLast = IMG_TRUE;
+ IMG_UINT16 ui16SwapCommandID = DC_FLIP_COMMAND;
- if(!hDeviceKM || !hSwapChain)
+ if(!hDeviceKM || !hSwapChainRef)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
return eError;
}
#endif
-
+
psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
- psSwapChain = (PVRSRV_DC_SWAPCHAIN*)hSwapChain;
+ psSwapChainRef = (PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef;
+ psSwapChain = psSwapChainRef->psSwapChain;
psQueue = psSwapChain->psQueue;
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+
+ if(psDCInfo->psFuncTable->pfnQuerySwapCommandID != IMG_NULL)
+ {
+ psDCInfo->psFuncTable->pfnQuerySwapCommandID(psDCInfo->hExtDevice,
+ psSwapChain->hExtSwapChain,
+ psDCInfo->sSystemBuffer.sDeviceClassBuffer.hExtBuffer,
+ 0,
+ &ui16SwapCommandID,
+ &bAddReferenceToLast);
+
+ }
+
+#endif
+
apsSrcSync[0] = psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo;
- if(psSwapChain->psLastFlipBuffer)
+
+
+
+ if(bAddReferenceToLast && psSwapChain->psLastFlipBuffer)
{
if (apsSrcSync[0] != psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo)
{
apsSrcSync[1] = psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo;
- ui32NumSrcSyncs++;
+
+
+
+ ui32NumSrcSyncs++;
}
}
eError = PVRSRVInsertCommandKM (psQueue,
&psCommand,
psDCInfo->ui32DeviceID,
- DC_FLIP_COMMAND,
+ ui16SwapCommandID,
0,
IMG_NULL,
ui32NumSrcSyncs,
+
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
{
if(PVRSRVProcessQueues(KERNEL_ID, IMG_FALSE) != PVRSRV_ERROR_PROCESSING_BLOCKED)
} END_LOOP_UNTIL_TIMEOUT();
PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Failed to process queues"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE;
goto Exit;
ProcessedQueues:
psSwapChain->psLastFlipBuffer = &psDCInfo->sSystemBuffer;
eError = PVRSRV_OK;
-
+
Exit:
+
+ if(eError == PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE)
+ {
+ eError = PVRSRV_ERROR_RETRY;
+ }
+
#if defined(SUPPORT_LMA)
PVRSRVPowerUnlock(KERNEL_ID);
-#endif
+#endif
return eError;
}
+static
PVRSRV_ERROR PVRSRVRegisterSystemISRHandler (PFN_ISR_HANDLER pfnISRHandler,
IMG_VOID *pvISRHandlerData,
IMG_UINT32 ui32ISRSourceMask,
psDevNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DeviceID,
IMG_TRUE);
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterSystemISRHandler: Failed to get psDevNode"));
PVR_DBG_BREAK;
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
}
return PVRSRV_OK;
}
+static
IMG_VOID PVRSRVSetDCState_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
IMG_UINT32 ui32State;
ui32State = va_arg(va, IMG_UINT32);
-
+
if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
{
psDCInfo = (PVRSRV_DISPLAYCLASS_INFO *)psDeviceNode->pvDevice;
if (psDCInfo->psFuncTable->pfnSetDCState && psDCInfo->hExtDevice)
{
psDCInfo->psFuncTable->pfnSetDCState(psDCInfo->hExtDevice, ui32State);
- }
+ }
}
}
SysAcquireData(&psSysData);
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
- PVRSRVSetDCState_ForEachVaCb,
+ &PVRSRVSetDCState_ForEachVaCb,
ui32State);
}
IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable)
{
psJTable->ui32TableSize = sizeof(PVRSRV_DC_DISP2SRV_KMJTABLE);
- psJTable->pfnPVRSRVRegisterDCDevice = PVRSRVRegisterDCDeviceKM;
- psJTable->pfnPVRSRVRemoveDCDevice = PVRSRVRemoveDCDeviceKM;
- psJTable->pfnPVRSRVOEMFunction = SysOEMFunction;
- psJTable->pfnPVRSRVRegisterCmdProcList = PVRSRVRegisterCmdProcListKM;
- psJTable->pfnPVRSRVRemoveCmdProcList = PVRSRVRemoveCmdProcListKM;
+ psJTable->pfnPVRSRVRegisterDCDevice = &PVRSRVRegisterDCDeviceKM;
+ psJTable->pfnPVRSRVRemoveDCDevice = &PVRSRVRemoveDCDeviceKM;
+ psJTable->pfnPVRSRVOEMFunction = &SysOEMFunction;
+ psJTable->pfnPVRSRVRegisterCmdProcList = &PVRSRVRegisterCmdProcListKM;
+ psJTable->pfnPVRSRVRemoveCmdProcList = &PVRSRVRemoveCmdProcListKM;
#if defined(SUPPORT_MISR_IN_THREAD)
- psJTable->pfnPVRSRVCmdComplete = OSVSyncMISR;
+ psJTable->pfnPVRSRVCmdComplete = &OSVSyncMISR;
#else
- psJTable->pfnPVRSRVCmdComplete = PVRSRVCommandCompleteKM;
+ psJTable->pfnPVRSRVCmdComplete = &PVRSRVCommandCompleteKM;
#endif
- psJTable->pfnPVRSRVRegisterSystemISRHandler = PVRSRVRegisterSystemISRHandler;
- psJTable->pfnPVRSRVRegisterPowerDevice = PVRSRVRegisterPowerDevice;
-
+ psJTable->pfnPVRSRVRegisterSystemISRHandler = &PVRSRVRegisterSystemISRHandler;
+ psJTable->pfnPVRSRVRegisterPowerDevice = &PVRSRVRegisterPowerDevice;
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+ psJTable->pfnPVRSRVFreeCmdCompletePacket = &PVRSRVFreeCommandCompletePacketKM;
+#endif
+
return IMG_TRUE;
}
eError = ResManFreeResByPtr(psBCPerContextInfo->hResItem);
-
+
return eError;
}
IMG_UINT32 i;
- psBCInfo->psFuncTable->pfnCloseBCDevice(psBCInfo->hExtDevice);
+ psBCInfo->psFuncTable->pfnCloseBCDevice(psBCInfo->ui32DeviceID, psBCInfo->hExtDevice);
for(i=0; i<psBCInfo->ui32BufferCount; i++)
{
if(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
{
- PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ if (--psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+ {
+ PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ }
}
}
if(psBCInfo->psBuffer)
{
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER), psBCInfo->psBuffer, IMG_NULL);
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER) * psBCInfo->ui32BufferCount, psBCInfo->psBuffer, IMG_NULL);
psBCInfo->psBuffer = IMG_NULL;
}
}
if(!phDeviceKM || !hDevCookie)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Invalid params"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DeviceID,
IMG_FALSE,
PVRSRV_DEVICE_CLASS_BUFFER);
if (!psDeviceNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: No devnode matching index %d", ui32DeviceID));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
}
psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDeviceNode->pvDevice;
-
+
psBCInfo->hDevMemContext = (IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext;
- eError = psBCInfo->psFuncTable->pfnOpenBCDevice(&psBCInfo->hExtDevice);
+ eError = psBCInfo->psFuncTable->pfnOpenBCDevice(ui32DeviceID, &psBCInfo->hExtDevice);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to open external BC device"));
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_BC_BUFFER) * sBufferInfo.ui32BufferCount,
- (IMG_VOID **)&psBCInfo->psBuffer,
+ (IMG_VOID **)&psBCInfo->psBuffer,
IMG_NULL,
"Array of Buffer Class Buffer");
if(eError != PVRSRV_OK)
OSMemSet (psBCInfo->psBuffer,
0,
sizeof(PVRSRV_BC_BUFFER) * sBufferInfo.ui32BufferCount);
-
+
for(i=0; i<psBCInfo->ui32BufferCount; i++)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed sync info alloc"));
goto ErrorExit;
}
+
+ psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
RESMAN_TYPE_BUFFERCLASS_DEVICE,
psBCPerContextInfo,
0,
- CloseBCDeviceCallBack);
-
+ &CloseBCDeviceCallBack);
+
*phDeviceKM = (IMG_HANDLE)psBCPerContextInfo;
{
if(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
{
- PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ if (--psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+ {
+ PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+ }
}
}
if(!hDeviceKM || !phBuffer)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCBufferKM: Invalid parameters"));
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCBufferKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
{
psJTable->ui32TableSize = sizeof(PVRSRV_BC_BUFFER2SRV_KMJTABLE);
- psJTable->pfnPVRSRVRegisterBCDevice = PVRSRVRegisterBCDeviceKM;
- psJTable->pfnPVRSRVRemoveBCDevice = PVRSRVRemoveBCDeviceKM;
+ psJTable->pfnPVRSRVRegisterBCDevice = &PVRSRVRegisterBCDeviceKM;
+ psJTable->pfnPVRSRVScheduleDevices = &PVRSRVScheduleDevicesKM;
+ psJTable->pfnPVRSRVRemoveBCDevice = &PVRSRVRemoveBCDeviceKM;
return IMG_TRUE;
}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef __DEVICEID_H__
+#define __DEVICEID_H__
+
+#include "services.h"
+#include "syscommon.h"
+
+PVRSRV_ERROR AllocateDeviceID(SYS_DATA *psSysData, IMG_UINT32 *pui32DevID);
+PVRSRV_ERROR FreeDeviceID(SYS_DATA *psSysData, IMG_UINT32 ui32DevID);
+
+#endif
PVRSRV_KERNEL_MEM_INFO *psSrcMemInfo;
} RESMAN_MAP_DEVICE_MEM_DATA;
+typedef struct _PVRSRV_DC_MAPINFO_
+{
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_UINT32 ui32RangeIndex;
+ IMG_UINT32 ui32TilingStride;
+} PVRSRV_DC_MAPINFO;
+
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapsKM(IMG_HANDLE hDevCookie,
*pui32ClientHeapCount = ui32ClientHeapCount;
*phDevMemContext = hDevMemContext;
-
+
return PVRSRV_OK;
}
*pui32ClientHeapCount = ui32ClientHeapCount;
-
+
return PVRSRV_OK;
}
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32Size;
-
+
psMemInfo->pvSysBackupBuffer = IMG_NULL;
return (PVRSRV_OK);
}
+static PVRSRV_ERROR FreeDeviceMem2(PVRSRV_KERNEL_MEM_INFO *psMemInfo, IMG_BOOL bFromAllocator)
+{
+ BM_HANDLE hBuffer;
+
+ if (!psMemInfo)
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ hBuffer = psMemInfo->sMemBlk.hBuffer;
+
+
+ if (bFromAllocator)
+ BM_Free(hBuffer, psMemInfo->ui32Flags);
+ else
+ BM_FreeExport(hBuffer, psMemInfo->ui32Flags);
+
+
+ if ((psMemInfo->pvSysBackupBuffer) && bFromAllocator)
+ {
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, psMemInfo->ui32AllocSize, psMemInfo->pvSysBackupBuffer, IMG_NULL);
+ psMemInfo->pvSysBackupBuffer = IMG_NULL;
+ }
+
+ if (psMemInfo->ui32RefCount == 0)
+ OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+
+
+ return(PVRSRV_OK);
+}
static PVRSRV_ERROR FreeDeviceMem(PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
+ psKernelSyncInfo->ui32RefCount = 0;
+
pBMContext = (BM_CONTEXT*)hDevMemContext;
psDevMemoryInfo = &pBMContext->psDeviceNode->sDevMemoryInfo;
psSyncData->ui32LastReadOpDumpVal = 0;
#if defined(PDUMP)
- PDUMPMEM(psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM,
+ PDUMPCOMMENT("Allocating kernel sync object");
+ PDUMPMEM(psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM,
psKernelSyncInfo->psSyncDataMemInfoKM,
0,
psKernelSyncInfo->psSyncDataMemInfoKM->ui32AllocSize,
psKernelSyncInfo->psSyncDataMemInfoKM->psKernelSyncInfo = IMG_NULL;
- psKernelSyncInfo->hResItem = IMG_NULL;
-
-
*ppsKernelSyncInfo = psKernelSyncInfo;
return PVRSRV_OK;
{
PVRSRV_ERROR eError;
+ if (psKernelSyncInfo->ui32RefCount != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "oops: sync info ref count not zero at destruction"));
+
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
+
eError = FreeDeviceMem(psKernelSyncInfo->psSyncDataMemInfoKM);
(IMG_VOID)OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL);
return eError;
}
+static IMG_VOID freeWrapped(PVRSRV_KERNEL_MEM_INFO *psMemInfo)
+{
+ IMG_HANDLE hOSWrapMem = psMemInfo->sMemBlk.hOSWrapMem;
-static PVRSRV_ERROR FreeDeviceMemCallBack(IMG_PVOID pvParam,
- IMG_UINT32 ui32Param)
+
+ if(psMemInfo->sMemBlk.psIntSysPAddr)
+ {
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
+ psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
+ }
+
+ if(hOSWrapMem)
+ {
+ OSReleasePhysPageAddr(hOSWrapMem);
+ }
+}
+
+static PVRSRV_ERROR FreeMemCallBackCommon(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32Param,
+ IMG_BOOL bFromAllocator)
{
PVRSRV_ERROR eError = PVRSRV_OK;
- PVRSRV_KERNEL_MEM_INFO *psMemInfo = pvParam;
PVR_UNREFERENCED_PARAMETER(ui32Param);
psMemInfo->ui32RefCount--;
- if(psMemInfo->ui32Flags & PVRSRV_MEM_EXPORTED)
+ if((psMemInfo->ui32Flags & PVRSRV_MEM_EXPORTED) && (bFromAllocator == IMG_TRUE))
{
IMG_HANDLE hMemInfo = IMG_NULL;
- if (psMemInfo->ui32RefCount != 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "FreeDeviceMemCallBack: mappings are open in other processes"));
- return PVRSRV_ERROR_GENERIC;
- }
-
-
eError = PVRSRVFindHandle(KERNEL_HANDLE_BASE,
&hMemInfo,
psMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
if(eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "FreeDeviceMemCallBack: can't find exported meminfo in the global handle list"));
+ PVR_DPF((PVR_DBG_ERROR, "FreeMemCallBackCommon: can't find exported meminfo in the global handle list"));
return eError;
}
-
+
eError = PVRSRVReleaseHandle(KERNEL_HANDLE_BASE,
hMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
if(eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "FreeDeviceMemCallBack: PVRSRVReleaseHandle failed for exported meminfo"));
+ PVR_DPF((PVR_DBG_ERROR, "FreeMemCallBackCommon: PVRSRVReleaseHandle failed for exported meminfo"));
return eError;
}
}
- PVR_ASSERT(psMemInfo->ui32RefCount == 0);
-
- if (psMemInfo->psKernelSyncInfo)
+
+ if (psMemInfo->ui32RefCount == 0)
{
- eError = PVRSRVFreeSyncInfoKM(psMemInfo->psKernelSyncInfo);
+ switch(psMemInfo->memType)
+ {
+
+ case PVRSRV_MEMTYPE_WRAPPED:
+ freeWrapped(psMemInfo);
+ case PVRSRV_MEMTYPE_DEVICE:
+ if (psMemInfo->psKernelSyncInfo)
+ {
+ psMemInfo->psKernelSyncInfo->ui32RefCount--;
+
+ if (psMemInfo->psKernelSyncInfo->ui32RefCount == 0)
+ {
+ eError = PVRSRVFreeSyncInfoKM(psMemInfo->psKernelSyncInfo);
+ }
+ }
+ case PVRSRV_MEMTYPE_DEVICECLASS:
+ break;
+ default:
+ PVR_DPF((PVR_DBG_ERROR, "FreeMemCallBackCommon: Unknown memType"));
+ eError = PVRSRV_ERROR_INVALID_MEMINFO;
+ }
}
- if (eError == PVRSRV_OK)
- {
- eError = FreeDeviceMem(psMemInfo);
- }
+
+
+ eError = FreeDeviceMem2(psMemInfo, bFromAllocator);
return eError;
}
+static PVRSRV_ERROR FreeDeviceMemCallBack(IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param)
+{
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo = (PVRSRV_KERNEL_MEM_INFO *)pvParam;
+
+ return FreeMemCallBackCommon(psMemInfo, ui32Param, IMG_TRUE);
+}
+
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie,
if (psMemInfo->sMemBlk.hResItem != IMG_NULL)
{
- eError = ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
+ eError = ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
}
else
{
if (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
{
+
if (((ui32Size % HOST_PAGESIZE()) != 0) ||
((ui32Alignment % HOST_PAGESIZE()) != 0))
{
{
goto free_mainalloc;
}
+ psMemInfo->psKernelSyncInfo->ui32RefCount++;
}
RESMAN_TYPE_DEVICEMEM_ALLOCATION,
psMemInfo,
0,
- FreeDeviceMemCallBack);
+ &FreeDeviceMemCallBack);
if (psMemInfo->sMemBlk.hResItem == IMG_NULL)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto free_mainalloc;
}
- }
+ }
psMemInfo->ui32RefCount++;
+ psMemInfo->memType = PVRSRV_MEMTYPE_DEVICE;
+
return (PVRSRV_OK);
}
-IMG_EXPORT
+IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetFreeDeviceMemKM(IMG_UINT32 ui32Flags,
IMG_SIZE_T *pui32Total,
IMG_SIZE_T *pui32Free,
static PVRSRV_ERROR UnwrapExtMemoryCallBack(IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
- PVRSRV_KERNEL_MEM_INFO *psMemInfo = pvParam;
- IMG_HANDLE hOSWrapMem;
-
- PVR_UNREFERENCED_PARAMETER(ui32Param);
-
- hOSWrapMem = psMemInfo->sMemBlk.hOSWrapMem;
-
- if (psMemInfo->psKernelSyncInfo)
- {
- eError = PVRSRVFreeSyncInfoKM(psMemInfo->psKernelSyncInfo);
- }
-
-
- if(psMemInfo->sMemBlk.psIntSysPAddr)
- {
- OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
- psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
- }
-
- if (eError == PVRSRV_OK)
- {
-
- psMemInfo->ui32RefCount--;
-
- eError = FreeDeviceMem(psMemInfo);
- }
-
- if(hOSWrapMem)
- {
- OSReleasePhysPageAddr(hOSWrapMem);
- }
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo = (PVRSRV_KERNEL_MEM_INFO *)pvParam;
- return eError;
+ return FreeMemCallBackCommon(psMemInfo, ui32Param, IMG_TRUE);
}
IMG_BOOL bPhysContig,
IMG_SYS_PHYADDR *psExtSysPAddr,
IMG_VOID *pvLinAddr,
+ IMG_UINT32 ui32Flags,
PVRSRV_KERNEL_MEM_INFO **ppsMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
DEVICE_MEMORY_INFO *psDevMemoryInfo;
- IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
+ IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
IMG_HANDLE hDevMemHeap = IMG_NULL;
PVRSRV_DEVICE_NODE* psDeviceNode;
BM_HANDLE hBuffer;
IMG_VOID *pvPageAlignedCPUVAddr;
IMG_SYS_PHYADDR *psIntSysPAddr = IMG_NULL;
IMG_HANDLE hOSWrapMem = IMG_NULL;
- DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
- IMG_SIZE_T ui32PageCount = 0;
+ DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
IMG_UINT32 i;
-
+ IMG_SIZE_T ui32PageCount = 0;
+
+
psDeviceNode = (PVRSRV_DEVICE_NODE*)hDevCookie;
PVR_ASSERT(psDeviceNode != IMG_NULL);
ui32PageCount = HOST_PAGEALIGN(ui32ByteSize + ui32PageOffset) / ui32HostPageSize;
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvLinAddr - ui32PageOffset);
-
+
if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
ui32PageCount * sizeof(IMG_SYS_PHYADDR),
{
}
-
+
psDevMemoryInfo = &((BM_CONTEXT*)hDevMemContext)->psDeviceNode->sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
{
- hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
+ hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
}
else
{
hDevMemHeap = psDevMemoryInfo->psDeviceMemoryHeap[i].hDevMemHeap;
}
break;
- }
- }
+ }
+ }
if(hDevMemHeap == IMG_NULL)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: unable to find mapping heap"));
- eError = PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: unable to find mapping heap"));
+ eError = PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP;
goto ErrorExitPhase2;
}
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+ psMemInfo->ui32Flags = ui32Flags;
psMemBlock = &(psMemInfo->sMemBlk);
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: BM_Wrap Failed"));
eError = PVRSRV_ERROR_BAD_MAPPING;
- goto ErrorExitPhase3;
+ goto ErrorExitPhase3;
}
goto ErrorExitPhase4;
}
+ psMemInfo->psKernelSyncInfo->ui32RefCount++;
+
psMemInfo->ui32RefCount++;
+ psMemInfo->memType = PVRSRV_MEMTYPE_WRAPPED;
+
psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICEMEM_WRAP,
psMemInfo,
0,
- UnwrapExtMemoryCallBack);
+ &UnwrapExtMemoryCallBack);
*ppsMemInfo = psMemInfo;
-
+
return PVRSRV_OK;
{
OSReleasePhysPageAddr(hOSWrapMem);
}
-
+
ErrorExitPhase1:
if(psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageCount * sizeof(IMG_SYS_PHYADDR), psIntSysPAddr, IMG_NULL);
}
-
+
return eError;
}
}
-static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam,
+static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
{
PVRSRV_ERROR eError;
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMapData->psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
psMapData->psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
}
+
+ if( psMapData->psMemInfo->psKernelSyncInfo )
+ {
+ psMapData->psMemInfo->psKernelSyncInfo->ui32RefCount--;
+ if (psMapData->psMemInfo->psKernelSyncInfo->ui32RefCount == 0)
+ {
+ eError = PVRSRVFreeSyncInfoKM(psMapData->psMemInfo->psKernelSyncInfo);
+ if(eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free sync info"));
+ return eError;
+ }
+ }
+ }
eError = FreeDeviceMem(psMapData->psMemInfo);
if(eError != PVRSRV_OK)
}
- psMapData->psSrcMemInfo->ui32RefCount--;
-
- if (psMapData->psSrcMemInfo->ui32RefCount == 1 &&
- psMapData->psSrcMemInfo->bPendingFree == IMG_TRUE)
- {
-
-
-
- if (psMapData->psSrcMemInfo->sMemBlk.hResItem != IMG_NULL)
- {
-
-
- eError = ResManFreeResByPtr(psMapData->psSrcMemInfo->sMemBlk.hResItem);
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free SRC meminfo"));
- PVR_DBG_BREAK;
- }
- }
- else
- {
-
- eError = FreeDeviceMemCallBack(psMapData->psSrcMemInfo, 0);
- }
- }
+ eError = FreeMemCallBackCommon(psMapData->psSrcMemInfo, 0, IMG_FALSE);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
-
+
return eError;
}
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
PVRSRV_DEVICE_NODE *psDeviceNode;
- IMG_VOID *pvPageAlignedCPUVAddr;
+ IMG_VOID *pvPageAlignedCPUVAddr;
RESMAN_MAP_DEVICE_MEM_DATA *psMapData = IMG_NULL;
*ppsDstMemInfo = IMG_NULL;
-
+
ui32PageOffset = psSrcMemInfo->sDevVAddr.uiAddr & (ui32HostPageSize - 1);
ui32PageCount = HOST_PAGEALIGN(psSrcMemInfo->ui32AllocSize + ui32PageOffset) / ui32HostPageSize;
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)psSrcMemInfo->pvLinAddrKM - ui32PageOffset);
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc resman map data"));
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
- goto ErrorExit;
+ goto ErrorExit;
}
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: BM_Wrap Failed"));
eError = PVRSRV_ERROR_BAD_MAPPING;
- goto ErrorExit;
+ goto ErrorExit;
}
psMemBlock->psIntSysPAddr = psSysPAddr;
-
+
psMemInfo->pvLinAddrKM = psSrcMemInfo->pvLinAddrKM;
psMemInfo->psKernelSyncInfo = psSrcMemInfo->psKernelSyncInfo;
+ if( psMemInfo->psKernelSyncInfo )
+ psMemInfo->psKernelSyncInfo->ui32RefCount++;
+
+
psMemInfo->pvSysBackupBuffer = IMG_NULL;
+ psMemInfo->ui32RefCount++;
+
+
psSrcMemInfo->ui32RefCount++;
+
+ BM_Export(psSrcMemInfo->sMemBlk.hBuffer);
+
+ psMemInfo->memType = PVRSRV_MEMTYPE_MAPPED;
+
psMapData->psMemInfo = psMemInfo;
psMapData->psSrcMemInfo = psSrcMemInfo;
RESMAN_TYPE_DEVICEMEM_MAPPING,
psMapData,
0,
- UnmapDeviceMemoryCallBack);
+ &UnmapDeviceMemoryCallBack);
*ppsDstMemInfo = psMemInfo;
return PVRSRV_OK;
-
+
ErrorExit:
if(psSysPAddr)
}
-static PVRSRV_ERROR UnmapDeviceClassMemoryCallBack(IMG_PVOID pvParam,
+static PVRSRV_ERROR UnmapDeviceClassMemoryCallBack(IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
{
- PVRSRV_KERNEL_MEM_INFO *psMemInfo = pvParam;
+ PVRSRV_DC_MAPINFO *psDCMapInfo = pvParam;
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo;
PVR_UNREFERENCED_PARAMETER(ui32Param);
- return FreeDeviceMem(psMemInfo);
+ psMemInfo = psDCMapInfo->psMemInfo;
+
+#if defined(SUPPORT_MEMORY_TILING)
+ if(psDCMapInfo->ui32TilingStride > 0)
+ {
+ PVRSRV_DEVICE_NODE *psDeviceNode = psDCMapInfo->psDeviceNode;
+
+ if (psDeviceNode->pfnFreeMemTilingRange(psDeviceNode,
+ psDCMapInfo->ui32RangeIndex) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceClassMemoryCallBack: FreeMemTilingRange failed"));
+ }
+ }
+#endif
+
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_MAPINFO), psDCMapInfo, IMG_NULL);
+
+ return FreeMemCallBackCommon(psMemInfo, ui32Param, IMG_TRUE);
}
IMG_HANDLE *phOSMapInfo)
{
PVRSRV_ERROR eError;
- PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+ PVRSRV_DEVICE_NODE* psDeviceNode;
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
PVRSRV_DEVICECLASS_BUFFER *psDeviceClassBuffer;
IMG_SYS_PHYADDR *psSysPAddr;
IMG_VOID *pvCPUVAddr, *pvPageAlignedCPUVAddr;
PVRSRV_MEMBLK *psMemBlock;
IMG_BOOL bBMError;
IMG_UINT32 i;
+ PVRSRV_DC_MAPINFO *psDCMapInfo = IMG_NULL;
if(!hDeviceClassBuffer || !ppsMemInfo || !phOSMapInfo || !hDevMemContext)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: invalid parameters"));
- return PVRSRV_ERROR_INVALID_PARAMS;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
+
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(PVRSRV_DC_MAPINFO),
+ (IMG_VOID **)&psDCMapInfo, IMG_NULL,
+ "PVRSRV_DC_MAPINFO") != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for psDCMapInfo"));
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
+ OSMemSet(psDCMapInfo, 0, sizeof(PVRSRV_DC_MAPINFO));
+
psDeviceClassBuffer = (PVRSRV_DEVICECLASS_BUFFER*)hDeviceClassBuffer;
-
+
&ui32ByteSize,
&pvCPUVAddr,
phOSMapInfo,
- &bPhysContig);
+ &bPhysContig,
+ &psDCMapInfo->ui32TilingStride);
if(eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to get buffer address"));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to get buffer address"));
+ goto ErrorExitPhase1;
}
psBMContext = (BM_CONTEXT*)psDeviceClassBuffer->hDevMemContext;
- psDevMemoryInfo = &psBMContext->psDeviceNode->sDevMemoryInfo;
+ psDeviceNode = psBMContext->psDeviceNode;
+ psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
for(i=0; i<PVRSRV_MAX_CLIENT_HEAPS; i++)
{
if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
{
- hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
+ hDevMemHeap = BM_CreateHeap(hDevMemContext, &psDeviceMemoryHeap[i]);
}
else
{
hDevMemHeap = psDevMemoryInfo->psDeviceMemoryHeap[i].hDevMemHeap;
}
break;
- }
- }
+ }
+ }
if(hDevMemHeap == IMG_NULL)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to find mapping heap"));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to find mapping heap"));
+ eError = PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE;
+ goto ErrorExitPhase1;
}
ui32Offset = ((IMG_UINTPTR_T)pvCPUVAddr) & (ui32PageSize - 1);
pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvCPUVAddr - ui32Offset);
- if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+ eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_KERNEL_MEM_INFO),
(IMG_VOID **)&psMemInfo, IMG_NULL,
- "Kernel Memory Info") != PVRSRV_OK)
+ "Kernel Memory Info");
+ if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for block"));
- return (PVRSRV_ERROR_OUT_OF_MEMORY);
+ goto ErrorExitPhase1;
}
OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
if (!bBMError)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: BM_Wrap Failed"));
- OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
- return PVRSRV_ERROR_BAD_MAPPING;
+ eError = PVRSRV_ERROR_BAD_MAPPING;
+ goto ErrorExitPhase2;
}
psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
-
+
psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
psMemInfo->ui32AllocSize = ui32ByteSize;
psMemInfo->pvSysBackupBuffer = IMG_NULL;
+ psDCMapInfo->psMemInfo = psMemInfo;
+
+#if defined(SUPPORT_MEMORY_TILING)
+ psDCMapInfo->psDeviceNode = psDeviceNode;
+
+ if(psDCMapInfo->ui32TilingStride > 0)
+ {
+
+ eError = psDeviceNode->pfnAllocMemTilingRange(psDeviceNode,
+ psMemInfo,
+ psDCMapInfo->ui32TilingStride,
+ &psDCMapInfo->ui32RangeIndex);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: AllocMemTilingRange failed"));
+ goto ErrorExitPhase3;
+ }
+ }
+#endif
+
+
psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_DEVICECLASSMEM_MAPPING,
- psMemInfo,
+ psDCMapInfo,
0,
- UnmapDeviceClassMemoryCallBack);
+ &UnmapDeviceClassMemoryCallBack);
+
+ psMemInfo->ui32RefCount++;
+
+ psMemInfo->memType = PVRSRV_MEMTYPE_DEVICECLASS;
*ppsMemInfo = psMemInfo;
- return PVRSRV_OK;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ PDUMPCOMMENT("Dump display surface");
+ PDUMPMEM(IMG_NULL, psMemInfo, ui32Offset, psMemInfo->ui32AllocSize, PDUMP_FLAGS_CONTINUOUS, ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping);
+#endif
+ return PVRSRV_OK;
+
+#if defined(SUPPORT_MEMORY_TILING)
+ErrorExitPhase3:
+ if(psMemInfo)
+ {
+ FreeDeviceMem(psMemInfo);
+
+
+
+ psMemInfo = IMG_NULL;
+ }
+#endif
+
+ErrorExitPhase2:
+ if(psMemInfo)
+ {
+ OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+ }
+
+ErrorExitPhase1:
+ if(psDCMapInfo)
+ {
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psDCMapInfo, IMG_NULL);
+ }
+
+ return eError;
}
#include "services_headers.h"
#include "handle.h"
-#ifdef DEBUG_PVR
-#define HANDLE_BLOCK_SIZE 1
+#ifdef DEBUG
+#define HANDLE_BLOCK_SHIFT 2
#else
-#define HANDLE_BLOCK_SIZE 256
+#define HANDLE_BLOCK_SHIFT 8
#endif
-#define HANDLE_HASH_TAB_INIT_SIZE 32
+#define DIVIDE_BY_BLOCK_SIZE(i) (((IMG_UINT32)(i)) >> HANDLE_BLOCK_SHIFT)
+#define MULTIPLY_BY_BLOCK_SIZE(i) (((IMG_UINT32)(i)) << HANDLE_BLOCK_SHIFT)
+
+#define HANDLE_BLOCK_SIZE MULTIPLY_BY_BLOCK_SIZE(1)
+#define HANDLE_SUB_BLOCK_MASK (HANDLE_BLOCK_SIZE - 1)
+#define HANDLE_BLOCK_MASK (~(HANDLE_SUB_BLOCK_MASK))
-#define DEFAULT_MAX_INDEX_PLUS_ONE 0xfffffffful
-#define DEFAULT_MAX_HANDLE DEFAULT_MAX_INDEX_PLUS_ONE
+#define HANDLE_HASH_TAB_INIT_SIZE 32
#define INDEX_IS_VALID(psBase, i) ((i) < (psBase)->ui32TotalHandCount)
-#define INDEX_TO_HANDLE(psBase, idx) ((IMG_HANDLE)((idx) + 1))
-#define HANDLE_TO_INDEX(psBase, hand) ((IMG_UINT32)(hand) - 1)
+#define INDEX_TO_HANDLE(i) ((IMG_HANDLE)((i) + 1))
+#define HANDLE_TO_INDEX(h) ((IMG_UINT32)(h) - 1)
+
+#define INDEX_TO_BLOCK_INDEX(i) DIVIDE_BY_BLOCK_SIZE(i)
+#define BLOCK_INDEX_TO_INDEX(i) MULTIPLY_BY_BLOCK_SIZE(i)
+#define INDEX_TO_SUB_BLOCK_INDEX(i) ((i) & HANDLE_SUB_BLOCK_MASK)
+
+#define INDEX_TO_INDEX_STRUCT_PTR(psArray, i) (&((psArray)[INDEX_TO_BLOCK_INDEX(i)]))
+#define BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i) INDEX_TO_INDEX_STRUCT_PTR((psBase)->psHandleArray, i)
+
+#define INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, i) (BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i)->ui32FreeHandBlockCount)
+
+#define INDEX_TO_HANDLE_STRUCT_PTR(psBase, i) (BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, i)->psHandle + INDEX_TO_SUB_BLOCK_INDEX(i))
+
+#define HANDLE_TO_HANDLE_STRUCT_PTR(psBase, h) (INDEX_TO_HANDLE_STRUCT_PTR(psBase, HANDLE_TO_INDEX(h)))
-#define INDEX_TO_HANDLE_PTR(psBase, i) (((psBase)->psHandleArray) + (i))
-#define HANDLE_TO_HANDLE_PTR(psBase, h) (INDEX_TO_HANDLE_PTR(psBase, HANDLE_TO_INDEX(psBase, h)))
+#define HANDLE_PTR_TO_INDEX(psHandle) ((psHandle)->ui32Index)
+#define HANDLE_PTR_TO_HANDLE(psHandle) INDEX_TO_HANDLE(HANDLE_PTR_TO_INDEX(psHandle))
-#define HANDLE_PTR_TO_INDEX(psBase, psHandle) (IMG_UINT32)((psHandle) - ((psBase)->psHandleArray))
-#define HANDLE_PTR_TO_HANDLE(psBase, psHandle) \
- INDEX_TO_HANDLE(psBase, HANDLE_PTR_TO_INDEX(psBase, psHandle))
+#define ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(a) (HANDLE_BLOCK_MASK & (a))
+#define ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(a) ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE((a) + HANDLE_BLOCK_SIZE - 1)
-#define ROUND_UP_TO_MULTIPLE(a, b) ((((a) + (b) - 1) / (b)) * (b))
+#define DEFAULT_MAX_HANDLE 0x7fffffffu
+#define DEFAULT_MAX_INDEX_PLUS_ONE ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(DEFAULT_MAX_HANDLE)
#define HANDLES_BATCHED(psBase) ((psBase)->ui32HandBatchSize != 0)
+#define HANDLE_ARRAY_SIZE(handleCount) DIVIDE_BY_BLOCK_SIZE(ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(handleCount))
+
#define SET_FLAG(v, f) ((IMG_VOID)((v) |= (f)))
#define CLEAR_FLAG(v, f) ((IMG_VOID)((v) &= ~(f)))
#define TEST_FLAG(v, f) ((IMG_BOOL)(((v) & (f)) != 0))
struct sHandleList sSiblings;
};
+struct sHandleIndex
+{
+
+ struct sHandle *psHandle;
+
+
+ IMG_HANDLE hBlockAlloc;
+
+
+ IMG_UINT32 ui32FreeHandBlockCount;
+};
+
struct _PVRSRV_HANDLE_BASE_
{
IMG_HANDLE hBaseBlockAlloc;
- IMG_HANDLE hHandBlockAlloc;
+ IMG_HANDLE hArrayBlockAlloc;
- struct sHandle *psHandleArray;
+ struct sHandleIndex *psHandleArray;
HASH_TABLE *psHashTab;
#pragma inline(InitParentList)
#endif
static INLINE
-IMG_VOID InitParentList(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
+IMG_VOID InitParentList(struct sHandle *psHandle)
{
- IMG_UINT32 ui32Parent = HANDLE_PTR_TO_INDEX(psBase, psHandle);
+ IMG_UINT32 ui32Parent = HANDLE_PTR_TO_INDEX(psHandle);
- HandleListInit(ui32Parent, &psHandle->sChildren, INDEX_TO_HANDLE(psBase, ui32Parent));
+ HandleListInit(ui32Parent, &psHandle->sChildren, INDEX_TO_HANDLE(ui32Parent));
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(InitChildEntry)
#endif
static INLINE
-IMG_VOID InitChildEntry(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
+IMG_VOID InitChildEntry(struct sHandle *psHandle)
{
- HandleListInit(HANDLE_PTR_TO_INDEX(psBase, psHandle), &psHandle->sSiblings, IMG_NULL);
+ HandleListInit(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, IMG_NULL);
}
#ifdef INLINE_IS_PRAGMA
bIsEmpty = (IMG_BOOL)(psList->ui32Next == ui32Index);
-#ifdef DEBUG_PVR
+#ifdef DEBUG
{
IMG_BOOL bIsEmpty2;
return bIsEmpty;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
#ifdef INLINE_IS_PRAGMA
#pragma inline(NoChildren)
#endif
static INLINE
-IMG_BOOL NoChildren(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
+IMG_BOOL NoChildren(struct sHandle *psHandle)
{
- PVR_ASSERT(psHandle->sChildren.hParent == HANDLE_PTR_TO_HANDLE(psBase, psHandle));
+ PVR_ASSERT(psHandle->sChildren.hParent == HANDLE_PTR_TO_HANDLE(psHandle));
- return HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psBase, psHandle), &psHandle->sChildren);
+ return HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sChildren);
}
#ifdef INLINE_IS_PRAGMA
#pragma inline(NoParent)
#endif
static INLINE
-IMG_BOOL NoParent(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
+IMG_BOOL NoParent(struct sHandle *psHandle)
{
- if (HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psBase, psHandle), &psHandle->sSiblings))
+ if (HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings))
{
PVR_ASSERT(psHandle->sSiblings.hParent == IMG_NULL);
}
#define LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, i, p, po, eo) \
- ((struct sHandleList *)((IMG_CHAR *)(INDEX_TO_HANDLE_PTR(psBase, i)) + (((i) == (p)) ? (po) : (eo))))
+ ((struct sHandleList *)((IMG_CHAR *)(INDEX_TO_HANDLE_STRUCT_PTR(psBase, i)) + (((i) == (p)) ? (po) : (eo))))
#ifdef INLINE_IS_PRAGMA
#pragma inline(HandleListInsertBefore)
PVR_ASSERT(psEntry->hParent == IMG_NULL);
PVR_ASSERT(ui32InsIndex == psPrevIns->ui32Next);
- PVR_ASSERT(LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32ParentIndex, ui32ParentIndex, uiParentOffset, uiParentOffset)->hParent == INDEX_TO_HANDLE(psBase, ui32ParentIndex));
+ PVR_ASSERT(LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32ParentIndex, ui32ParentIndex, uiParentOffset, uiParentOffset)->hParent == INDEX_TO_HANDLE(ui32ParentIndex));
psEntry->ui32Prev = psIns->ui32Prev;
psIns->ui32Prev = ui32EntryIndex;
psEntry->ui32Next = ui32InsIndex;
psPrevIns->ui32Next = ui32EntryIndex;
- psEntry->hParent = INDEX_TO_HANDLE(psBase, ui32ParentIndex);
+ psEntry->hParent = INDEX_TO_HANDLE(ui32ParentIndex);
}
#ifdef INLINE_IS_PRAGMA
static INLINE
IMG_VOID AdoptChild(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, struct sHandle *psChild)
{
- IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psBase, psParent->sChildren.hParent);
+ IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psParent->sChildren.hParent);
- PVR_ASSERT(ui32Parent == HANDLE_PTR_TO_INDEX(psBase, psParent));
+ PVR_ASSERT(ui32Parent == HANDLE_PTR_TO_INDEX(psParent));
- HandleListInsertBefore(psBase, ui32Parent, &psParent->sChildren, offsetof(struct sHandle, sChildren), HANDLE_PTR_TO_INDEX(psBase, psChild), &psChild->sSiblings, offsetof(struct sHandle, sSiblings), ui32Parent);
+ HandleListInsertBefore(psBase, ui32Parent, &psParent->sChildren, offsetof(struct sHandle, sChildren), HANDLE_PTR_TO_INDEX(psChild), &psChild->sSiblings, offsetof(struct sHandle, sSiblings), ui32Parent);
}
if (!HandleListIsEmpty(ui32EntryIndex, psEntry))
{
- struct sHandleList *psPrev = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Prev, HANDLE_TO_INDEX(psBase, psEntry->hParent), uiParentOffset, uiEntryOffset);
- struct sHandleList *psNext = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Next, HANDLE_TO_INDEX(psBase, psEntry->hParent), uiParentOffset, uiEntryOffset);
+ struct sHandleList *psPrev = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Prev, HANDLE_TO_INDEX(psEntry->hParent), uiParentOffset, uiEntryOffset);
+ struct sHandleList *psNext = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psEntry->ui32Next, HANDLE_TO_INDEX(psEntry->hParent), uiParentOffset, uiEntryOffset);
PVR_ASSERT(psEntry->hParent != IMG_NULL);
static INLINE
IMG_VOID UnlinkFromParent(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
{
- HandleListRemove(psBase, HANDLE_PTR_TO_INDEX(psBase, psHandle), &psHandle->sSiblings, offsetof(struct sHandle, sSiblings), offsetof(struct sHandle, sChildren));
+ HandleListRemove(psBase, HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, offsetof(struct sHandle, sSiblings), offsetof(struct sHandle, sChildren));
}
#ifdef INLINE_IS_PRAGMA
PVRSRV_ERROR HandleListIterate(PVRSRV_HANDLE_BASE *psBase, struct sHandleList *psHead, IMG_SIZE_T uiParentOffset, IMG_SIZE_T uiEntryOffset, PVRSRV_ERROR (*pfnIterFunc)(PVRSRV_HANDLE_BASE *, struct sHandle *))
{
IMG_UINT32 ui32Index;
- IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psBase, psHead->hParent);
+ IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psHead->hParent);
PVR_ASSERT(psHead->hParent != IMG_NULL);
for(ui32Index = psHead->ui32Next; ui32Index != ui32Parent; )
{
- struct sHandle *psHandle = INDEX_TO_HANDLE_PTR(psBase, ui32Index);
+ struct sHandle *psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32Index);
struct sHandleList *psEntry = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, ui32Index, ui32Parent, uiParentOffset, uiEntryOffset);
PVRSRV_ERROR eError;
static INLINE
PVRSRV_ERROR GetHandleStructure(PVRSRV_HANDLE_BASE *psBase, struct sHandle **ppsHandle, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
{
- IMG_UINT32 ui32Index = HANDLE_TO_INDEX(psBase, hHandle);
+ IMG_UINT32 ui32Index = HANDLE_TO_INDEX(hHandle);
struct sHandle *psHandle;
if (!INDEX_IS_VALID(psBase, ui32Index))
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle index out of range (%u >= %u)", ui32Index, psBase->ui32TotalHandCount));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE;
}
- psHandle = INDEX_TO_HANDLE_PTR(psBase, ui32Index);
+ psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32Index);
if (psHandle->eType == PVRSRV_HANDLE_TYPE_NONE)
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle not allocated (index: %u)", ui32Index));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_NOT_ALLOCATED;
}
if (eType != PVRSRV_HANDLE_TYPE_NONE && eType != psHandle->eType)
{
PVR_DPF((PVR_DBG_ERROR, "GetHandleStructure: Handle type mismatch (%d != %d)", eType, psHandle->eType));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_TYPE_MISMATCH;
}
return TEST_ALLOC_FLAG(psHandle, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ?
ParentHandle(psHandle) : IMG_NULL;
}
-
+
#ifdef INLINE_IS_PRAGMA
#pragma inline(InitKey)
#endif
aKey[HAND_KEY_PARENT] = (IMG_UINTPTR_T)hParent;
}
-static PVRSRV_ERROR FreeHandleArray(PVRSRV_HANDLE_BASE *psBase)
+static
+PVRSRV_ERROR ReallocHandleArray(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32NewCount)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ struct sHandleIndex *psOldArray = psBase->psHandleArray;
+ IMG_HANDLE hOldArrayBlockAlloc = psBase->hArrayBlockAlloc;
+ IMG_UINT32 ui32OldCount = psBase->ui32TotalHandCount;
+ struct sHandleIndex *psNewArray = IMG_NULL;
+ IMG_HANDLE hNewArrayBlockAlloc = IMG_NULL;
+ PVRSRV_ERROR eError;
+ PVRSRV_ERROR eReturn = PVRSRV_OK;
+ IMG_UINT32 ui32Index;
- if (psBase->psHandleArray != IMG_NULL)
+ if (ui32NewCount == ui32OldCount)
{
+ return PVRSRV_OK;
+ }
+
+ if (ui32NewCount != 0 && !psBase->bPurgingEnabled &&
+ ui32NewCount < ui32OldCount)
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ if (((ui32OldCount % HANDLE_BLOCK_SIZE) != 0) ||
+ ((ui32NewCount % HANDLE_BLOCK_SIZE) != 0))
+ {
+ PVR_ASSERT((ui32OldCount % HANDLE_BLOCK_SIZE) == 0);
+ PVR_ASSERT((ui32NewCount % HANDLE_BLOCK_SIZE) == 0);
+
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ if (ui32NewCount != 0)
+ {
+
+ eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ HANDLE_ARRAY_SIZE(ui32NewCount) * sizeof(struct sHandleIndex),
+ (IMG_VOID **)&psNewArray,
+ &hNewArrayBlockAlloc,
+ "Memory Area");
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't allocate new handle array (%d)", eError));
+ eReturn = eError;
+ goto error;
+ }
+
+ if (ui32OldCount != 0)
+ {
+ OSMemCopy(psNewArray, psOldArray, HANDLE_ARRAY_SIZE(MIN(ui32NewCount, ui32OldCount)) * sizeof(struct sHandleIndex));
+ }
+ }
+
+
+ for(ui32Index = ui32NewCount; ui32Index < ui32OldCount; ui32Index += HANDLE_BLOCK_SIZE)
+ {
+ struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psOldArray, ui32Index);
+
eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- psBase->ui32TotalHandCount * sizeof(struct sHandle),
- psBase->psHandleArray,
- psBase->hHandBlockAlloc);
+ sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
+ psIndex->psHandle,
+ psIndex->hBlockAlloc);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free handle structures (%d)", eError));
+ }
+ }
+
+
+ for(ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
+ {
+
+ struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psNewArray, ui32Index);
+
+ eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
+ (IMG_VOID **)&psIndex->psHandle,
+ &psIndex->hBlockAlloc,
+ "Memory Area");
+ if (eError != PVRSRV_OK)
+ {
+ psIndex->psHandle = IMG_NULL;
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't allocate handle structures (%d)", eError));
+ eReturn = eError;
+ }
+ else
+ {
+ IMG_UINT32 ui32SubIndex;
+
+ psIndex->ui32FreeHandBlockCount = HANDLE_BLOCK_SIZE;
+
+ for(ui32SubIndex = 0; ui32SubIndex < HANDLE_BLOCK_SIZE; ui32SubIndex++)
+ {
+ struct sHandle *psHandle = psIndex->psHandle + ui32SubIndex;
+
+ psHandle->ui32Index = ui32SubIndex + ui32Index;
+ psHandle->eType = PVRSRV_HANDLE_TYPE_NONE;
+ psHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
+ psHandle->ui32NextIndexPlusOne = 0;
+ }
+ }
+ }
+ if (eReturn != PVRSRV_OK)
+ {
+ goto error;
+ }
+
+#ifdef DEBUG_MAX_HANDLE_COUNT
+
+ if (ui32NewCount > DEBUG_MAX_HANDLE_COUNT)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Max handle count (%u) reached", DEBUG_MAX_HANDLE_COUNT));
+ eReturn = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto error;
+ }
+#endif
+
+ if (psOldArray != IMG_NULL)
+ {
+
+ eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+ HANDLE_ARRAY_SIZE(ui32OldCount) * sizeof(struct sHandleIndex),
+ psOldArray,
+ hOldArrayBlockAlloc);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "FreeHandleArray: Error freeing memory (%d)", eError));
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free old handle array (%d)", eError));
+ }
+ }
+
+ psBase->psHandleArray = psNewArray;
+ psBase->hArrayBlockAlloc = hNewArrayBlockAlloc;
+ psBase->ui32TotalHandCount = ui32NewCount;
+
+ if (ui32NewCount > ui32OldCount)
+ {
+
+ PVR_ASSERT(psBase->ui32FreeHandCount + (ui32NewCount - ui32OldCount) > psBase->ui32FreeHandCount)
+
+
+ psBase->ui32FreeHandCount += (ui32NewCount - ui32OldCount);
+
+
+ if (psBase->ui32FirstFreeIndex == 0)
+ {
+ PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0)
+
+ psBase->ui32FirstFreeIndex = ui32OldCount;
}
else
{
- psBase->psHandleArray = IMG_NULL;
+ if (!psBase->bPurgingEnabled)
+ {
+ PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0)
+ PVR_ASSERT(INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0)
+
+ INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32OldCount + 1;
+ }
+ }
+
+ if (!psBase->bPurgingEnabled)
+ {
+ psBase->ui32LastFreeIndexPlusOne = ui32NewCount;
+ }
+ }
+ else
+ {
+ PVR_ASSERT(ui32NewCount == 0 || psBase->bPurgingEnabled)
+ PVR_ASSERT(ui32NewCount == 0 || psBase->ui32FirstFreeIndex <= ui32NewCount)
+ PVR_ASSERT(psBase->ui32FreeHandCount - (ui32OldCount - ui32NewCount) < psBase->ui32FreeHandCount)
+
+
+ psBase->ui32FreeHandCount -= (ui32OldCount - ui32NewCount);
+
+ if (ui32NewCount == 0)
+ {
+ psBase->ui32FirstFreeIndex = 0;
+ psBase->ui32LastFreeIndexPlusOne = 0;
}
}
- return eError;
+ PVR_ASSERT(psBase->ui32FirstFreeIndex <= psBase->ui32TotalHandCount);
+
+ return PVRSRV_OK;
+
+error:
+ PVR_ASSERT(eReturn != PVRSRV_OK);
+
+ if (psNewArray != IMG_NULL)
+ {
+
+ for(ui32Index = ui32OldCount; ui32Index < ui32NewCount; ui32Index += HANDLE_BLOCK_SIZE)
+ {
+ struct sHandleIndex *psIndex = INDEX_TO_INDEX_STRUCT_PTR(psNewArray, ui32Index);
+ if (psIndex->psHandle != IMG_NULL)
+ {
+ eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(struct sHandle) * HANDLE_BLOCK_SIZE,
+ psIndex->psHandle,
+ psIndex->hBlockAlloc);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free handle structures (%d)", eError));
+ }
+ }
+ }
+
+
+ eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+ HANDLE_ARRAY_SIZE(ui32NewCount) * sizeof(struct sHandleIndex),
+ psNewArray,
+ hNewArrayBlockAlloc);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "ReallocHandleArray: Couldn't free new handle array (%d)", eError));
+ }
+ }
+
+ return eReturn;
+}
+
+static PVRSRV_ERROR FreeHandleArray(PVRSRV_HANDLE_BASE *psBase)
+{
+ return ReallocHandleArray(psBase, 0);
}
static PVRSRV_ERROR FreeHandle(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
{
HAND_KEY aKey;
- IMG_UINT32 ui32Index = HANDLE_PTR_TO_INDEX(psBase, psHandle);
+ IMG_UINT32 ui32Index = HANDLE_PTR_TO_INDEX(psHandle);
PVRSRV_ERROR eError;
hHandle = (IMG_HANDLE) HASH_Remove_Extended(psBase->psHashTab, aKey);
PVR_ASSERT(hHandle != IMG_NULL);
- PVR_ASSERT(hHandle == INDEX_TO_HANDLE(psBase, ui32Index));
+ PVR_ASSERT(hHandle == INDEX_TO_HANDLE(ui32Index));
PVR_UNREFERENCED_PARAMETER(hHandle);
}
if (BATCHED_HANDLE(psHandle) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
- SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle);
+ SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle);
return PVRSRV_OK;
}
{
PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0);
- PVR_ASSERT(INDEX_TO_HANDLE_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0);
- INDEX_TO_HANDLE_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32Index + 1;
+ PVR_ASSERT(INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0);
+ INDEX_TO_HANDLE_STRUCT_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = ui32Index + 1;
}
PVR_ASSERT(psHandle->ui32NextIndexPlusOne == 0);
}
psBase->ui32FreeHandCount++;
+ INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32Index)++;
+
+ PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32Index)<= HANDLE_BLOCK_SIZE);
+
+#ifdef DEBUG
+ {
+ IMG_UINT32 ui32BlockedIndex;
+ IMG_UINT32 ui32FreeHandCount = 0;
+
+ for (ui32BlockedIndex = 0; ui32BlockedIndex < psBase->ui32TotalHandCount; ui32BlockedIndex += HANDLE_BLOCK_SIZE)
+ {
+ ui32FreeHandCount += INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32BlockedIndex);
+ }
+
+ PVR_ASSERT(ui32FreeHandCount == psBase->ui32FreeHandCount);
+ }
+#endif
return PVRSRV_OK;
}
{
struct sHandle *psHandle;
- psHandle = INDEX_TO_HANDLE_PTR(psBase, i);
+ psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, i);
if (psHandle->eType != PVRSRV_HANDLE_TYPE_NONE)
{
static PVRSRV_ERROR FreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
{
PVRSRV_ERROR eError;
-
+
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_WARNING, "FreeHandleBase: Uncommitted/Unreleased handle batch"));
return (IMG_HANDLE) HASH_Retrieve_Extended(psBase->psHashTab, aKey);
}
-static PVRSRV_ERROR ReallocMem(IMG_PVOID *ppvMem, IMG_HANDLE *phBlockAlloc, IMG_UINT32 ui32NewSize, IMG_UINT32 ui32OldSize)
-{
- IMG_VOID *pvOldMem = *ppvMem;
- IMG_HANDLE hOldBlockAlloc = *phBlockAlloc;
- IMG_UINT32 ui32CopySize = MIN(ui32NewSize, ui32OldSize);
- IMG_VOID *pvNewMem = IMG_NULL;
- IMG_HANDLE hNewBlockAlloc = IMG_NULL;
- PVRSRV_ERROR eError;
-
- if (ui32NewSize == ui32OldSize)
- {
- return (PVRSRV_OK);
- }
-
- if (ui32NewSize != 0)
- {
-
- eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- ui32NewSize,
- &pvNewMem,
- &hNewBlockAlloc,
- "Memory Area");
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR, "ReallocMem: Couldn't allocate new memory area (%d)", eError));
- return eError;
- }
- }
-
- if (ui32CopySize != 0)
- {
-
- OSMemCopy(pvNewMem, pvOldMem, ui32CopySize);
- }
-
- if (ui32OldSize != 0)
- {
-
- eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
- ui32OldSize,
- pvOldMem,
- hOldBlockAlloc);
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR, "ReallocMem: Couldn't free old memory area (%d)", eError));
- }
- }
-
- *ppvMem = pvNewMem;
- *phBlockAlloc = hNewBlockAlloc;
-
- return PVRSRV_OK;
-}
-
-#ifdef INLINE_IS_PRAGMA
-#pragma inline(ReallocHandleArray)
-#endif
-static INLINE
-PVRSRV_ERROR ReallocHandleArray(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32NewCount, IMG_UINT32 ui32OldCount)
-{
- return ReallocMem((IMG_PVOID *)&psBase->psHandleArray,
- &psBase->hHandBlockAlloc,
- ui32NewCount * sizeof(struct sHandle),
- ui32OldCount * sizeof(struct sHandle));
-}
-
static PVRSRV_ERROR IncreaseHandleArraySize(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32Delta)
{
PVRSRV_ERROR eError;
- struct sHandle *psHandle;
- IMG_UINT32 ui32DeltaAdjusted = ROUND_UP_TO_MULTIPLE(ui32Delta, HANDLE_BLOCK_SIZE);
+ IMG_UINT32 ui32DeltaAdjusted = ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(ui32Delta);
IMG_UINT32 ui32NewTotalHandCount = psBase->ui32TotalHandCount + ui32DeltaAdjusted;
;
PVR_ASSERT(ui32DeltaAdjusted >= ui32Delta);
- eError = ReallocHandleArray(psBase, ui32NewTotalHandCount, psBase->ui32TotalHandCount);
+ eError = ReallocHandleArray(psBase, ui32NewTotalHandCount);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "IncreaseHandleArraySize: ReallocHandleArray failed (%d)", eError));
return eError;
}
-
- for(psHandle = psBase->psHandleArray + psBase->ui32TotalHandCount;
- psHandle < psBase->psHandleArray + ui32NewTotalHandCount;
- psHandle++)
- {
- psHandle->eType = PVRSRV_HANDLE_TYPE_NONE;
- psHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
- psHandle->ui32NextIndexPlusOne = 0;
- }
-
-
- psBase->ui32FreeHandCount += ui32DeltaAdjusted;
-
- if (psBase->ui32FirstFreeIndex == 0)
- {
- PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0);
-
- psBase->ui32FirstFreeIndex = psBase->ui32TotalHandCount;
- }
- else
- {
- if (!psBase->bPurgingEnabled)
- {
- PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne != 0)
- PVR_ASSERT(INDEX_TO_HANDLE_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne == 0);
-
- INDEX_TO_HANDLE_PTR(psBase, psBase->ui32LastFreeIndexPlusOne - 1)->ui32NextIndexPlusOne = psBase->ui32TotalHandCount + 1;
- }
- }
-
- if (!psBase->bPurgingEnabled)
- {
- psBase->ui32LastFreeIndexPlusOne = ui32NewTotalHandCount;
- }
-
- psBase->ui32TotalHandCount = ui32NewTotalHandCount;
-
return PVRSRV_OK;
}
static PVRSRV_ERROR AllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent)
{
- IMG_UINT32 ui32NewIndex;
+ IMG_UINT32 ui32NewIndex = DEFAULT_MAX_INDEX_PLUS_ONE;
struct sHandle *psNewHandle = IMG_NULL;
IMG_HANDLE hHandle;
HAND_KEY aKey;
PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
-
+ PVR_ASSERT(psBase != IMG_NULL);
PVR_ASSERT(psBase->psHashTab != IMG_NULL);
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
ui32NewIndex = psBase->ui32FirstFreeIndex;
- psNewHandle = INDEX_TO_HANDLE_PTR(psBase, ui32NewIndex);
+ psNewHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32NewIndex);
}
else
{
+ IMG_UINT32 ui32BlockedIndex;
+
+
- for(ui32NewIndex = psBase->ui32FirstFreeIndex; ui32NewIndex < psBase->ui32TotalHandCount; ui32NewIndex++)
+ PVR_ASSERT((psBase->ui32FirstFreeIndex % HANDLE_BLOCK_SIZE) == 0);
+
+ for (ui32BlockedIndex = ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(psBase->ui32FirstFreeIndex); ui32BlockedIndex < psBase->ui32TotalHandCount; ui32BlockedIndex += HANDLE_BLOCK_SIZE)
{
- psNewHandle = INDEX_TO_HANDLE_PTR(psBase, ui32NewIndex);
- if (HANDLE_STRUCT_IS_FREE(psNewHandle))
+ struct sHandleIndex *psIndex = BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, ui32BlockedIndex);
+
+ if (psIndex->ui32FreeHandBlockCount == 0)
{
- break;
+ continue;
+ }
+
+ for (ui32NewIndex = ui32BlockedIndex; ui32NewIndex < ui32BlockedIndex + HANDLE_BLOCK_SIZE; ui32NewIndex++)
+ {
+ psNewHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32NewIndex);
+ if (HANDLE_STRUCT_IS_FREE(psNewHandle))
+ {
+ break;
+ }
}
-
}
psBase->ui32FirstFreeIndex = 0;
PVR_ASSERT(ui32NewIndex < psBase->ui32TotalHandCount);
PVR_ASSERT(psNewHandle != IMG_NULL);
- hHandle = INDEX_TO_HANDLE(psBase, ui32NewIndex);
-
+ hHandle = INDEX_TO_HANDLE(ui32NewIndex);
+
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
{
{
PVR_DPF((PVR_DBG_ERROR, "AllocHandle: Couldn't add handle to hash table"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE;
}
}
psBase->ui32FreeHandCount--;
+ PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex) <= HANDLE_BLOCK_SIZE);
+ PVR_ASSERT(INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex) > 0);
+
+ INDEX_TO_FREE_HAND_BLOCK_COUNT(psBase, ui32NewIndex)--;
+
if (!psBase->bPurgingEnabled)
{
}
+ PVR_ASSERT(psNewHandle->ui32Index == ui32NewIndex);
+
+
psNewHandle->eType = eType;
psNewHandle->pvData = pvData;
psNewHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
psNewHandle->eFlag = eFlag;
- psNewHandle->ui32Index = ui32NewIndex;
- InitParentList(psBase, psNewHandle);
-#if defined(DEBUG_PVR)
- PVR_ASSERT(NoChildren(psBase, psNewHandle));
+ InitParentList(psNewHandle);
+#if defined(DEBUG)
+ PVR_ASSERT(NoChildren(psNewHandle));
#endif
- InitChildEntry(psBase, psNewHandle);
-#if defined(DEBUG_PVR)
- PVR_ASSERT(NoParent(psBase, psNewHandle));
+ InitChildEntry(psNewHandle);
+#if defined(DEBUG)
+ PVR_ASSERT(NoParent(psNewHandle));
#endif
if (HANDLES_BATCHED(psBase))
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandle: Lookup of existing handle failed"));
return eError;
}
-
+
if (TEST_FLAG(psHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED))
{
eError = PVRSRV_OK;
goto exit_ok;
}
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
}
}
eError = GetHandleStructure(psBase, &psPHand, hParent, PVRSRV_HANDLE_TYPE_NONE);
if (eError != PVRSRV_OK)
{
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Lookup of existing handle failed"));
return eErr;
}
-
- PVR_ASSERT(hParentKey != IMG_NULL && ParentHandle(HANDLE_TO_HANDLE_PTR(psBase, hHandle)) == hParent);
+
+ PVR_ASSERT(hParentKey != IMG_NULL && ParentHandle(HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle)) == hParent);
- if (TEST_FLAG(psCHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED) && ParentHandle(HANDLE_TO_HANDLE_PTR(psBase, hHandle)) == hParent)
+ if (TEST_FLAG(psCHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED) && ParentHandle(HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle)) == hParent)
{
*phHandle = hHandle;
goto exit_ok;
}
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
}
}
}
- psPHand = HANDLE_TO_HANDLE_PTR(psBase, hParent);
+ psPHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hParent);
- psCHand = HANDLE_TO_HANDLE_PTR(psBase, hHandle);
+ psCHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle);
AdoptChild(psBase, psPHand, psCHand);
hHandle = (IMG_HANDLE) FindHandle(psBase, pvData, eType, IMG_NULL);
if (hHandle == IMG_NULL)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_NOT_FOUND;
}
*phHandle = hHandle;
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupSubHandle: Subhandle doesn't belong to given ancestor"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_SUBHANDLE;
}
}
PVRSRV_ERROR PVRSRVNewHandleBatch(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32BatchSize)
{
- PVRSRV_ERROR eError;
+ PVRSRV_ERROR eError;
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: There is a handle batch already in use (size %u)", psBase->ui32HandBatchSize));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_BATCH_IN_USE;
}
if (ui32BatchSize == 0)
PVR_ASSERT(psBase->ui32BatchHandAllocFailures == 0 || !bCommit);
- ui32IndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
+ ui32IndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
while(ui32IndexPlusOne != 0)
{
- struct sHandle *psHandle = INDEX_TO_HANDLE_PTR(psBase, ui32IndexPlusOne - 1);
+ struct sHandle *psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32IndexPlusOne - 1);
IMG_UINT32 ui32NextIndexPlusOne = psHandle->ui32NextIndexPlusOne;
PVR_ASSERT(BATCHED_HANDLE(psHandle));
if (!BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
{
+
SET_UNBATCHED_HANDLE(psHandle);
}
}
else
{
- SET_UNBATCHED_HANDLE(psHandle);
+
+ SET_UNBATCHED_HANDLE(psHandle);
}
ui32IndexPlusOne = ui32NextIndexPlusOne;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
if (psBase->ui32TotalHandCountPreBatch != psBase->ui32TotalHandCount)
{
IMG_UINT32 ui32Delta = psBase->ui32TotalHandCount - psBase->ui32TotalHandCountPreBatch;
{
PVR_ASSERT(!bCommitBatch);
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE;
}
return PVRSRV_OK;
PVRSRV_ERROR PVRSRVSetMaxHandle(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32MaxHandle)
{
+ IMG_UINT32 ui32MaxHandleRounded;
+
if (HANDLES_BATCHED(psBase))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set whilst in batch mode"));
}
- if (ui32MaxHandle == 0 || ui32MaxHandle >= DEFAULT_MAX_HANDLE)
+ if (ui32MaxHandle == 0 || ui32MaxHandle > DEFAULT_MAX_HANDLE)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit must be between %u and %u, inclusive", 0, DEFAULT_MAX_HANDLE));
if (psBase->ui32TotalHandCount != 0)
{
- PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set becuase handles have already been allocated"));
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set because handles have already been allocated"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
- psBase->ui32MaxIndexPlusOne = ui32MaxHandle;
+ ui32MaxHandleRounded = ROUND_DOWN_TO_MULTIPLE_OF_BLOCK_SIZE(ui32MaxHandle);
+
+
+ if (ui32MaxHandleRounded != 0 && ui32MaxHandleRounded < psBase->ui32MaxIndexPlusOne)
+ {
+ psBase->ui32MaxIndexPlusOne = ui32MaxHandleRounded;
+ }
+
+ PVR_ASSERT(psBase->ui32MaxIndexPlusOne != 0);
+ PVR_ASSERT(psBase->ui32MaxIndexPlusOne <= DEFAULT_MAX_INDEX_PLUS_ONE);
+ PVR_ASSERT((psBase->ui32MaxIndexPlusOne % HANDLE_BLOCK_SIZE) == 0);
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVPurgeHandles(PVRSRV_HANDLE_BASE *psBase)
{
- IMG_UINT32 ui32Handle;
+ IMG_UINT32 ui32BlockIndex;
IMG_UINT32 ui32NewHandCount;
if (!psBase->bPurgingEnabled)
return PVRSRV_ERROR_INVALID_PARAMS;
}
- for (ui32Handle = psBase->ui32TotalHandCount; ui32Handle != 0; ui32Handle--)
+ PVR_ASSERT((psBase->ui32TotalHandCount % HANDLE_BLOCK_SIZE) == 0);
+
+ for (ui32BlockIndex = INDEX_TO_BLOCK_INDEX(psBase->ui32TotalHandCount); ui32BlockIndex != 0; ui32BlockIndex--)
{
- struct sHandle *psHandle = HANDLE_TO_HANDLE_PTR(psBase, ui32Handle);
- if (!HANDLE_STRUCT_IS_FREE(psHandle))
+ if (psBase->psHandleArray[ui32BlockIndex - 1].ui32FreeHandBlockCount != HANDLE_BLOCK_SIZE)
{
break;
}
}
-
- ui32NewHandCount = ROUND_UP_TO_MULTIPLE(ui32Handle, HANDLE_BLOCK_SIZE);
+ ui32NewHandCount = BLOCK_INDEX_TO_INDEX(ui32BlockIndex);
- if (ui32NewHandCount >= ui32Handle && ui32NewHandCount <= (psBase->ui32TotalHandCount/2))
+ if (ui32NewHandCount <= (psBase->ui32TotalHandCount/2))
{
- IMG_UINT32 ui32Delta = psBase->ui32TotalHandCount - ui32NewHandCount;
PVRSRV_ERROR eError;
- eError = ReallocHandleArray(psBase, ui32NewHandCount, psBase->ui32TotalHandCount);
+ eError = ReallocHandleArray(psBase, ui32NewHandCount);
if (eError != PVRSRV_OK)
{
return eError;
}
-
-
- psBase->ui32TotalHandCount = ui32NewHandCount;
- psBase->ui32FreeHandCount -= ui32Delta;
- psBase->ui32FirstFreeIndex = 0;
}
return PVRSRV_OK;
if (psBase->psHashTab == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't create data pointer hash table\n"));
- goto failure;
+ (IMG_VOID)PVRSRVFreeHandleBase(psBase);
+ return PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE;
}
psBase->hBaseBlockAlloc = hBlockAlloc;
*ppsBase = psBase;
return PVRSRV_OK;
-failure:
- (IMG_VOID)PVRSRVFreeHandleBase(psBase);
- return PVRSRV_ERROR_GENERIC;
}
PVRSRV_ERROR PVRSRVFreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
#define PRIVATE_MAX(a,b) ((a)>(b)?(a):(b))
#define KEY_TO_INDEX(pHash, key, uSize) \
- ((pHash)->pfnHashFunc((pHash)->uKeySize, key, uSize) % uSize)
+ ((pHash)->pfnHashFunc((pHash)->uKeySize, (key), (uSize)) % (uSize))
#define KEY_COMPARE(pHash, pKey1, pKey2) \
- ((pHash)->pfnKeyComp((pHash)->uKeySize, pKey1, pKey2))
+ ((pHash)->pfnKeyComp((pHash)->uKeySize, (pKey1), (pKey2)))
struct _BUCKET_
{
};
typedef struct _BUCKET_ BUCKET;
-struct _HASH_TABLE_
+struct _HASH_TABLE_
{
BUCKET **ppBucketTable;
+
-
- IMG_UINT32 uSize;
+ IMG_UINT32 uSize;
IMG_UINT32 uCount;
IMG_UINT32
HASH_Func_Default (IMG_SIZE_T uKeySize, IMG_VOID *pKey, IMG_UINT32 uHashTabLen)
-{
+{
IMG_UINTPTR_T *p = (IMG_UINTPTR_T *)pKey;
IMG_UINT32 uKeyLen = uKeySize / sizeof(IMG_UINTPTR_T);
IMG_UINT32 ui;
IMG_BOOL
HASH_Key_Comp_Default (IMG_SIZE_T uKeySize, IMG_VOID *pKey1, IMG_VOID *pKey2)
-{
+{
IMG_UINTPTR_T *p1 = (IMG_UINTPTR_T *)pKey1;
IMG_UINTPTR_T *p2 = (IMG_UINTPTR_T *)pKey2;
IMG_UINT32 uKeyLen = uKeySize / sizeof(IMG_UINTPTR_T);
static PVRSRV_ERROR
_ChainInsert (HASH_TABLE *pHash, BUCKET *pBucket, BUCKET **ppBucketTable, IMG_UINT32 uSize)
-{
+{
IMG_UINT32 uIndex;
PVR_ASSERT (pBucket != IMG_NULL);
pBucket = ppOldTable[uIndex];
while (pBucket != IMG_NULL)
{
+ PVRSRV_ERROR eError;
BUCKET *pNextBucket = pBucket->pNext;
- if (_ChainInsert (pHash, pBucket, ppNewTable, uNewSize) != PVRSRV_OK)
+ eError = _ChainInsert (pHash, pBucket, ppNewTable, uNewSize);
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "_Rehash: call to _ChainInsert failed"));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
pBucket = pNextBucket;
}
"HASH_Resize: oldsize=0x%x newsize=0x%x count=0x%x",
pHash->uSize, uNewSize, pHash->uCount));
- OSAllocMem(PVRSRV_PAGEABLE_SELECT,
- sizeof (BUCKET *) * uNewSize,
+ OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+ sizeof (BUCKET *) * uNewSize,
(IMG_PVOID*)&ppNewTable, IMG_NULL,
"Hash Table Buckets");
if (ppNewTable == IMG_NULL)
return IMG_FALSE;
-
+
for (uIndex=0; uIndex<uNewSize; uIndex++)
ppNewTable[uIndex] = IMG_NULL;
IMG_UINT32 uIndex;
PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Create_Extended: InitialSize=0x%x", uInitialLen));
-
- if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
- sizeof(HASH_TABLE),
+
+ if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+ sizeof(HASH_TABLE),
(IMG_VOID **)&pHash, IMG_NULL,
"Hash Table") != PVRSRV_OK)
{
pHash->pfnHashFunc = pfnHashFunc;
pHash->pfnKeyComp = pfnKeyComp;
- OSAllocMem(PVRSRV_PAGEABLE_SELECT,
- sizeof (BUCKET *) * pHash->uSize,
+ OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+ sizeof (BUCKET *) * pHash->uSize,
(IMG_PVOID*)&pHash->ppBucketTable, IMG_NULL,
- "Hash Table Buckets");
+ "Hash Table Buckets");
if (pHash->ppBucketTable == IMG_NULL)
{
if (pHash != IMG_NULL)
{
PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Delete"));
-
+
PVR_ASSERT (pHash->uCount==0);
if(pHash->uCount != 0)
{
BUCKET *pBucket;
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Insert_Extended: Hash=%08X, pKey=%08X, v=0x%x", pHash, pKey, v));
+ "HASH_Insert_Extended: Hash=0x%08x, pKey=0x%08x, v=0x%x",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey, v));
PVR_ASSERT (pHash != IMG_NULL);
PVR_DPF((PVR_DBG_ERROR, "HASH_Insert_Extended: invalid parameter"));
return IMG_FALSE;
}
-
- if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
- sizeof(BUCKET) + pHash->uKeySize,
+
+ if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+ sizeof(BUCKET) + pHash->uKeySize,
(IMG_VOID **)&pBucket, IMG_NULL,
"Hash Table entry") != PVRSRV_OK)
{
_Resize (pHash, pHash->uSize << 1);
}
-
-
+
+
return IMG_TRUE;
}
HASH_Insert (HASH_TABLE *pHash, IMG_UINTPTR_T k, IMG_UINTPTR_T v)
{
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Insert: Hash=%08X, k=0x%x, v=0x%x", pHash, k, v));
+ "HASH_Insert: Hash=0x%x, k=0x%x, v=0x%x",
+ (IMG_UINTPTR_T)pHash, k, v));
return HASH_Insert_Extended(pHash, &k, v);
}
BUCKET **ppBucket;
IMG_UINT32 uIndex;
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove_Extended: Hash=%08X, pKey=%08X", pHash, pKey));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove_Extended: Hash=0x%x, pKey=0x%x",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey));
PVR_ASSERT (pHash != IMG_NULL);
-
+
if (pHash == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "HASH_Remove_Extended: Null hash table"));
}
uIndex = KEY_TO_INDEX(pHash, pKey, pHash->uSize);
-
+
for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext))
{
PRIVATE_MAX (pHash->uSize >> 1,
pHash->uMinimumSize));
}
-
+
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Remove_Extended: Hash=%08X, pKey=%08X = 0x%x",
- pHash, pKey, v));
+ "HASH_Remove_Extended: Hash=0x%x, pKey=0x%x = 0x%x",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey, v));
return v;
}
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Remove_Extended: Hash=%08X, pKey=%08X = 0x0 !!!!", pHash, pKey));
+ "HASH_Remove_Extended: Hash=0x%x, pKey=0x%x = 0x0 !!!!",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey));
return 0;
}
IMG_UINTPTR_T
HASH_Remove (HASH_TABLE *pHash, IMG_UINTPTR_T k)
{
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove: Hash=%08X, k=0x%x", pHash, k));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Remove: Hash=0x%x, k=0x%x",
+ (IMG_UINTPTR_T)pHash, k));
return HASH_Remove_Extended(pHash, &k);
}
BUCKET **ppBucket;
IMG_UINT32 uIndex;
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve_Extended: Hash=%08X, pKey=%08X", pHash,pKey));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve_Extended: Hash=0x%x, pKey=0x%x",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey));
PVR_ASSERT (pHash != IMG_NULL);
-
+
if (pHash == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "HASH_Retrieve_Extended: Null hash table"));
}
uIndex = KEY_TO_INDEX(pHash, pKey, pHash->uSize);
-
+
for (ppBucket = &(pHash->ppBucketTable[uIndex]); *ppBucket != IMG_NULL; ppBucket = &((*ppBucket)->pNext))
{
if (KEY_COMPARE(pHash, (*ppBucket)->k, pKey))
- {
+ {
BUCKET *pBucket = *ppBucket;
IMG_UINTPTR_T v = pBucket->v;
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Retrieve: Hash=%08X, pKey=%08X = 0x%x",
- pHash, pKey, v));
+ "HASH_Retrieve: Hash=0x%x, pKey=0x%x = 0x%x",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey, v));
return v;
}
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "HASH_Retrieve: Hash=%08X, pKey=%08X = 0x0 !!!!", pHash, pKey));
+ "HASH_Retrieve: Hash=0x%x, pKey=0x%x = 0x0 !!!!",
+ (IMG_UINTPTR_T)pHash, (IMG_UINTPTR_T)pKey));
return 0;
}
IMG_UINTPTR_T
HASH_Retrieve (HASH_TABLE *pHash, IMG_UINTPTR_T k)
{
- PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve: Hash=%08X, k=0x%x", pHash,k));
+ PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Retrieve: Hash=0x%x, k=0x%x",
+ (IMG_UINTPTR_T)pHash, k));
return HASH_Retrieve_Extended(pHash, &k);
}
BUCKET *pBucket;
IMG_UINT32 uLength = 0;
if (pHash->ppBucketTable[uIndex] == IMG_NULL)
+ {
uEmptyCount++;
+ }
for (pBucket=pHash->ppBucketTable[uIndex];
- pBucket != IMG_NULL;
- pBucket = pBucket->pNext)
- uLength++;
+ pBucket != IMG_NULL;
+ pBucket = pBucket->pNext)
+ {
+ uLength++;
+ }
uMaxLength = PRIVATE_MAX (uMaxLength, uLength);
}
RESMAN_TYPE_SHARED_MEM_INFO,
psKernelMemInfo,
0,
- FreeSharedSysMemCallBack);
+ &FreeSharedSysMemCallBack);
*ppsKernelMemInfo = psKernelMemInfo;
#include "sgxapi_km.h"
#endif
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(DEBUG) || defined(TIMING)
static volatile IMG_UINT32 *pui32TimerRegister = 0;
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include "img_types.h"
+#include "services_headers.h"
+#include "osfunc.h"
+
+
#include "services_headers.h"
#if defined(SUPPORT_SGX)
#include "sgxdefs.h"
-#include "sgxmmu.h"
#endif
+#include "perproc.h"
+
#include "pdump_km.h"
+#include "pdump_int.h"
#if !defined(PDUMP_TEMP_BUFFER_SIZE)
-#define PDUMP_TEMP_BUFFER_SIZE (64 * 1024L)
+#define PDUMP_TEMP_BUFFER_SIZE (64 * 1024U)
#endif
#if 1
-#define PDUMP_DBG(a) PDumpOSDebugPrintf a
+#define PDUMP_DBG(a) PDumpOSDebugPrintf (a)
#else
#define PDUMP_DBG(a)
#endif
#define PDUMP_DATAMASTER_PIXEL (1)
#define PDUMP_DATAMASTER_EDM (3)
-#define MIN(x, y) (((x) < (y)) ? (x) : (y))
-#define PTR_PLUS(t, p, x) ((t *)(((IMG_CHAR *)(p)) + (x)))
-#define VPTR_PLUS(p, x) PTR_PLUS(IMG_VOID, p, x)
-#define VPTR_INC(p, x) (p = VPTR_PLUS(p, x))
+#define PTR_PLUS(t, p, x) ((t)(((IMG_CHAR *)(p)) + (x)))
+#define VPTR_PLUS(p, x) PTR_PLUS(IMG_VOID *, p, x)
+#define VPTR_INC(p, x) ((p) = VPTR_PLUS(p, x))
#define MAX_PDUMP_MMU_CONTEXTS (32)
static IMG_VOID *gpvTempBuffer = IMG_NULL;
static IMG_HANDLE ghTempBufferBlockAlloc;
static IMG_UINT16 gui16MMUContextUsage = 0;
+#if defined(PDUMP_DEBUG_OUTFILES)
+IMG_UINT32 g_ui32EveryLineCounter = 1U;
+#endif
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(_PDumpIsPersistent)
+#endif
+static INLINE
+IMG_BOOL _PDumpIsPersistent(IMG_VOID)
+{
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc == IMG_NULL)
+ {
+
+ return IMG_FALSE;
+ }
+ return psPerProc->bPDumpPersistent;
+}
+
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+static INLINE
+IMG_BOOL _PDumpIsProcessActive(IMG_VOID)
+{
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc == IMG_NULL)
+ {
+
+ return IMG_TRUE;
+ }
+ return psPerProc->bPDumpActive;
+}
+#endif
+
+#if defined(PDUMP_DEBUG_OUTFILES)
+static INLINE
+IMG_UINT32 _PDumpGetPID(IMG_VOID)
+{
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc == IMG_NULL)
+ {
+
+ return 0;
+ }
+ return psPerProc->ui32PID;
+}
+#endif
static IMG_VOID *GetTempBuffer(IMG_VOID)
{
PDumpDeInit();
}
-#if defined(SGX_SUPPORT_COMMON_PDUMP)
-
IMG_BOOL PDumpIsSuspended(IMG_VOID)
{
return PDumpOSIsSuspended();
}
-PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_UINT32 ui32Reg, IMG_UINT32 ui32Data, IMG_UINT32 ui32Flags)
+IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID)
+{
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if( _PDumpIsProcessActive() )
+ {
+ return PDumpOSIsCaptureFrameKM();
+ }
+ return IMG_FALSE;
+#else
+ return PDumpOSIsCaptureFrameKM();
+#endif
+}
+
+PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
+{
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if( _PDumpIsProcessActive() )
+ {
+ return PDumpOSSetFrameKM(ui32Frame);
+ }
+ return PVRSRV_OK;
+#else
+ return PDumpOSSetFrameKM(ui32Frame);
+#endif
+}
+
+
+PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data,
+ IMG_UINT32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING()
PDUMP_DBG(("PDumpRegWithFlagsKM"));
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :SGXREG:0x%8.8lX 0x%8.8lX\r\n", ui32Reg, ui32Data);
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "WRW :%s:0x%08X 0x%08X\r\n",
+ pszPDumpRegName, ui32Reg, ui32Data);
if(eErr != PVRSRV_OK)
{
return eErr;
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpRegKM(IMG_UINT32 ui32Reg,IMG_UINT32 ui32Data)
+PVRSRV_ERROR PDumpRegKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32Reg,
+ IMG_UINT32 ui32Data)
{
- return PDumpRegWithFlagsKM(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
+ return PDumpRegWithFlagsKM(pszPDumpRegName, ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
}
-PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask, IMG_UINT32 ui32Flags)
+PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegAddr,
+ IMG_UINT32 ui32RegValue,
+ IMG_UINT32 ui32Mask,
+ IMG_UINT32 ui32Flags)
{
- #define POLL_DELAY 1000UL
- #define POLL_COUNT_LONG (2000000000UL / POLL_DELAY)
- #define POLL_COUNT_SHORT (1000000UL / POLL_DELAY)
+ #define POLL_DELAY 1000U
+ #define POLL_COUNT_LONG (2000000000U / POLL_DELAY)
+ #define POLL_COUNT_SHORT (1000000U / POLL_DELAY)
PVRSRV_ERROR eErr;
IMG_UINT32 ui32PollCount;
PDUMP_GET_SCRIPT_STRING();
PDUMP_DBG(("PDumpRegPolWithFlagsKM"));
+ if ( _PDumpIsPersistent() )
+ {
+
+ return PVRSRV_OK;
+ }
+#if 0
if (((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
(ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_TA_FINISHED_MASK) != 0) ||
((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
ui32PollCount = POLL_COUNT_LONG;
}
else
+#endif
{
- ui32PollCount = POLL_COUNT_SHORT;
+ ui32PollCount = POLL_COUNT_LONG;
}
-
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "POL :SGXREG:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %lu %d\r\n",
- ui32RegAddr, ui32RegValue, ui32Mask, 0, ui32PollCount, POLL_DELAY);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "POL :%s:0x%08X 0x%08X 0x%08X %d %u %d\r\n",
+ pszPDumpRegName, ui32RegAddr, ui32RegValue,
+ ui32Mask, 0, ui32PollCount, POLL_DELAY);
if(eErr != PVRSRV_OK)
{
return eErr;
}
-PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask)
+PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName, IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask)
{
- return PDumpRegPolWithFlagsKM(ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS);
+ return PDumpRegPolWithFlagsKM(pszPDumpRegName, ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS);
}
-PVRSRV_ERROR PDumpMallocPages (PVRSRV_DEVICE_TYPE eDeviceType,
+PVRSRV_ERROR PDumpMallocPages (PVRSRV_DEVICE_IDENTIFIER *psDevID,
IMG_UINT32 ui32DevVAddr,
IMG_CPU_VIRTADDR pvLinAddr,
IMG_HANDLE hOSMemHandle,
IMG_UINT32 ui32NumBytes,
IMG_UINT32 ui32PageSize,
+ IMG_BOOL bShared,
IMG_HANDLE hUniqueTag)
{
PVRSRV_ERROR eErr;
IMG_UINT32 ui32NumPages;
IMG_DEV_PHYADDR sDevPAddr;
IMG_UINT32 ui32Page;
+ IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
PDUMP_GET_SCRIPT_STRING();
-
-#if defined(LINUX)
- PVR_ASSERT(hOSMemHandle);
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ ui32Flags |= ( _PDumpIsPersistent() || bShared ) ? PDUMP_FLAGS_PERSISTENT : 0;
#else
+ PVR_UNREFERENCED_PARAMETER(bShared);
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+#endif
+
- PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
- PVR_ASSERT(((IMG_UINT32) pvLinAddr & (SGX_MMU_PAGE_MASK)) == 0);
+#if !defined(LINUX)
+ PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & HOST_PAGEMASK) == 0);
#endif
- PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & (SGX_MMU_PAGE_MASK)) == 0);
- PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (SGX_MMU_PAGE_MASK)) == 0);
+ PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & HOST_PAGEMASK) == 0);
+ PVR_ASSERT(((IMG_UINT32) ui32NumBytes & HOST_PAGEMASK) == 0);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :SGXMEM:VA_%8.8lX 0x%8.8lX %lu\r\n",
- ui32DevVAddr, ui32NumBytes, ui32PageSize);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :%s:VA_%08X 0x%08X %u\r\n",
+ psDevID->pszPDumpDevName, ui32DevVAddr, ui32NumBytes, ui32PageSize);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
ui32Offset = 0;
ui32NumPages = ui32NumBytes / ui32PageSize;
while (ui32NumPages)
- {
+ {
ui32NumPages--;
- PDumpOSCPUVAddrToDevPAddr(eDeviceType,
+
+
+
+
+
+
+
+
+
+ PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,
hOSMemHandle,
ui32Offset,
pui8LinAddr,
ui32PageSize,
&sDevPAddr);
- ui32Page = sDevPAddr.uiAddr / ui32PageSize;
+ ui32Page = (IMG_UINT32)(sDevPAddr.uiAddr / ui32PageSize);
pui8LinAddr += ui32PageSize;
ui32Offset += ui32PageSize;
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX %lu %lu 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:PA_%08X%08X %u %u 0x%08X\r\n",
+ psDevID->pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
ui32Page * ui32PageSize,
ui32PageSize,
ui32PageSize,
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
}
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpMallocPageTable (PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32PTSize,
- IMG_HANDLE hUniqueTag)
+PVRSRV_ERROR PDumpMallocPageTable (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32PTSize,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
{
PVRSRV_ERROR eErr;
IMG_DEV_PHYADDR sDevPAddr;
- IMG_UINT32 ui32Page;
PDUMP_GET_SCRIPT_STRING();
- PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize - 1)) == 0);
+ PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize - 1)) == 0);
+ ui32Flags |= PDUMP_FLAGS_CONTINUOUS;
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :SGXMEM:PAGE_TABLE 0x%8.8lX %lu\r\n", ui32PTSize, SGX_MMU_PAGE_SIZE);
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "-- MALLOC :%s:PAGE_TABLE 0x%08X %u\r\n",
+ psDevId->pszPDumpDevName,
+ ui32PTSize,
+ ui32PTSize);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
-
-
+ PDumpOSWriteString2(hScript, ui32Flags);
-
-
-
-
+ PDumpOSCPUVAddrToDevPAddr(psDevId->eDeviceType,
+ hOSMemHandle,
+ ui32Offset,
+ (IMG_PUINT8) pvLinAddr,
+ ui32PTSize,
+ &sDevPAddr);
+
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:PA_%08X%08X 0x%X %u 0x%08X\r\n",
+ psDevId->pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr,
+ ui32PTSize,
+ ui32PTSize,
+ sDevPAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
{
-
-
- PDumpOSCPUVAddrToDevPAddr(eDeviceType,
- IMG_NULL,
- 0,
- (IMG_PUINT8) pvLinAddr,
- SGX_MMU_PAGE_SIZE,
- &sDevPAddr);
- ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
-
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :SGXMEM:PA_%8.8lX%8.8lX 0x%lX %lu 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
- ui32Page * SGX_MMU_PAGE_SIZE,
- SGX_MMU_PAGE_SIZE,
- SGX_MMU_PAGE_SIZE,
- ui32Page * SGX_MMU_PAGE_SIZE);
- if(eErr != PVRSRV_OK)
- {
- return eErr;
- }
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
-
+ return eErr;
}
+ PDumpOSWriteString2(hScript, ui32Flags);
+
return PVRSRV_OK;
}
PVRSRV_ERROR eErr;
IMG_UINT32 ui32NumPages, ui32PageCounter;
IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
PVRSRV_DEVICE_NODE *psDeviceNode;
PDUMP_GET_SCRIPT_STRING();
PVR_ASSERT(((IMG_UINT32) sDevVAddr.uiAddr & (ui32PageSize - 1)) == 0);
PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (ui32PageSize - 1)) == 0);
+ psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :SGXMEM:VA_%8.8lX\r\n", sDevVAddr.uiAddr);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:VA_%08X\r\n",
+ psDeviceNode->sDevId.pszPDumpDevName, sDevVAddr.uiAddr);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ {
+ PVRSRV_DEVICE_NODE *psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
+
+ if( psDeviceNode->pfnMMUIsHeapShared(psBMHeap->pMMUHeap) )
+ {
+ ui32Flags |= PDUMP_FLAGS_PERSISTENT;
+ }
+ }
+#endif
+ PDumpOSWriteString2(hScript, ui32Flags);
ui32NumPages = ui32NumBytes / ui32PageSize;
- psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages; ui32PageCounter++)
{
if (!bInterleaved || (ui32PageCounter % 2) == 0)
{
sDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->pMMUHeap, sDevVAddr);
-
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, sDevPAddr.uiAddr);
- if(eErr != PVRSRV_OK)
{
- return eErr;
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:PA_%08X%08X\r\n",
+ psDeviceNode->sDevId.pszPDumpDevName, (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag, sDevPAddr.uiAddr);
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+ PDumpOSWriteString2(hScript, ui32Flags);
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
}
else
{
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpFreePageTable (PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32PTSize,
- IMG_HANDLE hUniqueTag)
+PVRSRV_ERROR PDumpFreePageTable (PVRSRV_DEVICE_IDENTIFIER *psDevID,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32PTSize,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag)
{
PVRSRV_ERROR eErr;
IMG_DEV_PHYADDR sDevPAddr;
- IMG_UINT32 ui32Page;
PDUMP_GET_SCRIPT_STRING();
PVR_UNREFERENCED_PARAMETER(ui32PTSize);
+ ui32Flags |= PDUMP_FLAGS_CONTINUOUS;
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
- PVR_ASSERT(((IMG_UINT32) pvLinAddr & (ui32PTSize-1UL)) == 0);
+ PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize-1UL)) == 0);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :SGXMEM:PAGE_TABLE\r\n");
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:PAGE_TABLE\r\n", psDevID->pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
-
-
+ PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,
+ hOSMemHandle,
+ 0,
+ (IMG_PUINT8) pvLinAddr,
+ ui32PTSize,
+ &sDevPAddr);
-
{
- PDumpOSCPUVAddrToDevPAddr(eDeviceType,
- IMG_NULL,
- 0,
- (IMG_PUINT8) pvLinAddr,
- SGX_MMU_PAGE_SIZE,
- &sDevPAddr);
- ui32Page = sDevPAddr.uiAddr >> SGX_MMU_PAGE_SHIFT;
-
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :SGXMEM:PA_%8.8lX%8.8lX\r\n", (IMG_UINT32) hUniqueTag, ui32Page * SGX_MMU_PAGE_SIZE);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:PA_%08X%08X\r\n",
+ psDevID->pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
}
+
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
+PVRSRV_ERROR PDumpPDRegWithFlags(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_UINT32 ui32Reg,
IMG_UINT32 ui32Data,
IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag)
{
PVRSRV_ERROR eErr;
+ IMG_CHAR *pszRegString;
PDUMP_GET_SCRIPT_STRING()
+
+ if(psMMUAttrib->pszPDRegRegion != IMG_NULL)
+ {
+ pszRegString = psMMUAttrib->pszPDRegRegion;
+ }
+ else
+ {
+ pszRegString = psMMUAttrib->sDevId.pszPDumpRegName;
+ }
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
- "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ "WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag,
- (ui32Data & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PDE_ADDR_ALIGNSHIFT);
+ (ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift);
if(eErr != PVRSRV_OK)
{
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :%s:$1 :%s:$1 0x4\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
PDumpOSWriteString2(hScript, ui32Flags);
eErr = PDumpOSBufprintf(hScript, ui32MaxLen,
- "WRW :SGXREG:0x%8.8lX: SGXMEM:$1\r\n",
- ui32Reg);
+ "WRW :%s:0x%08X: %s:$1\r\n",
+ pszRegString,
+ ui32Reg,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "WRW :SGXREG:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
+ "WRW :%s:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",
+ pszRegString,
ui32Reg,
- (IMG_UINT32) hUniqueTag,
- (ui32Data & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PDE_ADDR_ALIGNSHIFT,
- ui32Data & ~SGX_MMU_PDE_ADDR_MASK);
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ (ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift,
+ ui32Data & ~psMMUAttrib->ui32PDEMask);
if(eErr != PVRSRV_OK)
{
return eErr;
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpPDReg (IMG_UINT32 ui32Reg,
+PVRSRV_ERROR PDumpPDReg (PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_UINT32 ui32Reg,
IMG_UINT32 ui32Data,
IMG_HANDLE hUniqueTag)
{
- return PDumpPDRegWithFlags(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS, hUniqueTag);
+ return PDumpPDRegWithFlags(psMMUAttrib, ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS, hUniqueTag);
}
PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
IMG_UINT8 *pui8LinAddr;
IMG_DEV_PHYADDR sDevPAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
+ PDUMP_MMU_ATTRIB *psMMUAttrib;
+
PDUMP_GET_SCRIPT_STRING();
+ if ( _PDumpIsPersistent() )
+ {
+
+ return PVRSRV_OK;
+ }
PVR_ASSERT((ui32Offset + sizeof(IMG_UINT32)) <= psMemInfo->ui32AllocSize);
+ psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;
+
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "-- POL :SGXMEM:VA_%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
+ "-- POL :%s:VA_%08X 0x%08X 0x%08X %d %d %d\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
psMemInfo->sDevVAddr.uiAddr + ui32Offset,
ui32Value,
ui32Mask,
PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
ui32Offset,
pui8LinAddr,
+ psMMUAttrib->ui32DataPageMask,
&ui32PageOffset);
sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;
- PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+ PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "POL :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %d %d %d\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ "POL :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %d %d %d\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),
+ sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),
ui32Value,
ui32Mask,
eOperator,
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_PHYADDR sDevPAddr;
IMG_UINT32 ui32ParamOutPos;
+ PDUMP_MMU_ATTRIB *psMMUAttrib;
+ IMG_UINT32 ui32DataPageSize;
PDUMP_GET_SCRIPT_AND_FILE_STRING();
+ psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;
+
+
PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
if (!PDumpOSJTInitialised())
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
}
+
if (ui32Bytes == 0 || PDumpOSIsSuspended())
{
return PVRSRV_OK;
}
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ {
+ BM_HEAP *pHeap = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap;
+ PVRSRV_DEVICE_NODE *psDeviceNode = pHeap->pBMContext->psDeviceNode;
+
+ if( psDeviceNode->pfnMMUIsHeapShared(pHeap->pMMUHeap) )
+ {
+ ui32Flags |= PDUMP_FLAGS_PERSISTENT;
+ }
+ }
+#endif
+
if(pvAltLinAddr)
{
ui32Bytes,
ui32Flags))
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
}
if (PDumpOSGetParamFileNum() == 0)
}
else
{
- eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%%lu.prm", PDumpOSGetParamFileNum());
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());
}
if(eErr != PVRSRV_OK)
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "-- LDB :SGXMEM:VA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- (IMG_UINT32)hUniqueTag,
+ "-- LDB :%s:VA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
psMemInfo->sDevVAddr.uiAddr,
ui32Offset,
ui32Bytes,
PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
ui32Offset,
pui8LinAddr,
+ psMMUAttrib->ui32DataPageMask,
&ui32PageByteOffset);
- ui32NumPages = (ui32PageByteOffset + ui32Bytes + HOST_PAGESIZE() - 1) / HOST_PAGESIZE();
+ ui32DataPageSize = psMMUAttrib->ui32DataPageMask + 1;
+ ui32NumPages = (ui32PageByteOffset + ui32Bytes + psMMUAttrib->ui32DataPageMask) / ui32DataPageSize;
while(ui32NumPages)
{
-#if 0
- IMG_UINT32 ui32BlockBytes = MIN(ui32BytesRemaining, PAGE_SIZE);
- CpuPAddr = OSMemHandleToCpuPAddr(psMemInfo->sMemBlk.hOSMemHandle,
- ui32CurrentOffset);
-#endif
ui32NumPages--;
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
- PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+ if (ui32DataPageSize <= PDUMP_TEMP_BUFFER_SIZE)
+ {
+
+ PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);
+ }
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset;
-#if 0
- if(ui32PageByteOffset)
- {
- ui32BlockBytes =
- MIN(ui32BytesRemaining, PAGE_ALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr);
-
- ui32PageByteOffset = 0;
- }
-#endif
+
- if (ui32PageByteOffset + ui32Bytes > HOST_PAGESIZE())
+ if (ui32PageByteOffset + ui32Bytes > ui32DataPageSize)
{
- ui32BlockBytes = HOST_PAGESIZE() - ui32PageByteOffset;
+ ui32BlockBytes = ui32DataPageSize - ui32PageByteOffset;
}
else
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ "LDB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),
+ sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),
ui32BlockBytes,
ui32ParamOutPos,
pszFileName);
+#if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)
+
+ ui32PageByteOffset = (ui32PageByteOffset + ui32BlockBytes) % ui32DataPageSize;
+#else
ui32PageByteOffset = 0;
+#endif
ui32Bytes -= ui32BlockBytes;
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32Bytes,
- IMG_UINT32 ui32Flags,
- IMG_BOOL bInitialisePages,
- IMG_HANDLE hUniqueTag1,
- IMG_HANDLE hUniqueTag2)
+PVRSRV_ERROR PDumpMemPDEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_BOOL bInitialisePages,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2)
+{
+ PDUMP_MMU_ATTRIB sMMUAttrib;
+
+
+ sMMUAttrib = *psMMUAttrib;
+ sMMUAttrib.ui32PTSize = HOST_PAGESIZE();
+ return PDumpMemPTEntriesKM( &sMMUAttrib,
+ hOSMemHandle,
+ pvLinAddr,
+ ui32Bytes,
+ ui32Flags,
+ bInitialisePages,
+ hUniqueTag1,
+ hUniqueTag2);
+}
+
+PVRSRV_ERROR PDumpMemPTEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_BOOL bInitialisePages,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2)
{
PVRSRV_ERROR eErr;
IMG_UINT32 ui32NumPages;
IMG_CPU_PHYADDR sCpuPAddr;
IMG_UINT32 ui32Offset;
IMG_UINT32 ui32ParamOutPos;
+ IMG_UINT32 ui32PageMask;
PDUMP_GET_SCRIPT_AND_FILE_STRING();
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
- if (!pvLinAddr || !PDumpOSJTInitialised())
+ if (!PDumpOSJTInitialised())
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
+ }
+
+ if (!pvLinAddr)
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
if (PDumpOSIsSuspended())
if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
pvLinAddr,
ui32Bytes,
- PDUMP_FLAGS_CONTINUOUS))
+ ui32Flags | PDUMP_FLAGS_CONTINUOUS))
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
}
if (PDumpOSGetParamFileNum() == 0)
}
else
{
- eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%%lu.prm", PDumpOSGetParamFileNum());
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());
}
if(eErr != PVRSRV_OK)
{
+
+
+
+ ui32PageMask = psMMUAttrib->ui32PTSize - 1;
+
+
+
- ui32PageOffset = (IMG_UINT32) pvLinAddr & (HOST_PAGESIZE() - 1);
- ui32NumPages = (ui32PageOffset + ui32Bytes + HOST_PAGESIZE() - 1) / HOST_PAGESIZE();
+ ui32PageOffset = (IMG_UINT32)((IMG_UINTPTR_T)pvLinAddr & (psMMUAttrib->ui32PTSize - 1));
+ ui32NumPages = (ui32PageOffset + ui32Bytes + psMMUAttrib->ui32PTSize - 1) / psMMUAttrib->ui32PTSize;
pui8LinAddr = (IMG_UINT8*) pvLinAddr;
while (ui32NumPages)
{
ui32NumPages--;
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
- sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
+
+
+
+
+
+
+ sCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle, pui8LinAddr);
+ sDevPAddr = SysCpuPAddrToDevPAddr(psMMUAttrib->sDevId.eDeviceType, sCpuPAddr);
- if (ui32PageOffset + ui32Bytes > HOST_PAGESIZE())
+ if (ui32PageOffset + ui32Bytes > psMMUAttrib->ui32PTSize)
{
- ui32BlockBytes = HOST_PAGESIZE() - ui32PageOffset;
+ ui32BlockBytes = psMMUAttrib->ui32PTSize - ui32PageOffset;
}
else
{
+
if (bInitialisePages)
{
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "LDB :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX %s\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ "LDB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ sDevPAddr.uiAddr & ~ui32PageMask,
+ sDevPAddr.uiAddr & ui32PageMask,
ui32BlockBytes,
ui32ParamOutPos,
pszFileName);
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
}
else
{
{
IMG_UINT32 ui32PTE = *((IMG_UINT32 *) (pui8LinAddr + ui32Offset));
- if ((ui32PTE & SGX_MMU_PDE_ADDR_MASK) != 0)
+ if ((ui32PTE & psMMUAttrib->ui32PDEMask) != 0)
{
+
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ "WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag2,
- (ui32PTE & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PTE_ADDR_ALIGNSHIFT);
+ (ui32PTE & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PTEAlignShift);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :SGXMEM:$1 :SGXMEM:$1 0x4\r\n");
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :%s:$1 :%s:$1 0x4\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "OR :SGXMEM:$1 :SGXMEM:$1 0x%8.8lX\r\n", ui32PTE & ~SGX_MMU_PDE_ADDR_MASK);
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "OR :%s:$1 :%s:$1 0x%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ ui32PTE & ~psMMUAttrib->ui32PDEMask);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$1\r\n",
+ "WRW :%s:PA_%08X%08X:0x%08X :%s:$1\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag1,
- (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
- (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK));
+ (sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,
+ (sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
- (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK),
- (IMG_UINT32) hUniqueTag2,
- (ui32PTE & SGX_MMU_PDE_ADDR_MASK) << SGX_MMU_PTE_ADDR_ALIGNSHIFT,
- ui32PTE & ~SGX_MMU_PDE_ADDR_MASK);
+ "WRW :%s:PA_%08X%08X:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ (sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,
+ (sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2,
+ (ui32PTE & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PTEAlignShift,
+ ui32PTE & ~psMMUAttrib->ui32PDEMask);
if(eErr != PVRSRV_OK)
{
return eErr;
}
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
#endif
}
else
{
- PVR_ASSERT((ui32PTE & SGX_MMU_PTE_VALID) == 0UL);
+ PVR_ASSERT((ui32PTE & psMMUAttrib->ui32PTEValid) == 0UL);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLenScript,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- (sDevPAddr.uiAddr + ui32Offset) & ~(SGX_MMU_PAGE_MASK),
- (sDevPAddr.uiAddr + ui32Offset) & (SGX_MMU_PAGE_MASK),
- (ui32PTE << SGX_MMU_PTE_ADDR_ALIGNSHIFT),
- (IMG_UINT32) hUniqueTag2);
+ "WRW :%s:PA_%08X%08X:0x%08X 0x%08X%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ (sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,
+ (sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,
+ (ui32PTE << psMMUAttrib->ui32PTEAlignShift),
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2);
if(eErr != PVRSRV_OK)
{
return eErr;
}
+ PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
}
}
IMG_DEV_VIRTADDR sDevVAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
IMG_DEV_PHYADDR sDevPAddr;
+ IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
+ IMG_UINT32 ui32ParamOutPos;
+ PDUMP_MMU_ATTRIB *psMMUAttrib;
+ IMG_UINT32 ui32PageMask;
- PDUMP_GET_SCRIPT_STRING();
+ PDUMP_GET_SCRIPT_AND_FILE_STRING();
+
+ if (!PDumpOSJTInitialised())
+ {
+ return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
+ }
+ psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;
+ ui32PageMask = psMMUAttrib->ui32PTSize - 1;
+
+ ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
+
+
if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
(IMG_UINT8 *)&sPDDevPAddr,
sizeof(IMG_DEV_PHYADDR),
- PDUMP_FLAGS_CONTINUOUS))
+ ui32Flags))
+ {
+ return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
+ }
+
+ if (PDumpOSGetParamFileNum() == 0)
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");
+ }
+ else
+ {
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());
+ }
+ if(eErr != PVRSRV_OK)
+ {
+ return eErr;
+ }
+
+
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLenScript,
+ "-- LDB :%s:PA_0x%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ sPDDevPAddr.uiAddr & ~ui32PageMask,
+ sPDDevPAddr.uiAddr & ui32PageMask,
+ sizeof(IMG_DEV_PHYADDR),
+ ui32ParamOutPos,
+ pszFileName);
+ if(eErr != PVRSRV_OK)
{
- return PVRSRV_ERROR_GENERIC;
+ return eErr;
}
+ PDumpOSWriteString2(hScript, ui32Flags);
+
sDevVAddr = psMemInfo->sDevVAddr;
- ui32PageByteOffset = sDevVAddr.uiAddr & (SGX_MMU_PAGE_MASK);
+ ui32PageByteOffset = sDevVAddr.uiAddr & ui32PageMask;
sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
sDevPAddr.uiAddr += ui32PageByteOffset + ui32Offset;
- if ((sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK) != 0UL)
+ if ((sPDDevPAddr.uiAddr & psMMUAttrib->ui32PDEMask) != 0UL)
{
#if defined(SGX_FEATURE_36BIT_MMU)
eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
- "WRW :SGXMEM:$1 :SGXMEM:PA_%8.8lX%8.8lX:0x0\r\n",
+ ui32MaxLenScript,
+ "WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag2,
sPDDevPAddr.uiAddr);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "AND :SGXMEM:$2 :SGXMEM:$1 0xFFFFFFFF\r\n");
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "AND :%s:$2 :%s:$1 0xFFFFFFFF\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
+ ui32MaxLenScript,
+ "WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag1,
- (sDevPAddr.uiAddr) & ~(SGX_MMU_PAGE_MASK),
- (sDevPAddr.uiAddr) & (SGX_MMU_PAGE_MASK));
+ (sDevPAddr.uiAddr) & ~(psMMUAttrib->ui32DataPageMask),
+ (sDevPAddr.uiAddr) & (psMMUAttrib->ui32DataPageMask),
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :SGXMEM:$2 :SGXMEM:$1 0x20\r\n");
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :%s:$2 :%s:$1 0x20\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:$2\r\n",
+ ui32MaxLenScript,
+ "WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
(IMG_UINT32)hUniqueTag1,
- (sDevPAddr.uiAddr + 4) & ~(SGX_MMU_PAGE_MASK),
- (sDevPAddr.uiAddr + 4) & (SGX_MMU_PAGE_MASK));
+ (sDevPAddr.uiAddr + 4) & ~(psMMUAttrib->ui32DataPageMask),
+ (sDevPAddr.uiAddr + 4) & (psMMUAttrib->ui32DataPageMask),
+ psMMUAttrib->sDevId.pszPDumpDevName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
#else
eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
- (IMG_UINT32) hUniqueTag2,
- sPDDevPAddr.uiAddr & SGX_MMU_PDE_ADDR_MASK,
- sPDDevPAddr.uiAddr & ~SGX_MMU_PDE_ADDR_MASK);
+ ui32MaxLenScript,
+ "WRW :%s:PA_%08X%08X:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ sDevPAddr.uiAddr & ~ui32PageMask,
+ sDevPAddr.uiAddr & ui32PageMask,
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2,
+ sPDDevPAddr.uiAddr & psMMUAttrib->ui32PDEMask,
+ sPDDevPAddr.uiAddr & ~psMMUAttrib->ui32PDEMask);
if(eErr != PVRSRV_OK)
{
return eErr;
}
else
{
- PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
+ PVR_ASSERT(!(sDevPAddr.uiAddr & psMMUAttrib->ui32PTEValid));
eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
- "WRW :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag1,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ ui32MaxLenScript,
+ "WRW :%s:PA_%08X%08X:0x%08X 0x%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+ sDevPAddr.uiAddr & ~ui32PageMask,
+ sDevPAddr.uiAddr & ui32PageMask,
sPDDevPAddr.uiAddr);
if(eErr != PVRSRV_OK)
{
return eErr;
}
}
- PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);
+ PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags)
{
PVRSRV_ERROR eErr;
- PDUMP_GET_MSG_STRING();
+ IMG_CHAR pszCommentPrefix[] = "-- ";
+#if defined(PDUMP_DEBUG_OUTFILES)
+ IMG_CHAR pszTemp[256];
+#endif
+ IMG_UINT32 ui32LenCommentPrefix;
+ PDUMP_GET_SCRIPT_STRING();
PDUMP_DBG(("PDumpCommentKM"));
+#if defined(PDUMP_DEBUG_OUTFILES)
+
+ ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+#endif
+
+ PDumpOSVerifyLineEnding(pszComment, ui32MaxLen);
+
+
+ ui32LenCommentPrefix = PDumpOSBuflen(pszCommentPrefix, sizeof(pszCommentPrefix));
- if (!PDumpOSWriteString2("-- ", ui32Flags))
+ if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_SCRIPT2),
+ (IMG_UINT8*)pszCommentPrefix,
+ ui32LenCommentPrefix,
+ ui32Flags))
{
if(ui32Flags & PDUMP_FLAGS_CONTINUOUS)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
}
else
{
return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
}
+#if defined(PDUMP_DEBUG_OUTFILES)
+
+ eErr = PDumpOSSprintf(pszTemp, 256, "%d-%d %s",
+ _PDumpGetPID(),
+ g_ui32EveryLineCounter,
+ pszComment);
- eErr = PDumpOSBufprintf(hMsg, ui32MaxLen, "%s", pszComment);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "%s",
+ pszTemp);
+#else
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "%s",
+ pszComment);
+#endif
if( (eErr != PVRSRV_OK) &&
(eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW))
{
return eErr;
}
-
-
- PDumpOSVerifyLineEnding(hMsg, ui32MaxLen);
- PDumpOSWriteString2(hMsg, ui32Flags);
-
+ PDumpOSWriteString2(hScript, ui32Flags);
return PVRSRV_OK;
}
PDUMP_va_start(ap, pszFormat);
- eErr = PDumpOSVSprintf(hMsg, ui32MaxLen, pszFormat, ap);
+ eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);
PDUMP_va_end(ap);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- return PDumpCommentKM(hMsg, ui32Flags);
+ return PDumpCommentKM(pszMsg, ui32Flags);
}
PVRSRV_ERROR PDumpComment(IMG_CHAR *pszFormat, ...)
PDUMP_va_start(ap, pszFormat);
- eErr = PDumpOSVSprintf(hMsg, ui32MaxLen, pszFormat, ap);
+ eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);
PDUMP_va_end(ap);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- return PDumpCommentKM(hMsg, PDUMP_FLAGS_CONTINUOUS);
+ return PDumpCommentKM(pszMsg, PDUMP_FLAGS_CONTINUOUS);
}
PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags)
PDUMP_GET_MSG_STRING();
- eErr = PDumpOSBufprintf(hMsg, ui32MaxLen, "%s", pszString);
+ eErr = PDumpOSSprintf(pszMsg, ui32MaxLen, "%s", pszString);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSVerifyLineEnding(hMsg, ui32MaxLen);
- ui32MsgLen = PDumpOSBuflen(hMsg, ui32MaxLen);
+ PDumpOSVerifyLineEnding(pszMsg, ui32MaxLen);
+ ui32MsgLen = PDumpOSBuflen(pszMsg, ui32MaxLen);
if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_DRIVERINFO),
- (IMG_UINT8 *)hMsg,
+ (IMG_UINT8*)pszMsg,
ui32MsgLen,
ui32Flags))
{
if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
}
else
{
return PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
}
-
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpBitmapKM( IMG_CHAR *pszFileName,
+PVRSRV_ERROR PDumpBitmapKM( PVRSRV_DEVICE_NODE *psDeviceNode,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Width,
IMG_UINT32 ui32Height,
IMG_UINT32 ui32StrideInBytes,
IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_HANDLE hDevMemContext,
IMG_UINT32 ui32Size,
PDUMP_PIXEL_FORMAT ePixelFormat,
PDUMP_MEM_FORMAT eMemFormat,
IMG_UINT32 ui32PDumpFlags)
{
+ PVRSRV_DEVICE_IDENTIFIER *psDevId = &psDeviceNode->sDevId;
+
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
+
+ if ( _PDumpIsPersistent() )
+ {
+ return PVRSRV_OK;
+ }
+
PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump bitmap of render\r\n");
+
+
+
+ PVR_UNREFERENCED_PARAMETER(hDevMemContext);
+
#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "SII %s %s.bin :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
+ "SII %s %s.bin :%s:v%x:0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\r\n",
pszFileName,
pszFileName,
+ psDevId->pszPDumpDevName,
PDUMP_DATAMASTER_PIXEL,
sDevBaseAddr.uiAddr,
ui32Size,
#else
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "SII %s %s.bin :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX 0x%08X 0x%08lX 0x%08lX 0x%08lX 0x%08X\r\n",
+ "SII %s %s.bin :%s:v:0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\r\n",
pszFileName,
pszFileName,
+ psDevId->pszPDumpDevName,
sDevBaseAddr.uiAddr,
ui32Size,
ui32FileOffset,
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszFileName,
+PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszPDumpRegName,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Address,
IMG_UINT32 ui32Size,
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "SAB :SGXREG:0x%08lX 0x%08lX %s\r\n",
+ "SAB :%s:0x%08X 0x%08X %s\r\n",
+ pszPDumpRegName,
ui32Address,
ui32FileOffset,
pszFileName);
return bFrameDumped;
}
-static PVRSRV_ERROR PDumpSignatureRegister (IMG_CHAR *pszFileName,
+static PVRSRV_ERROR PDumpSignatureRegister (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32Address,
IMG_UINT32 ui32Size,
IMG_UINT32 *pui32FileOffset,
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "SAB :SGXREG:0x%08X 0x%08X %s\r\n",
+ "SAB :%s:0x%08X 0x%08X %s\r\n",
+ psDevId->pszPDumpRegName,
ui32Address,
*pui32FileOffset,
pszFileName);
return PVRSRV_OK;
}
-static IMG_VOID PDumpRegisterRange(IMG_CHAR *pszFileName,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters,
- IMG_UINT32 *pui32FileOffset,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32Flags)
+static IMG_VOID PDumpRegisterRange(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters,
+ IMG_UINT32 *pui32FileOffset,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32Flags)
{
IMG_UINT32 i;
for (i = 0; i < ui32NumRegisters; i++)
{
- PDumpSignatureRegister(pszFileName, pui32Registers[i], ui32Size, pui32FileOffset, ui32Flags);
+ PDumpSignatureRegister(psDevId, pszFileName, pui32Registers[i], ui32Size, pui32FileOffset, ui32Flags);
}
}
-PVRSRV_ERROR PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters)
+PVRSRV_ERROR PDump3DSignatureRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters)
{
PVRSRV_ERROR eErr;
IMG_UINT32 ui32FileOffset, ui32Flags;
ui32FileOffset = 0;
PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump 3D signature registers\r\n");
- eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu_3d.sig", ui32DumpFrameNum);
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_3d.sig", ui32DumpFrameNum);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ PDumpRegisterRange(psDevId,
+ pszFileName,
+ pui32Registers,
+ ui32NumRegisters,
+ &ui32FileOffset,
+ sizeof(IMG_UINT32),
+ ui32Flags);
+
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpTASignatureRegisters (IMG_UINT32 ui32DumpFrameNum,
+PVRSRV_ERROR PDumpTASignatureRegisters (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
IMG_UINT32 ui32TAKickCount,
IMG_BOOL bLastFrame,
IMG_UINT32 *pui32Registers,
ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(IMG_UINT32);
PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump TA signature registers\r\n");
- eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu_ta.sig", ui32DumpFrameNum);
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_ta.sig", ui32DumpFrameNum);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ PDumpRegisterRange(psDevId,
+ pszFileName,
+ pui32Registers,
+ ui32NumRegisters,
+ &ui32FileOffset,
+ sizeof(IMG_UINT32),
+ ui32Flags);
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpCounterRegisters (IMG_UINT32 ui32DumpFrameNum,
+PVRSRV_ERROR PDumpCounterRegisters (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
IMG_BOOL bLastFrame,
IMG_UINT32 *pui32Registers,
IMG_UINT32 ui32NumRegisters)
ui32FileOffset = 0UL;
PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump counter registers\r\n");
- eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%lu.perf", ui32DumpFrameNum);
+ eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u.perf", ui32DumpFrameNum);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpRegisterRange(pszFileName, pui32Registers, ui32NumRegisters, &ui32FileOffset, sizeof(IMG_UINT32), ui32Flags);
+ PDumpRegisterRange(psDevId,
+ pszFileName,
+ pui32Registers,
+ ui32NumRegisters,
+ &ui32FileOffset,
+ sizeof(IMG_UINT32),
+ ui32Flags);
+
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpRegRead(const IMG_UINT32 ui32RegOffset, IMG_UINT32 ui32Flags)
+PVRSRV_ERROR PDumpRegRead(IMG_CHAR *pszPDumpRegName,
+ const IMG_UINT32 ui32RegOffset,
+ IMG_UINT32 ui32Flags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X\r\n",
+ pszPDumpRegName,
+ ui32RegOffset);
if(eErr != PVRSRV_OK)
{
return eErr;
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpCycleCountRegRead(const IMG_UINT32 ui32RegOffset, IMG_BOOL bLastFrame)
+PVRSRV_ERROR PDumpSaveMemKM (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32DataMaster,
+ IMG_UINT32 ui32PDumpFlags)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+ PVR_UNREFERENCED_PARAMETER(ui32DataMaster);
+#endif
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :SGXREG:0x%lX\r\n", ui32RegOffset);
+ eErr = PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+ "SAB :%s:v%x:0x%08X 0x%08X 0x%08X %s.bin\r\n",
+ psDevId->pszPDumpDevName,
+ ui32DataMaster,
+#else
+ "SAB :%s:v:0x%08X 0x%08X 0x%08X %s.bin\r\n",
+ psDevId->pszPDumpDevName,
+#endif
+ sDevBaseAddr.uiAddr,
+ ui32Size,
+ ui32FileOffset,
+ pszFileName);
if(eErr != PVRSRV_OK)
{
return eErr;
}
- PDumpOSWriteString2(hScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
+
+ PDumpOSWriteString2(hScript, ui32PDumpFlags);
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpHWPerfCBKM (IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_DEV_VIRTADDR sDevBaseAddr,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PDumpFlags)
+PVRSRV_ERROR PDumpCycleCountRegRead(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ const IMG_UINT32 ui32RegOffset,
+ IMG_BOOL bLastFrame)
{
PVRSRV_ERROR eErr;
PDUMP_GET_SCRIPT_STRING();
- PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump Hardware Performance Circular Buffer\r\n");
- eErr = PDumpOSBufprintf(hScript,
- ui32MaxLen,
-#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
- "SAB :SGXMEM:v%x:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
- PDUMP_DATAMASTER_EDM,
-#else
- "SAB :SGXMEM:v:0x%08lX 0x%08lX 0x%08lX %s.bin\r\n",
-#endif
- sDevBaseAddr.uiAddr,
- ui32Size,
- ui32FileOffset,
- pszFileName);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X\r\n",
+ psDevId->pszPDumpRegName,
+ ui32RegOffset);
if(eErr != PVRSRV_OK)
{
return eErr;
}
-
- PDumpOSWriteString2(hScript, ui32PDumpFlags);
+ PDumpOSWriteString2(hScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
return PVRSRV_OK;
}
+PVRSRV_ERROR PDumpSignatureBuffer (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_CHAR *pszBufferType,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags)
+{
+ PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump microkernel %s signature Buffer\r\n",
+ pszBufferType);
+ PDumpCommentWithFlags(ui32PDumpFlags, "Buffer format (sizes in 32-bit words):\r\n");
+ PDumpCommentWithFlags(ui32PDumpFlags, "\tNumber of signatures per sample (1)\r\n");
+ PDumpCommentWithFlags(ui32PDumpFlags, "\tNumber of samples (1)\r\n");
+ PDumpCommentWithFlags(ui32PDumpFlags, "\tSignature register offsets (1 * number of signatures)\r\n");
+ PDumpCommentWithFlags(ui32PDumpFlags, "\tSignature sample values (number of samples * number of signatures)\r\n");
+ PDumpCommentWithFlags(ui32PDumpFlags, "Note: If buffer is full, last sample is final state after test completed\r\n");
+ return PDumpSaveMemKM(psDevId, pszFileName, ui32FileOffset, sDevBaseAddr, ui32Size,
+ PDUMP_DATAMASTER_EDM, ui32PDumpFlags);
+}
+
+
+PVRSRV_ERROR PDumpHWPerfCBKM (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags)
+{
+ PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump Hardware Performance Circular Buffer\r\n");
+ return PDumpSaveMemKM(psDevId, pszFileName, ui32FileOffset, sDevBaseAddr, ui32Size,
+ PDUMP_DATAMASTER_EDM, ui32PDumpFlags);
+}
+
+
PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
IMG_UINT32 ui32ROffOffset,
IMG_UINT32 ui32WPosVal,
IMG_DEV_PHYADDR sDevPAddr;
IMG_DEV_VIRTADDR sDevVPageAddr;
+ PDUMP_MMU_ATTRIB *psMMUAttrib;
PDUMP_GET_SCRIPT_STRING();
+ psMMUAttrib = ((BM_BUF*)psROffMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;
+
PVR_ASSERT((ui32ROffOffset + sizeof(IMG_UINT32)) <= psROffMemInfo->ui32AllocSize);
-
-
PDumpOSCPUVAddrToPhysPages(psROffMemInfo->sMemBlk.hOSMemHandle,
ui32ROffOffset,
pui8LinAddr,
+ psMMUAttrib->ui32DataPageMask,
&ui32PageOffset);
eErr = PDumpOSBufprintf(hScript,
ui32MaxLen,
- "CBP :SGXMEM:PA_%8.8lX%8.8lX:0x%8.8lX 0x%8.8lX 0x%8.8lX 0x%8.8lX\r\n",
- (IMG_UINT32) hUniqueTag,
- sDevPAddr.uiAddr & ~(SGX_MMU_PAGE_MASK),
- sDevPAddr.uiAddr & (SGX_MMU_PAGE_MASK),
+ "CBP :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X 0x%08X\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),
+ sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),
ui32WPosVal,
ui32PacketSize,
ui32BufferSize);
PDUMP_GET_SCRIPT_STRING();
PDUMP_DBG(("PDumpIDLWithFlags"));
- eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %lu\r\n", ui32Clocks);
+ eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %u\r\n", ui32Clocks);
if(eErr != PVRSRV_OK)
{
return eErr;
{
return PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS);
}
-#endif
-
PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_PVOID pvAltLinAddrUM,
if (pvAddrUM == IMG_NULL || pvAddrKM == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: Nothing to dump"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
if (ui32Bytes > PDUMP_TEMP_BUFFER_SIZE)
{
- PDumpCommentWithFlags(ui32Flags, "Dumping 0x%8.8lx bytes of memory, in blocks of 0x%8.8lx bytes", ui32Bytes, (IMG_UINT32)PDUMP_TEMP_BUFFER_SIZE);
+ PDumpCommentWithFlags(ui32Flags, "Dumping 0x%08x bytes of memory, in blocks of 0x%08x bytes", ui32Bytes, (IMG_UINT32)PDUMP_TEMP_BUFFER_SIZE);
}
ui32CurrentOffset = ui32Offset;
ui32BytesToDump);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: OSCopyFromUser failed (%d), eError"));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: OSCopyFromUser failed (%d)", eError));
+ return eError;
}
eError = PDumpMemKM(pvAddrKM,
PVR_DPF((PVR_DBG_ERROR, "_PdumpAllocMMUContext: no free MMU context ids"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;
}
PVR_DPF((PVR_DBG_ERROR, "_PdumpFreeMMUContext: MMU context ids invalid"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;
}
IMG_UINT32 *pui32MMUContextID,
IMG_UINT32 ui32MMUType,
IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hOSMemHandle,
IMG_VOID *pvPDCPUAddr)
{
IMG_UINT8 *pui8LinAddr = (IMG_UINT8 *)pvPDCPUAddr;
}
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
+
+ sCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle, pui8LinAddr);
sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
sDevPAddr.uiAddr &= ~((PVRSRV_4K_PAGE_SIZE) -1);
PDumpComment("Set MMU Context\r\n");
- PDumpComment("MMU :%s:v%d %d :%s:PA_%8.8lX%8.8lX\r\n",
+ PDumpComment("MMU :%s:v%d %d :%s:PA_%08X%08X\r\n",
pszMemSpace,
ui32MMUContextID,
ui32MMUType,
pszMemSpace,
- hUniqueTag1,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
sDevPAddr.uiAddr);
return PVRSRV_OK;
}
+PVRSRV_ERROR PDumpStoreMemToFile(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 uiAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags,
+ IMG_HANDLE hUniqueTag)
+{
+ IMG_DEV_PHYADDR sDevPAddr;
+ IMG_DEV_VIRTADDR sDevVPageAddr;
+ IMG_UINT32 ui32PageOffset;
+
+ PDUMP_GET_SCRIPT_STRING();
+
+
+
+
+ ui32PageOffset = (IMG_UINT32)psMemInfo->pvLinAddrKM & psMMUAttrib->ui32DataPageMask;
+
+
+ sDevVPageAddr.uiAddr = uiAddr - ui32PageOffset;
+
+
+ BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+
+
+ sDevPAddr.uiAddr += ui32PageOffset;
+
+ PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "SAB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",
+ psMMUAttrib->sDevId.pszPDumpDevName,
+ (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+ sDevPAddr.uiAddr & ~psMMUAttrib->ui32DataPageMask,
+ sDevPAddr.uiAddr & psMMUAttrib->ui32DataPageMask,
+ ui32Size,
+ ui32FileOffset,
+ pszFileName);
+
+ PDumpOSWriteString2(hScript, ui32PDumpFlags);
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpRegBasedCBP(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegOffset,
+ IMG_UINT32 ui32WPosVal,
+ IMG_UINT32 ui32PacketSize,
+ IMG_UINT32 ui32BufferSize,
+ IMG_UINT32 ui32Flags)
+{
+ PDUMP_GET_SCRIPT_STRING();
+
+ PDumpOSBufprintf(hScript,
+ ui32MaxLen,
+ "CBP :%s:0x%08X 0x%08X 0x%08X 0x%08X\r\n",
+ pszPDumpRegName,
+ ui32RegOffset,
+ ui32WPosVal,
+ ui32PacketSize,
+ ui32BufferSize);
+ PDumpOSWriteString2(hScript, ui32Flags);
+
+ return PVRSRV_OK;
+}
+
+
+#include "syscommon.h"
+
+IMG_EXPORT IMG_VOID PDumpConnectionNotify(IMG_VOID)
+{
+ SYS_DATA *psSysData;
+ PVRSRV_DEVICE_NODE *psThis;
+ PVR_DPF((PVR_DBG_WARNING, "PDump has connected."));
+
+
+ SysAcquireData(&psSysData);
+
+ psThis = psSysData->psDeviceNodeList;
+ while (psThis)
+ {
+ if (psThis->pfnPDumpInitDevice)
+ {
+
+ psThis->pfnPDumpInitDevice(psThis);
+ }
+ psThis = psThis->psNext;
+ }
+}
+
+IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags)
+{
+ IMG_UINT32 ui32BytesWritten = 0;
+ IMG_UINT32 ui32Off = 0;
+ PDBG_STREAM_CONTROL psCtrl = psStream->psCtrl;
+
+
+ if ((ui32Flags & PDUMP_FLAGS_NEVER) != 0)
+ {
+ return ui32BCount;
+ }
+
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ if ( (_PDumpIsProcessActive() == IMG_FALSE ) &&
+ ((ui32Flags & PDUMP_FLAGS_PERSISTENT) == 0) )
+ {
+ return ui32BCount;
+ }
+#endif
+
+
+ if ( ((ui32Flags & PDUMP_FLAGS_PERSISTENT) != 0) && (psCtrl->bInitPhaseComplete) )
+ {
+ while (((IMG_UINT32) ui32BCount > 0) && (ui32BytesWritten != 0xFFFFFFFFU))
+ {
+
+
+
+ ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,
+ PDUMP_WRITE_MODE_PERSISTENT,
+ &pui8Data[ui32Off], ui32BCount, 1, 0);
+
+ if (ui32BytesWritten == 0)
+ {
+ PDumpOSReleaseExecution();
+ }
+
+ if (ui32BytesWritten != 0xFFFFFFFFU)
+ {
+ ui32Off += ui32BytesWritten;
+ ui32BCount -= ui32BytesWritten;
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DbgWrite: Failed to send persistent data"));
+ if( (psCtrl->ui32Flags & DEBUG_FLAGS_READONLY) != 0)
+ {
+
+ PDumpSuspendKM();
+ }
+ return 0xFFFFFFFFU;
+ }
+ }
+
+
+ ui32BCount = ui32Off; ui32Off = 0; ui32BytesWritten = 0;
+ }
+
+ while (((IMG_UINT32) ui32BCount > 0) && (ui32BytesWritten != 0xFFFFFFFFU))
+ {
+ if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)
+ {
+
+
+ if (((psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
+ (psCtrl->ui32Start == 0xFFFFFFFFU) &&
+ (psCtrl->ui32End == 0xFFFFFFFFU) &&
+ psCtrl->bInitPhaseComplete)
+ {
+ ui32BytesWritten = ui32BCount;
+ }
+ else
+ {
+ ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,
+ PDUMP_WRITE_MODE_CONTINUOUS,
+ &pui8Data[ui32Off], ui32BCount, 1, 0);
+ }
+ }
+ else
+ {
+ if (ui32Flags & PDUMP_FLAGS_LASTFRAME)
+ {
+ IMG_UINT32 ui32DbgFlags;
+
+ ui32DbgFlags = 0;
+ if (ui32Flags & PDUMP_FLAGS_RESETLFBUFFER)
+ {
+ ui32DbgFlags |= WRITELF_FLAGS_RESETBUF;
+ }
+
+ ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,
+ PDUMP_WRITE_MODE_LASTFRAME,
+ &pui8Data[ui32Off], ui32BCount, 1, ui32DbgFlags);
+ }
+ else
+ {
+ ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,
+ PDUMP_WRITE_MODE_BINCM,
+ &pui8Data[ui32Off], ui32BCount, 1, 0);
+ }
+ }
+
+
+
+
+ if (ui32BytesWritten == 0)
+ {
+ PDumpOSReleaseExecution();
+ }
+
+ if (ui32BytesWritten != 0xFFFFFFFFU)
+ {
+ ui32Off += ui32BytesWritten;
+ ui32BCount -= ui32BytesWritten;
+ }
+
+
+ }
+
+
+
+ return ui32BytesWritten;
+}
+
+
+
#else
#endif
}
-PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32 ui32PID)
+PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32 ui32PID, IMG_UINT32 ui32Flags)
{
PVRSRV_PER_PROCESS_DATA *psPerProc;
IMG_HANDLE hBlockAlloc;
if (!HASH_Insert(psHashTab, (IMG_UINTPTR_T)ui32PID, (IMG_UINTPTR_T)psPerProc))
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't insert per-process data into hash table"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED;
goto failure;
}
psPerProc->ui32PID = ui32PID;
psPerProc->ui32RefCount = 0;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if (ui32Flags == SRV_FLAGS_PDUMP_ACTIVE)
+ {
+ psPerProc->bPDumpActive = IMG_TRUE;
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(ui32Flags);
+#endif
+
eError = OSPerProcessPrivateDataInit(&psPerProc->hOsPrivateData);
if (eError != PVRSRV_OK)
if (psHashTab == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataInit: Couldn't create per-process data hash table"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE;
}
return PVRSRV_OK;
#include "lists.h"
-DECLARE_LIST_ANY_VA(PVRSRV_POWER_DEV);
-DECLARE_LIST_ANY_VA_2(PVRSRV_POWER_DEV, PVRSRV_ERROR, PVRSRV_OK);
-DECLARE_LIST_INSERT(PVRSRV_POWER_DEV);
-DECLARE_LIST_REMOVE(PVRSRV_POWER_DEV);
-
-IMG_VOID* MatchPowerDeviceIndex_AnyVaCb(PVRSRV_POWER_DEV *psPowerDev, va_list va);
-
-
static IMG_BOOL gbInitServerRunning = IMG_FALSE;
static IMG_BOOL gbInitServerRan = IMG_FALSE;
static IMG_BOOL gbInitSuccessful = IMG_FALSE;
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_STATE eInitServerState, IMG_BOOL bState)
-{
+{
switch(eInitServerState)
{
case PVRSRV_INIT_SERVER_RUNNING:
gbInitServerRunning = bState;
break;
- case PVRSRV_INIT_SERVER_RAN:
+ case PVRSRV_INIT_SERVER_RAN:
gbInitServerRan = bState;
break;
- case PVRSRV_INIT_SERVER_SUCCESSFUL:
+ case PVRSRV_INIT_SERVER_SUCCESSFUL:
gbInitSuccessful = bState;
break;
default:
PVR_DPF((PVR_DBG_ERROR,
- "PVRSRVSetInitServerState : Unknown state %lx", eInitServerState));
- return PVRSRV_ERROR_GENERIC;
+ "PVRSRVSetInitServerState : Unknown state %x", eInitServerState));
+ return PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE;
}
return PVRSRV_OK;
IMG_EXPORT
IMG_BOOL PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_STATE eInitServerState)
-{
+{
IMG_BOOL bReturnVal;
-
+
switch(eInitServerState)
{
case PVRSRV_INIT_SERVER_RUNNING:
bReturnVal = gbInitServerRunning;
break;
- case PVRSRV_INIT_SERVER_RAN:
+ case PVRSRV_INIT_SERVER_RAN:
bReturnVal = gbInitServerRan;
break;
- case PVRSRV_INIT_SERVER_SUCCESSFUL:
+ case PVRSRV_INIT_SERVER_SUCCESSFUL:
bReturnVal = gbInitSuccessful;
break;
default:
PVR_DPF((PVR_DBG_ERROR,
- "PVRSRVGetInitServerState : Unknown state %lx", eInitServerState));
+ "PVRSRVGetInitServerState : Unknown state %x", eInitServerState));
bReturnVal = IMG_FALSE;
}
SysPowerLockUnwrap(psSysData);
}
#endif
+
if ((eError == PVRSRV_OK) &&
!bSystemPowerEvent &&
!_IsSystemStatePowered(psSysData->eCurrentPowerState))
}
-PVRSRV_ERROR PVRSRVDevicePrePowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
+static PVRSRV_ERROR PVRSRVDevicePrePowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
{
PVRSRV_DEV_POWER_STATE eNewDevicePowerState;
PVRSRV_ERROR eError;
- IMG_BOOL bAllDevices;
+ IMG_BOOL bAllDevices;
IMG_UINT32 ui32DeviceIndex;
PVRSRV_DEV_POWER_STATE eNewPowerState;
eError = List_PVRSRV_POWER_DEV_PVRSRV_ERROR_Any_va(psSysData->psPowerDeviceList,
- PVRSRVDevicePrePowerStateKM_AnyVaCb,
+ &PVRSRVDevicePrePowerStateKM_AnyVaCb,
bAllDevices,
ui32DeviceIndex,
eNewPowerState);
return eError;
}
-PVRSRV_ERROR PVRSRVDevicePostPowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
+static PVRSRV_ERROR PVRSRVDevicePostPowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
{
PVRSRV_DEV_POWER_STATE eNewDevicePowerState;
PVRSRV_ERROR eError;
eError = List_PVRSRV_POWER_DEV_PVRSRV_ERROR_Any_va(psSysData->psPowerDeviceList,
- PVRSRVDevicePostPowerStateKM_AnyVaCb,
+ &PVRSRVDevicePostPowerStateKM_AnyVaCb,
bAllDevices,
ui32DeviceIndex,
eNewPowerState);
}
-PVRSRV_ERROR PVRSRVSetDevicePowerStateCoreKM(IMG_UINT32 ui32DeviceIndex,
- PVRSRV_DEV_POWER_STATE eNewPowerState)
-{
- PVRSRV_ERROR eError;
- eError = PVRSRVDevicePrePowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState);
- if(eError != PVRSRV_OK)
- {
- return eError;
- }
-
- eError = PVRSRVDevicePostPowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState);
- return eError;
-}
-
-
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDevicePowerStateKM(IMG_UINT32 ui32DeviceIndex,
PVRSRV_DEV_POWER_STATE eNewPowerState,
{
goto Exit;
}
-
- PDUMPSUSPEND();
+
+ PDUMPSUSPEND();
}
#endif
goto ErrorExit;
}
}
-
+
if (eNewSysPowerState != psSysData->eCurrentPowerState)
{
goto Exit;
}
}
-
+
PVR_DPF((PVR_DBG_MESSAGE,
"PVRSRVSystemPostPowerStateKM: System Power Transition from %d to %d OK",
psSysData->eCurrentPowerState, eNewSysPowerState));
PVRSRVPowerUnlock(KERNEL_ID);
+
if (_IsSystemStatePowered(eNewSysPowerState) &&
PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL))
{
- PVRSRVCommandCompleteCallbacks();
+ PVRSRVScheduleDeviceCallbacks();
}
return eError;
psPowerDev = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
- MatchPowerDeviceIndex_AnyVaCb,
+ &MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
if (psPowerDev)
SysAcquireData(&psSysData);
+
if (OSIsResourceLocked(&psSysData->sPowerStateChangeResource, KERNEL_ID) ||
OSIsResourceLocked(&psSysData->sPowerStateChangeResource, ISR_ID))
{
psPowerDevice = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
- MatchPowerDeviceIndex_AnyVaCb,
+ &MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
return (psPowerDevice && (psPowerDevice->eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON))
? IMG_TRUE : IMG_FALSE;
eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "PVRSRVDevicePreClockSpeedChange : failed to acquire lock, error:0x%lx", eError));
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVDevicePreClockSpeedChange : failed to acquire lock, error:0x%x", eError));
return eError;
}
}
-
+
psPowerDevice = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
- MatchPowerDeviceIndex_AnyVaCb,
+ &MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
-
+
if (psPowerDevice && psPowerDevice->pfnPostClockSpeedChange)
{
eError = psPowerDevice->pfnPreClockSpeedChange(psPowerDevice->hDevCookie,
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,
- "PVRSRVDevicePreClockSpeedChange : Device %lu failed, error:0x%lx",
+ "PVRSRVDevicePreClockSpeedChange : Device %u failed, error:0x%x",
ui32DeviceIndex, eError));
}
}
psPowerDevice = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
- MatchPowerDeviceIndex_AnyVaCb,
+ &MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
if (psPowerDevice && psPowerDevice->pfnPostClockSpeedChange)
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,
- "PVRSRVDevicePostClockSpeedChange : Device %lu failed, error:0x%lx",
+ "PVRSRVDevicePostClockSpeedChange : Device %u failed, error:0x%x",
ui32DeviceIndex, eError));
}
}
#include "services_headers.h"
#include "buffer_manager.h"
+#include "pvr_bridge_km.h"
#include "handle.h"
#include "perproc.h"
#include "pdump_km.h"
+#include "deviceid.h"
#include "ra.h"
#include "pvrversion.h"
#include "lists.h"
-DECLARE_LIST_ANY_VA_2(BM_CONTEXT, PVRSRV_ERROR, PVRSRV_OK);
-
-DECLARE_LIST_FOR_EACH_VA(BM_HEAP);
-
-DECLARE_LIST_ANY_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK);
-DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_ANY_VA_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK);
-DECLARE_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_INSERT(PVRSRV_DEVICE_NODE);
-DECLARE_LIST_REMOVE(PVRSRV_DEVICE_NODE);
-
-IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va);
+IMG_UINT32 g_ui32InitFlags;
+#define INIT_DATA_ENABLE_PDUMPINIT 0x1U
PVRSRV_ERROR AllocateDeviceID(SYS_DATA *psSysData, IMG_UINT32 *pui32DevID)
{
SYS_DEVICE_ID* psDeviceWalker;
SYS_DEVICE_ID* psDeviceEnd;
-
+
psDeviceWalker = &psSysData->sDeviceID[0];
psDeviceEnd = psDeviceWalker + psSysData->ui32NumDevices;
}
psDeviceWalker++;
}
-
+
PVR_DPF((PVR_DBG_ERROR,"AllocateDeviceID: No free and valid device IDs available!"));
PVR_ASSERT(psDeviceWalker < psDeviceEnd);
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE;
}
}
psDeviceWalker++;
}
-
+
PVR_DPF((PVR_DBG_ERROR,"FreeDeviceID: no matching dev ID that is in use!"));
PVR_ASSERT(psDeviceWalker < psDeviceEnd);
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_DEVICEID;
}
IMG_EXPORT
IMG_VOID WriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value)
{
- PVR_DPF((PVR_DBG_MESSAGE,"WriteHWReg Base:%x, Offset: %x, Value %x",pvLinRegBaseAddr,ui32Offset,ui32Value));
+ PVR_DPF((PVR_DBG_MESSAGE,"WriteHWReg Base:%x, Offset: %x, Value %x",
+ (IMG_UINTPTR_T)pvLinRegBaseAddr,ui32Offset,ui32Value));
*(IMG_UINT32*)((IMG_UINTPTR_T)pvLinRegBaseAddr+ui32Offset) = ui32Value;
}
}
#endif
-IMG_VOID PVRSRVEnumerateDevicesKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+static IMG_VOID PVRSRVEnumerateDevicesKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
IMG_UINT *pui32DevCount;
PVRSRV_DEVICE_IDENTIFIER **ppsDevIdList;
if (psDeviceNode->sDevId.eDeviceType != PVRSRV_DEVICE_TYPE_EXT)
{
- *(*ppsDevIdList) = psDeviceNode->sDevId;
+ *(*ppsDevIdList) = psDeviceNode->sDevId;
(*ppsDevIdList)++;
(*pui32DevCount)++;
}
{
SYS_DATA *psSysData;
IMG_UINT32 i;
-
+
if (!pui32NumDevices || !psDevIdList)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDevicesKM: Invalid params"));
{
psDevIdList[i].eDeviceType = PVRSRV_DEVICE_TYPE_UNKNOWN;
}
-
+
*pui32NumDevices = 0;
-
+
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
- PVRSRVEnumerateDevicesKM_ForEachVaCb,
+ &PVRSRVEnumerateDevicesKM_ForEachVaCb,
pui32NumDevices,
&psDevIdList);
-
-
+
+
return PVRSRV_OK;
}
psSysData->eFailedPowerState = PVRSRV_SYS_POWER_STATE_Unspecified;
- if(OSAllocMem( PVRSRV_PAGEABLE_SELECT,
- sizeof(PVRSRV_EVENTOBJECT) ,
+ if(OSAllocMem( PVRSRV_PAGEABLE_SELECT,
+ sizeof(PVRSRV_EVENTOBJECT) ,
(IMG_VOID **)&psSysData->psGlobalEventObject, 0,
- "Event Object") != PVRSRV_OK)
+ "Event Object") != PVRSRV_OK)
{
-
+
goto Error;
}
if(OSEventObjectCreate("PVRSRV_GLOBAL_EVENTOBJECT", psSysData->psGlobalEventObject) != PVRSRV_OK)
{
- goto Error;
+ goto Error;
}
- return eError;
+ PDUMPINIT();
+ g_ui32InitFlags |= INIT_DATA_ENABLE_PDUMPINIT;
+
+ return eError;
+
Error:
PVRSRVDeInit(psSysData);
return eError;
}
+ if( (g_ui32InitFlags & INIT_DATA_ENABLE_PDUMPINIT) > 0)
+ {
+ PDUMPDEINIT();
+ }
+
+
if(psSysData->psGlobalEventObject)
{
OSEventObjectDestroy(psSysData->psGlobalEventObject);
}
-PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData,
PVRSRV_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*),
IMG_UINT32 ui32SOCInterruptBit,
IMG_UINT32 *pui32DeviceIndex)
{
PVRSRV_ERROR eError;
PVRSRV_DEVICE_NODE *psDeviceNode;
+
-
- if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
- sizeof(PVRSRV_DEVICE_NODE),
+ if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
+ sizeof(PVRSRV_DEVICE_NODE),
(IMG_VOID **)&psDeviceNode, IMG_NULL,
- "Device Node") != PVRSRV_OK)
+ "Device Node") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to alloc memory for psDeviceNode"));
return (PVRSRV_ERROR_OUT_OF_MEMORY);
}
- OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
+ OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
eError = pfnRegisterDevice(psDeviceNode);
if (eError != PVRSRV_OK)
psDeviceNode->ui32RefCount = 1;
psDeviceNode->psSysData = psSysData;
psDeviceNode->ui32SOCInterruptBit = ui32SOCInterruptBit;
-
+
AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex);
-
+
List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
*pui32DeviceIndex = psDeviceNode->sDevId.ui32DeviceIndex;
-
+
return PVRSRV_OK;
}
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_TRUE);
if(!psDeviceNode)
PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: Failed PVRSRVResManConnect call"));
return eError;
}
-
+
if(psDeviceNode->pfnInitDevice != IMG_NULL)
{
}
-PVRSRV_ERROR PVRSRVFinaliseSystem_SetPowerState_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+static PVRSRV_ERROR PVRSRVFinaliseSystem_SetPowerState_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
{
PVRSRV_ERROR eError;
eError = PVRSRVSetDevicePowerStateKM(psDeviceNode->sDevId.ui32DeviceIndex,
return eError;
}
-PVRSRV_ERROR PVRSRVFinaliseSystem_CompatCheck_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+static PVRSRV_ERROR PVRSRVFinaliseSystem_CompatCheck_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
{
PVRSRV_ERROR eError;
eError = PVRSRVDevInitCompatCheck(psDeviceNode);
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
- PVRSRVFinaliseSystem_SetPowerState_AnyCb);
+ &PVRSRVFinaliseSystem_SetPowerState_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
- PVRSRVFinaliseSystem_CompatCheck_AnyCb);
+ &PVRSRVFinaliseSystem_CompatCheck_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
-
-
-
-#if !defined(SUPPORT_DRI_DRM)
PDUMPENDINITPHASE();
-#endif
return PVRSRV_OK;
}
return PVRSRV_OK;
}
-IMG_VOID * PVRSRVAcquireDeviceDataKM_Match_AnyVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+static IMG_VOID * PVRSRVAcquireDeviceDataKM_Match_AnyVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
PVRSRV_DEVICE_TYPE eDeviceType;
IMG_UINT32 ui32DevIndex;
eDeviceType = va_arg(va, PVRSRV_DEVICE_TYPE);
ui32DevIndex = va_arg(va, IMG_UINT32);
-
+
if ((eDeviceType != PVRSRV_DEVICE_TYPE_UNKNOWN &&
psDeviceNode->sDevId.eDeviceType == eDeviceType) ||
(eDeviceType == PVRSRV_DEVICE_TYPE_UNKNOWN &&
psDeviceNode = List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- PVRSRVAcquireDeviceDataKM_Match_AnyVaCb,
+ &PVRSRVAcquireDeviceDataKM_Match_AnyVaCb,
eDeviceType,
ui32DevIndex);
-
+
if (!psDeviceNode)
{
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- MatchDeviceKM_AnyVaCb,
+ &MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_TRUE);
if (!psDeviceNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: requested device %d is not present", ui32DevIndex));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_DEVICEID_NOT_FOUND;
}
List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
-
- (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+
+ (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
-
+
return (PVRSRV_OK);
}
IMG_UINT32 ui32Tries)
{
{
+ IMG_UINT32 ui32ActualValue = 0xFFFFFFFFU;
IMG_UINT32 uiMaxTime = ui32Tries * ui32Waitus;
+
LOOP_UNTIL_TIMEOUT(uiMaxTime)
{
- if((*pui32LinMemAddr & ui32Mask) == ui32Value)
+ ui32ActualValue = (*pui32LinMemAddr & ui32Mask);
+ if(ui32ActualValue == ui32Value)
{
return PVRSRV_OK;
}
OSWaitus(ui32Waitus);
} END_LOOP_UNTIL_TIMEOUT();
+
+ PVR_DPF((PVR_DBG_ERROR,"PollForValueKM: Timeout. Expected 0x%x but found 0x%x (mask 0x%x).",
+ ui32Value, ui32ActualValue, ui32Mask));
}
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_TIMEOUT;
}
-#if defined (USING_ISR_INTERRUPTS)
-
-extern IMG_UINT32 gui32EventStatusServicesByISR;
-
-PVRSRV_ERROR PollForInterruptKM (IMG_UINT32 ui32Value,
- IMG_UINT32 ui32Mask,
- IMG_UINT32 ui32Waitus,
- IMG_UINT32 ui32Tries)
-{
- IMG_UINT32 uiMaxTime;
-
- uiMaxTime = ui32Tries * ui32Waitus;
-
-
- LOOP_UNTIL_TIMEOUT(uiMaxTime)
- {
- if ((gui32EventStatusServicesByISR & ui32Mask) == ui32Value)
- {
- gui32EventStatusServicesByISR = 0;
- return PVRSRV_OK;
- }
- OSWaitus(ui32Waitus);
- } END_LOOP_UNTIL_TIMEOUT();
-
- return PVRSRV_ERROR_GENERIC;
-}
-#endif
-
-IMG_VOID PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
+static IMG_VOID PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
{
IMG_CHAR **ppszStr;
IMG_UINT32 *pui32StrLen;
+ IMG_UINT32 ui32Mode;
+ PVRSRV_ERROR (*pfnGetStats)(RA_ARENA *, IMG_CHAR **, IMG_UINT32 *);
ppszStr = va_arg(va, IMG_CHAR**);
pui32StrLen = va_arg(va, IMG_UINT32*);
+ ui32Mode = va_arg(va, IMG_UINT32);
+
+
+ switch(ui32Mode)
+ {
+ case PVRSRV_MISC_INFO_MEMSTATS_PRESENT:
+ pfnGetStats = &RA_GetStats;
+ break;
+ case PVRSRV_MISC_INFO_FREEMEM_PRESENT:
+ pfnGetStats = &RA_GetStatsFreeMem;
+ break;
+ default:
+ return;
+ }
if(psBMHeap->pImportArena)
{
- RA_GetStats(psBMHeap->pImportArena,
- ppszStr,
+ pfnGetStats(psBMHeap->pImportArena,
+ ppszStr,
pui32StrLen);
}
if(psBMHeap->pVMArena)
{
- RA_GetStats(psBMHeap->pVMArena,
- ppszStr,
+ pfnGetStats(psBMHeap->pVMArena,
+ ppszStr,
pui32StrLen);
}
}
-PVRSRV_ERROR PVRSRVGetMiscInfoKM_BMContext_AnyVaCb(BM_CONTEXT *psBMContext, va_list va)
+static PVRSRV_ERROR PVRSRVGetMiscInfoKM_BMContext_AnyVaCb(BM_CONTEXT *psBMContext, va_list va)
{
IMG_UINT32 *pui32StrLen;
IMG_INT32 *pi32Count;
IMG_CHAR **ppszStr;
-
+ IMG_UINT32 ui32Mode;
+
pui32StrLen = va_arg(va, IMG_UINT32*);
pi32Count = va_arg(va, IMG_INT32*);
ppszStr = va_arg(va, IMG_CHAR**);
-
+ ui32Mode = va_arg(va, IMG_UINT32);
+
CHECK_SPACE(*pui32StrLen);
- *pi32Count = OSSNPrintf(*ppszStr, 100, "\nApplication Context (hDevMemContext) 0x%08X:\n",
+ *pi32Count = OSSNPrintf(*ppszStr, 100, "\nApplication Context (hDevMemContext) %p:\n",
(IMG_HANDLE)psBMContext);
UPDATE_SPACE(*ppszStr, *pi32Count, *pui32StrLen);
List_BM_HEAP_ForEach_va(psBMContext->psBMHeap,
- PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb,
+ &PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb,
ppszStr,
- pui32StrLen);
+ pui32StrLen,
+ ui32Mode);
return PVRSRV_OK;
}
-PVRSRV_ERROR PVRSRVGetMiscInfoKM_Device_AnyVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+static PVRSRV_ERROR PVRSRVGetMiscInfoKM_Device_AnyVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
IMG_UINT32 *pui32StrLen;
IMG_INT32 *pi32Count;
IMG_CHAR **ppszStr;
-
+ IMG_UINT32 ui32Mode;
+
pui32StrLen = va_arg(va, IMG_UINT32*);
pi32Count = va_arg(va, IMG_INT32*);
- ppszStr = va_arg(va, IMG_CHAR**);
+ ppszStr = va_arg(va, IMG_CHAR**);
+ ui32Mode = va_arg(va, IMG_UINT32);
CHECK_SPACE(*pui32StrLen);
*pi32Count = OSSNPrintf(*ppszStr, 100, "\n\nDevice Type %d:\n", psDeviceNode->sDevId.eDeviceType);
CHECK_SPACE(*pui32StrLen);
*pi32Count = OSSNPrintf(*ppszStr, 100, "\nKernel Context:\n");
UPDATE_SPACE(*ppszStr, *pi32Count, *pui32StrLen);
-
-
+
List_BM_HEAP_ForEach_va(psDeviceNode->sDevMemoryInfo.pBMKernelContext->psBMHeap,
- PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb,
+ &PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb,
ppszStr,
- pui32StrLen);
+ pui32StrLen,
+ ui32Mode);
}
return List_BM_CONTEXT_PVRSRV_ERROR_Any_va(psDeviceNode->sDevMemoryInfo.pBMContext,
- PVRSRVGetMiscInfoKM_BMContext_AnyVaCb,
+ &PVRSRVGetMiscInfoKM_BMContext_AnyVaCb,
pui32StrLen,
pi32Count,
- ppszStr);
+ ppszStr,
+ ui32Mode);
}
-IMG_EXPORT
+IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfoKM(PVRSRV_MISC_INFO *psMiscInfo)
{
SYS_DATA *psSysData;
-
+
if(!psMiscInfo)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetMiscInfoKM: invalid parameters"));
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetMiscInfoKM: invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
-
+
psMiscInfo->ui32StatePresent = 0;
|PVRSRV_MISC_INFO_MEMSTATS_PRESENT
|PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT
|PVRSRV_MISC_INFO_DDKVERSION_PRESENT
- |PVRSRV_MISC_INFO_CPUCACHEFLUSH_PRESENT))
+ |PVRSRV_MISC_INFO_CPUCACHEOP_PRESENT
+ |PVRSRV_MISC_INFO_RESET_PRESENT
+ |PVRSRV_MISC_INFO_FREEMEM_PRESENT))
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetMiscInfoKM: invalid state request flags"));
- return PVRSRV_ERROR_INVALID_PARAMS;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
IMG_CHAR *pszStr;
IMG_UINT32 ui32StrLen;
IMG_INT32 i32Count;
-
+
pszStr = psMiscInfo->pszMemoryStr;
ui32StrLen = psMiscInfo->ui32MemoryStrLen;
CHECK_SPACE(ui32StrLen);
i32Count = OSSNPrintf(pszStr, 100, "\nLocal Backing Store:\n");
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
-
+
RA_GetStats(*ppArena,
- &pszStr,
+ &pszStr,
&ui32StrLen);
ppArena++;
List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any_va(psSysData->psDeviceNodeList,
- PVRSRVGetMiscInfoKM_Device_AnyVaCb,
+ &PVRSRVGetMiscInfoKM_Device_AnyVaCb,
&ui32StrLen,
&i32Count,
- &pszStr);
+ &pszStr,
+ PVRSRV_MISC_INFO_MEMSTATS_PRESENT);
+
+
+ i32Count = OSSNPrintf(pszStr, 100, "\n");
+ UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+ }
+
+
+ if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_FREEMEM_PRESENT)
+ && psMiscInfo->pszMemoryStr)
+ {
+ IMG_CHAR *pszStr;
+ IMG_UINT32 ui32StrLen;
+ IMG_INT32 i32Count;
+
+ pszStr = psMiscInfo->pszMemoryStr;
+ ui32StrLen = psMiscInfo->ui32MemoryStrLen;
+
+ psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_FREEMEM_PRESENT;
- i32Count = OSSNPrintf(pszStr, 100, "\n\0");
+ List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any_va(psSysData->psDeviceNodeList,
+ &PVRSRVGetMiscInfoKM_Device_AnyVaCb,
+ &ui32StrLen,
+ &i32Count,
+ &pszStr,
+ PVRSRV_MISC_INFO_FREEMEM_PRESENT);
+
+ i32Count = OSSNPrintf(pszStr, 100, "\n");
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
}
psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT;
psMiscInfo->sGlobalEventObject = *psSysData->psGlobalEventObject;
}
-
+
if (((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0UL)
return PVRSRV_ERROR_INVALID_PARAMS;
}
- i32Count = OSSNPrintf(pszStr, ui32LenStrPerNum, "%ld", psMiscInfo->aui32DDKVersion[i]);
+ i32Count = OSSNPrintf(pszStr, ui32LenStrPerNum, "%u", psMiscInfo->aui32DDKVersion[i]);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
if (i != 3)
{
}
}
-#if defined(SUPPORT_CPU_CACHED_BUFFERS)
- if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_CPUCACHEFLUSH_PRESENT) != 0UL)
+ if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_CPUCACHEOP_PRESENT) != 0UL)
{
- if(psMiscInfo->bDeferCPUCacheFlush)
+ if(psMiscInfo->sCacheOpCtl.bDeferOp)
{
- if(!psMiscInfo->bCPUCacheFlushAll)
- {
-
-
-
- PVR_DPF((PVR_DBG_MESSAGE,"PVRSRVGetMiscInfoKM: don't support deferred range flushes"));
- PVR_DPF((PVR_DBG_MESSAGE," using deferred flush all instead"));
- }
-
- psSysData->bFlushAll = IMG_TRUE;
+ psSysData->ePendingCacheOpType = psMiscInfo->sCacheOpCtl.eCacheOpType;
}
else
{
-
- if(psMiscInfo->bCPUCacheFlushAll)
+ PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+ PVRSRV_PER_PROCESS_DATA *psPerProc;
+
+ if(!psMiscInfo->sCacheOpCtl.u.psKernelMemInfo)
{
-
- OSFlushCPUCacheKM();
-
- psSysData->bFlushAll = IMG_FALSE;
+ PVR_DPF((PVR_DBG_WARNING, "PVRSRVGetMiscInfoKM: "
+ "Ignoring non-deferred cache op with no meminfo"));
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
- else
+
+ if(psSysData->ePendingCacheOpType != PVRSRV_MISC_INFO_CPUCACHEOP_NONE)
{
-
- OSFlushCPUCacheRangeKM(psMiscInfo->pvRangeAddrStart, psMiscInfo->pvRangeAddrEnd);
+ PVR_DPF((PVR_DBG_WARNING, "PVRSRVGetMiscInfoKM: "
+ "Deferred cache op is pending. It is unlikely you want "
+ "to combine deferred cache ops with immediate ones"));
}
- }
- }
-#endif
-
- return PVRSRV_OK;
-}
+
+ psPerProc = PVRSRVFindPerProcessData();
-PVRSRV_ERROR IMG_CALLCONV PVRSRVGetFBStatsKM(IMG_UINT32 *pui32Total,
- IMG_UINT32 *pui32Available)
-{
- IMG_UINT32 ui32Total = 0, i = 0;
- IMG_UINT32 ui32Available = 0;
+ if(PVRSRVLookupHandle(psPerProc->psHandleBase,
+ (IMG_PVOID *)&psKernelMemInfo,
+ psMiscInfo->sCacheOpCtl.u.psKernelMemInfo,
+ PVRSRV_HANDLE_TYPE_MEM_INFO) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetMiscInfoKM: "
+ "Can't find kernel meminfo"));
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
- *pui32Total = 0;
- *pui32Available = 0;
+ if(psMiscInfo->sCacheOpCtl.eCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_FLUSH)
+ {
+ if(!OSFlushCPUCacheRangeKM(psKernelMemInfo->sMemBlk.hOSMemHandle,
+ psMiscInfo->sCacheOpCtl.pvBaseVAddr,
+ psMiscInfo->sCacheOpCtl.ui32Length))
+ {
+ return PVRSRV_ERROR_CACHEOP_FAILED;
+ }
+ }
+ else if(psMiscInfo->sCacheOpCtl.eCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_CLEAN)
+ {
+ if(!OSCleanCPUCacheRangeKM(psKernelMemInfo->sMemBlk.hOSMemHandle,
+ psMiscInfo->sCacheOpCtl.pvBaseVAddr,
+ psMiscInfo->sCacheOpCtl.ui32Length))
+ {
+ return PVRSRV_ERROR_CACHEOP_FAILED;
+ }
+ }
+ }
+ }
-
- while(BM_ContiguousStatistics(i, &ui32Total, &ui32Available) == IMG_TRUE)
+#if defined(PVRSRV_RESET_ON_HWTIMEOUT)
+ if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_RESET_PRESENT) != 0UL)
{
- *pui32Total += ui32Total;
- *pui32Available += ui32Available;
-
- i++;
+ PVR_LOG(("User requested OS reset"));
+ OSPanic();
}
+#endif
return PVRSRV_OK;
}
{
if(psDeviceNode->pfnDeviceISR != IMG_NULL)
{
- bStatus = (*psDeviceNode->pfnDeviceISR)(psDeviceNode->pvISRData);
+ bStatus = (*psDeviceNode->pfnDeviceISR)(psDeviceNode->pvISRData);
}
SysClearInterrupts(psSysData, psDeviceNode->ui32SOCInterruptBit);
return bStatus;
}
-IMG_VOID PVRSRVSystemLISR_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+static IMG_VOID PVRSRVSystemLISR_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
{
IMG_BOOL *pbStatus;
pbStatus = va_arg(va, IMG_BOOL*);
pui32InterruptSource = va_arg(va, IMG_UINT32*);
pui32ClearInterrupts = va_arg(va, IMG_UINT32*);
-
-
+
+
if(psDeviceNode->pfnDeviceISR != IMG_NULL)
{
if(*pui32InterruptSource & psDeviceNode->ui32SOCInterruptBit)
{
ui32InterruptSource = SysGetInterruptSource(psSysData, IMG_NULL);
-
+
if(ui32InterruptSource)
{
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
- PVRSRVSystemLISR_ForEachVaCb,
+ &PVRSRVSystemLISR_ForEachVaCb,
&bStatus,
&ui32InterruptSource,
&ui32ClearInterrupts);
}
-IMG_VOID PVRSRVMISR_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+static IMG_VOID PVRSRVMISR_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
{
if(psDeviceNode->pfnDeviceMISR != IMG_NULL)
{
List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
- PVRSRVMISR_ForEachCb);
+ &PVRSRVMISR_ForEachCb);
if (PVRSRVProcessQueues(ISR_ID, IMG_FALSE) == PVRSRV_ERROR_PROCESSING_BLOCKED)
{
PVRSRVProcessQueues(ISR_ID, IMG_FALSE);
}
-
+
if (psSysData->psGlobalEventObject)
{
{
OSEventObjectSignal(hOSEventKM);
}
- }
+ }
}
IMG_EXPORT
-PVRSRV_ERROR IMG_CALLCONV PVRSRVProcessConnect(IMG_UINT32 ui32PID)
+PVRSRV_ERROR IMG_CALLCONV PVRSRVProcessConnect(IMG_UINT32 ui32PID, IMG_UINT32 ui32Flags)
{
- return PVRSRVPerProcessDataConnect(ui32PID);
+ return PVRSRVPerProcessDataConnect(ui32PID, ui32Flags);
}
}
-PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer,
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer,
IMG_SIZE_T *puiBufSize, IMG_BOOL bSave)
{
IMG_SIZE_T uiBytesSaved = 0;
}
+IMG_EXPORT
+const IMG_CHAR *PVRSRVGetErrorStringKM(PVRSRV_ERROR eError)
+{
+
+#include "pvrsrv_errors.h"
+}
+
+static IMG_VOID PVRSRVCommandCompleteCallbacks_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ if(psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
+ {
+
+ (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
+ }
+}
+
+IMG_VOID PVRSRVScheduleDeviceCallbacks(IMG_VOID)
+{
+ SYS_DATA *psSysData;
+ SysAcquireData(&psSysData);
+
+
+ List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
+ &PVRSRVCommandCompleteCallbacks_ForEachCb);
+}
+
+IMG_EXPORT
+IMG_VOID PVRSRVScheduleDevicesKM(IMG_VOID)
+{
+ PVRSRVScheduleDeviceCallbacks();
+}
+
#include "lists.h"
-DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
-#if defined(__linux__) && defined(__KERNEL__)
-
-#include "proc.h"
+#define DC_NUM_COMMANDS_PER_TYPE 1
-static IMG_INT
-QueuePrintCommands (PVRSRV_QUEUE_INFO * psQueue, IMG_CHAR * buffer, size_t size)
+typedef struct _DEVICE_COMMAND_DATA_
{
- off_t off = 0;
- IMG_INT cmds = 0;
- IMG_SIZE_T ui32ReadOffset = psQueue->ui32ReadOffset;
- IMG_SIZE_T ui32WriteOffset = psQueue->ui32WriteOffset;
- PVRSRV_COMMAND * psCmd;
-
- while (ui32ReadOffset != ui32WriteOffset)
- {
- psCmd= (PVRSRV_COMMAND *)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + ui32ReadOffset);
-
- off = printAppend(buffer, size, off, "%p %p %5lu %6lu %3lu %5lu %2lu %2lu %3lu \n",
- psQueue,
- psCmd,
- psCmd->ui32ProcessID,
- psCmd->CommandType,
- psCmd->ui32CmdSize,
- psCmd->ui32DevIndex,
- psCmd->ui32DstSyncCount,
- psCmd->ui32SrcSyncCount,
- psCmd->ui32DataSize);
-
- ui32ReadOffset += psCmd->ui32CmdSize;
- ui32ReadOffset &= psQueue->ui32QueueSize - 1;
- cmds++;
- }
- if (cmds == 0)
- off = printAppend(buffer, size, off, "%p <empty>\n", psQueue);
- return off;
-}
+ PFN_CMD_PROC pfnCmdProc;
+ PCOMMAND_COMPLETE_DATA apsCmdCompleteData[DC_NUM_COMMANDS_PER_TYPE];
+ IMG_UINT32 ui32CCBOffset;
+} DEVICE_COMMAND_DATA;
+#if defined(__linux__) && defined(__KERNEL__)
-#ifdef PVR_PROC_USE_SEQ_FILE
+#include "proc.h"
-void ProcSeqShowQueue(struct seq_file *sfile,void* el)
+void ProcSeqShowQueue(struct seq_file *sfile,void* el)
{
- PVRSRV_QUEUE_INFO * psQueue = (PVRSRV_QUEUE_INFO*)el;
+ PVRSRV_QUEUE_INFO *psQueue = (PVRSRV_QUEUE_INFO*)el;
IMG_INT cmds = 0;
- IMG_SIZE_T ui32ReadOffset;
+ IMG_SIZE_T ui32ReadOffset;
IMG_SIZE_T ui32WriteOffset;
- PVRSRV_COMMAND * psCmd;
+ PVRSRV_COMMAND *psCmd;
- if(el == PVR_PROC_SEQ_START_TOKEN)
+ if(el == PVR_PROC_SEQ_START_TOKEN)
{
seq_printf( sfile,
"Command Queues\n"
{
psCmd= (PVRSRV_COMMAND *)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + ui32ReadOffset);
- seq_printf(sfile, "%p %p %5lu %6lu %3lu %5lu %2lu %2lu %3lu \n",
- psQueue,
- psCmd,
+ seq_printf(sfile, "%x %x %5u %6u %3u %5u %2u %2u %3u \n",
+ (IMG_UINTPTR_T)psQueue,
+ (IMG_UINTPTR_T)psCmd,
psCmd->ui32ProcessID,
psCmd->CommandType,
psCmd->ui32CmdSize,
}
if (cmds == 0)
- seq_printf(sfile, "%p <empty>\n", psQueue);
+ {
+ seq_printf(sfile, "%x <empty>\n", (IMG_UINTPTR_T)psQueue);
+ }
}
-void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off)
+void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off)
{
- PVRSRV_QUEUE_INFO * psQueue;
- SYS_DATA * psSysData;
+ PVRSRV_QUEUE_INFO *psQueue = IMG_NULL;
+ SYS_DATA *psSysData;
+
+ PVR_UNREFERENCED_PARAMETER(sfile);
- if(!off)
+ if(!off)
{
return PVR_PROC_SEQ_START_TOKEN;
}
-
- SysAcquireData(&psSysData);
- for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM);
+ psSysData = SysAcquireDataNoCheck();
+ if (psSysData != IMG_NULL)
+ {
+ for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM);
+ }
+
return psQueue;
}
-
-#endif
-
-off_t
-QueuePrintQueues (IMG_CHAR * buffer, size_t size, off_t off)
-{
- SYS_DATA * psSysData;
- PVRSRV_QUEUE_INFO * psQueue;
-
- SysAcquireData(&psSysData);
-
- if (!off)
- return printAppend (buffer, size, 0,
- "Command Queues\n"
- "Queue CmdPtr Pid Command Size DevInd DSC SSC #Data ...\n");
-
-
-
- for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM)
- ;
-
- return psQueue ? QueuePrintCommands (psQueue, buffer, size) : END_OF_FILE;
-}
#endif
#define GET_SPACE_IN_CMDQ(psQueue) \
- (((psQueue->ui32ReadOffset - psQueue->ui32WriteOffset) \
- + (psQueue->ui32QueueSize - 1)) & (psQueue->ui32QueueSize - 1))
+ ((((psQueue)->ui32ReadOffset - (psQueue)->ui32WriteOffset) \
+ + ((psQueue)->ui32QueueSize - 1)) & ((psQueue)->ui32QueueSize - 1))
#define UPDATE_QUEUE_WOFF(psQueue, ui32Size) \
- psQueue->ui32WriteOffset = (psQueue->ui32WriteOffset + ui32Size) \
- & (psQueue->ui32QueueSize - 1);
+ (psQueue)->ui32WriteOffset = ((psQueue)->ui32WriteOffset + (ui32Size)) \
+ & ((psQueue)->ui32QueueSize - 1);
#define SYNCOPS_STALE(ui32OpsComplete, ui32OpsPending) \
- (ui32OpsComplete >= ui32OpsPending)
+ ((ui32OpsComplete) >= (ui32OpsPending))
-DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
-
static IMG_VOID QueueDumpCmdComplete(COMMAND_COMPLETE_DATA *psCmdCompleteData,
IMG_UINT32 i,
IMG_BOOL bIsSrc)
PVRSRV_SYNC_OBJECT *psSyncObject;
psSyncObject = bIsSrc ? psCmdCompleteData->psSrcSync : psCmdCompleteData->psDstSync;
-
+
if (psCmdCompleteData->bInUse)
{
- PVR_LOG(("\t%s %lu: ROC DevVAddr:0x%lX ROP:0x%lx ROC:0x%lx, WOC DevVAddr:0x%lX WOP:0x%lx WOC:0x%lx",
+ PVR_LOG(("\t%s %u: ROC DevVAddr:0x%X ROP:0x%x ROC:0x%x, WOC DevVAddr:0x%X WOP:0x%x WOC:0x%x",
bIsSrc ? "SRC" : "DEST", i,
psSyncObject[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsPending,
psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsComplete,
psSyncObject[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsPending,
- psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete));
+ psSyncObject[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete))
}
else
{
- PVR_LOG(("\t%s %lu: (Not in use)", bIsSrc ? "SRC" : "DEST", i));
+ PVR_LOG(("\t%s %u: (Not in use)", bIsSrc ? "SRC" : "DEST", i))
}
}
{
if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
{
- IMG_UINT32 i;
+ IMG_UINT32 ui32CmdCounter, ui32SyncCounter;
SYS_DATA *psSysData;
- COMMAND_COMPLETE_DATA **ppsCmdCompleteData;
- COMMAND_COMPLETE_DATA *psCmdCompleteData;
-
+ DEVICE_COMMAND_DATA *psDeviceCommandData;
+ PCOMMAND_COMPLETE_DATA psCmdCompleteData;
+
SysAcquireData(&psSysData);
- ppsCmdCompleteData = psSysData->ppsCmdCompleteData[psDeviceNode->sDevId.ui32DeviceIndex];
+ psDeviceCommandData = psSysData->apsDeviceCommandData[psDeviceNode->sDevId.ui32DeviceIndex];
- if (ppsCmdCompleteData != IMG_NULL)
+ if (psDeviceCommandData != IMG_NULL)
{
- psCmdCompleteData = ppsCmdCompleteData[DC_FLIP_COMMAND];
-
- PVR_LOG(("Command Complete Data for display device %lu:", psDeviceNode->sDevId.ui32DeviceIndex));
-
- for (i = 0; i < psCmdCompleteData->ui32SrcSyncCount; i++)
+ for (ui32CmdCounter = 0; ui32CmdCounter < DC_NUM_COMMANDS_PER_TYPE; ui32CmdCounter++)
{
- QueueDumpCmdComplete(psCmdCompleteData, i, IMG_TRUE);
- }
+ psCmdCompleteData = psDeviceCommandData[DC_FLIP_COMMAND].apsCmdCompleteData[ui32CmdCounter];
- for (i = 0; i < psCmdCompleteData->ui32DstSyncCount; i++)
- {
- QueueDumpCmdComplete(psCmdCompleteData, i, IMG_FALSE);
- }
+ PVR_LOG(("Flip Command Complete Data %u for display device %u:",
+ ui32CmdCounter, psDeviceNode->sDevId.ui32DeviceIndex))
+
+ for (ui32SyncCounter = 0;
+ ui32SyncCounter < psCmdCompleteData->ui32SrcSyncCount;
+ ui32SyncCounter++)
+ {
+ QueueDumpCmdComplete(psCmdCompleteData, ui32SyncCounter, IMG_TRUE);
+ }
+
+ for (ui32SyncCounter = 0;
+ ui32SyncCounter < psCmdCompleteData->ui32DstSyncCount;
+ ui32SyncCounter++)
+ {
+ QueueDumpCmdComplete(psCmdCompleteData, ui32SyncCounter, IMG_FALSE);
+ }
+ }
}
else
{
- PVR_LOG(("There is no Command Complete Data for display device %u", psDeviceNode->sDevId.ui32DeviceIndex));
+ PVR_LOG(("There is no Command Complete Data for display device %u", psDeviceNode->sDevId.ui32DeviceIndex))
}
}
}
{
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
- List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList, QueueDumpDebugInfo_ForEachCb);
+ List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList, &QueueDumpDebugInfo_ForEachCb);
}
-IMG_SIZE_T NearestPower2(IMG_SIZE_T ui32Value)
+static IMG_SIZE_T NearestPower2(IMG_SIZE_T ui32Value)
{
IMG_SIZE_T ui32Temp, ui32Result = 1;
SysAcquireData(&psSysData);
- if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_QUEUE_INFO),
(IMG_VOID **)&psQueueInfo, &hMemBlock,
- "Queue Info") != PVRSRV_OK)
+ "Queue Info");
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue struct"));
goto ErrorExit;
psQueueInfo->ui32ProcessID = OSGetCurrentProcessIDKM();
- if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- ui32Power2QueueSize + PVRSRV_MAX_CMD_SIZE,
+ eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ ui32Power2QueueSize + PVRSRV_MAX_CMD_SIZE,
&psQueueInfo->pvLinQueueKM, &hMemBlock,
- "Command Queue") != PVRSRV_OK)
+ "Command Queue");
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue buffer"));
goto ErrorExit;
goto ErrorExit;
}
}
+
-
- if (OSLockResource(&psSysData->sQProcessResource,
- KERNEL_ID) != PVRSRV_OK)
+ eError = OSLockResource(&psSysData->sQProcessResource,
+ KERNEL_ID);
+ if (eError != PVRSRV_OK)
{
goto ErrorExit;
}
psQueueInfo->psNextKM = psSysData->psQueueList;
psSysData->psQueueList = psQueueInfo;
- if (OSUnlockResource(&psSysData->sQProcessResource, KERNEL_ID) != PVRSRV_OK)
+ eError = OSUnlockResource(&psSysData->sQProcessResource, KERNEL_ID);
+ if (eError != PVRSRV_OK)
{
goto ErrorExit;
}
*ppsQueueInfo = psQueueInfo;
return PVRSRV_OK;
-
+
ErrorExit:
if(psQueueInfo)
psQueueInfo->pvLinQueueKM = IMG_NULL;
}
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- sizeof(PVRSRV_QUEUE_INFO),
- psQueueInfo,
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ sizeof(PVRSRV_QUEUE_INFO),
+ psQueueInfo,
psQueueInfo->hMemBlock[0]);
}
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
psQueue = psSysData->psQueueList;
+
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
{
if(psQueueInfo->ui32ReadOffset == psQueueInfo->ui32WriteOffset)
{
bTimeout = IMG_FALSE;
break;
- }
+ }
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
} END_LOOP_UNTIL_TIMEOUT();
}
- eError = OSLockResource(&psSysData->sQProcessResource,
+ eError = OSLockResource(&psSysData->sQProcessResource,
KERNEL_ID);
if (eError != PVRSRV_OK)
{
goto ErrorExit;
}
-
+
if(psQueue == psQueueInfo)
{
psSysData->psQueueList = psQueueInfo->psNextKM;
goto ErrorExit;
}
}
-
+
ErrorExit:
return eError;
return PVRSRV_ERROR_CMD_TOO_BIG;
}
+
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
{
if (GET_SPACE_IN_CMDQ(psQueue) > ui32ParamSize)
{
bTimeout = IMG_FALSE;
- break;
+ break;
}
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
} END_LOOP_UNTIL_TIMEOUT();
ui32DataByteSize = (ui32DataByteSize + 3UL) & ~3UL;
- ui32CommandSize = sizeof(PVRSRV_COMMAND)
+ ui32CommandSize = sizeof(PVRSRV_COMMAND)
+ ((ui32DstSyncCount + ui32SrcSyncCount) * sizeof(PVRSRV_SYNC_OBJECT))
+ ui32DataByteSize;
psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand) + sizeof(PVRSRV_COMMAND));
- psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psDstSync)
+ psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psDstSync)
+ (ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
- psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psSrcSync)
+ psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand->psSrcSync)
+ (ui32SrcSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
psCommand->ui32DataSize = ui32DataByteSize;
psCommand->psDstSync[i].ui32WriteOpsPending = PVRSRVGetWriteOpsPending(apsDstSync[i], IMG_FALSE);
psCommand->psDstSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsDstSync[i], IMG_FALSE);
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Dst %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x",
i, psCommand->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCommand->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCommand->psDstSync[i].ui32ReadOpsPending,
{
psCommand->psSrcSync[i].psKernelSyncInfoKM = apsSrcSync[i];
psCommand->psSrcSync[i].ui32WriteOpsPending = PVRSRVGetWriteOpsPending(apsSrcSync[i], IMG_TRUE);
- psCommand->psSrcSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsSrcSync[i], IMG_TRUE);
+ psCommand->psSrcSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsSrcSync[i], IMG_TRUE);
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInsertCommandKM: Src %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x",
i, psCommand->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCommand->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCommand->psSrcSync[i].ui32ReadOpsPending,
if (psCommand->ui32DstSyncCount > 0)
{
- psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psCommand->psDstSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND));
}
if (psCommand->ui32SrcSyncCount > 0)
{
- psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psCommand->psSrcSync = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND)
+ (psCommand->ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
}
- psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psCommand->pvData = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psQueue->pvLinQueueKM)
+ psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND)
+ (psCommand->ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT))
+ (psCommand->ui32SrcSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
UPDATE_QUEUE_WOFF(psQueue, psCommand->ui32CmdSize);
-
+
return PVRSRV_OK;
}
-IMG_EXPORT
+static
PVRSRV_ERROR PVRSRVProcessCommand(SYS_DATA *psSysData,
PVRSRV_COMMAND *psCommand,
IMG_BOOL bFlush)
PVRSRV_ERROR eError = PVRSRV_OK;
IMG_UINT32 ui32WriteOpsComplete;
IMG_UINT32 ui32ReadOpsComplete;
+ DEVICE_COMMAND_DATA *psDeviceCommandData;
+ IMG_UINT32 ui32CCBOffset;
psWalkerObj = psCommand->psDstSync;
{
PVR_DPF((PVR_DBG_WARNING,
"PVRSRVProcessCommand: Stale syncops psSyncData:0x%x ui32WriteOpsComplete:0x%x ui32WriteOpsPending:0x%x",
- psSyncData, ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending));
+ (IMG_UINTPTR_T)psSyncData, ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending));
}
if (!bFlush ||
}
- psCmdCompleteData = psSysData->ppsCmdCompleteData[psCommand->ui32DevIndex][psCommand->CommandType];
+ psDeviceCommandData = psSysData->apsDeviceCommandData[psCommand->ui32DevIndex];
+ ui32CCBOffset = psDeviceCommandData[psCommand->CommandType].ui32CCBOffset;
+ psCmdCompleteData = psDeviceCommandData[psCommand->CommandType].apsCmdCompleteData[ui32CCBOffset];
if (psCmdCompleteData->bInUse)
{
{
psCmdCompleteData->psDstSync[i] = psCommand->psDstSync[i];
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Dst %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x (CCB:%u)",
i, psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psDstSync[i].ui32ReadOpsPending,
- psCmdCompleteData->psDstSync[i].ui32WriteOpsPending));
+ psCmdCompleteData->psDstSync[i].ui32WriteOpsPending,
+ ui32CCBOffset));
}
+
psCmdCompleteData->ui32SrcSyncCount = psCommand->ui32SrcSyncCount;
for (i=0; i<psCommand->ui32SrcSyncCount; i++)
{
psCmdCompleteData->psSrcSync[i] = psCommand->psSrcSync[i];
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: Src %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x (CCB:%u)",
i, psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psSrcSync[i].ui32ReadOpsPending,
- psCmdCompleteData->psSrcSync[i].ui32WriteOpsPending));
+ psCmdCompleteData->psSrcSync[i].ui32WriteOpsPending,
+ ui32CCBOffset));
}
- if (psSysData->ppfnCmdProcList[psCommand->ui32DevIndex][psCommand->CommandType]((IMG_HANDLE)psCmdCompleteData,
- psCommand->ui32DataSize,
- psCommand->pvData) == IMG_FALSE)
+ if (psDeviceCommandData[psCommand->CommandType].pfnCmdProc((IMG_HANDLE)psCmdCompleteData,
+ psCommand->ui32DataSize,
+ psCommand->pvData) == IMG_FALSE)
{
eError = PVRSRV_ERROR_CMD_NOT_PROCESSED;
}
+
+ psDeviceCommandData[psCommand->CommandType].ui32CCBOffset = (ui32CCBOffset + 1) % DC_NUM_COMMANDS_PER_TYPE;
+
return eError;
}
-IMG_VOID PVRSRVProcessQueues_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+static IMG_VOID PVRSRVProcessQueues_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
{
if (psDeviceNode->bReProcessDeviceCommandComplete &&
psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
}
else
{
- PVR_DPF((PVR_DBG_MESSAGE,"PVRSRVProcessQueues: Couldn't acquire queue processing lock"));
+ PVR_DPF((PVR_DBG_MESSAGE,"PVRSRVProcessQueues: Couldn't acquire queue processing lock"));
}
}
else
PVR_DPF((PVR_DBG_MESSAGE,"PVRSRVProcessQueues: Queue processing lock-acquire failed when called from the Services driver."));
PVR_DPF((PVR_DBG_MESSAGE," This is due to MISR queue processing being interrupted by the Services driver."));
}
-
+
return PVRSRV_OK;
}
if (PVRSRVProcessCommand(psSysData, psCommand, bFlush) == PVRSRV_OK)
{
-
- UPDATE_QUEUE_ROFF(psQueue, psCommand->ui32CmdSize)
- if (bFlush)
- {
- continue;
- }
+ UPDATE_QUEUE_ROFF(psQueue, psCommand->ui32CmdSize)
+
+ continue;
}
break;
List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
- PVRSRVProcessQueues_ForEachCb);
-
+ &PVRSRVProcessQueues_ForEachCb);
+
OSUnlockResource(&psSysData->sQProcessResource, ui32CallerID);
-
+
if(psSysData->bReProcessQueues)
{
return PVRSRV_ERROR_PROCESSING_BLOCKED;
}
-
+
return PVRSRV_OK;
}
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+IMG_INTERNAL
+IMG_VOID PVRSRVFreeCommandCompletePacketKM(IMG_HANDLE hCmdCookie,
+ IMG_BOOL bScheduleMISR)
+{
+ COMMAND_COMPLETE_DATA *psCmdCompleteData = (COMMAND_COMPLETE_DATA *)hCmdCookie;
+ SYS_DATA *psSysData;
+
+ SysAcquireData(&psSysData);
+
+
+ psCmdCompleteData->bInUse = IMG_FALSE;
+
+
+ PVRSRVScheduleDeviceCallbacks();
+
+ if(bScheduleMISR)
+ {
+ OSScheduleMISR(psSysData);
+ }
+}
+
+#endif
+
IMG_EXPORT
IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie,
{
psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete++;
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Dst %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Dst %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x",
i, psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psDstSync[i].ui32ReadOpsPending,
{
psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsComplete++;
- PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Src %lu RO-VA:0x%lx WO-VA:0x%lx ROP:0x%lx WOP:0x%lx",
+ PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVCommandCompleteKM: Src %u RO-VA:0x%x WO-VA:0x%x ROP:0x%x WOP:0x%x",
i, psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sReadOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->sWriteOpsCompleteDevVAddr.uiAddr,
psCmdCompleteData->psSrcSync[i].ui32ReadOpsPending,
psCmdCompleteData->psSrcSync[i].ui32WriteOpsPending));
}
-
+
psCmdCompleteData->bInUse = IMG_FALSE;
+
-
- PVRSRVCommandCompleteCallbacks();
-
-#if defined(SYS_USING_INTERRUPTS)
+ PVRSRVScheduleDeviceCallbacks();
+
if(bScheduleMISR)
{
OSScheduleMISR(psSysData);
}
-#else
- PVR_UNREFERENCED_PARAMETER(bScheduleMISR);
-#endif
}
-IMG_VOID PVRSRVCommandCompleteCallbacks_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
-{
- if(psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
- {
-
- (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
- }
-}
-IMG_VOID PVRSRVCommandCompleteCallbacks(IMG_VOID)
-{
- SYS_DATA *psSysData;
- SysAcquireData(&psSysData);
-
-
- List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
- PVRSRVCommandCompleteCallbacks_ForEachCb);
-}
IMG_EXPORT
PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex,
{
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
- IMG_UINT32 i;
+ IMG_UINT32 ui32CmdCounter, ui32CmdTypeCounter;
IMG_SIZE_T ui32AllocSize;
- PFN_CMD_PROC *ppfnCmdProc;
+ DEVICE_COMMAND_DATA *psDeviceCommandData;
COMMAND_COMPLETE_DATA *psCmdCompleteData;
SysAcquireData(&psSysData);
- eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
- ui32CmdCount * sizeof(PFN_CMD_PROC),
- (IMG_VOID **)&psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL,
- "Internal Queue Info structure");
- if (eError != PVRSRV_OK)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc queue"));
- return eError;
- }
-
-
- ppfnCmdProc = psSysData->ppfnCmdProcList[ui32DevIndex];
-
-
- for (i=0; i<ui32CmdCount; i++)
- {
- ppfnCmdProc[i] = ppfnCmdProcList[i];
- }
-
-
- ui32AllocSize = ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*);
- eError = OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
- ui32AllocSize,
- (IMG_VOID **)&psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL,
- "Array of Pointers for Command Store");
+ ui32AllocSize = ui32CmdCount * sizeof(*psDeviceCommandData);
+ eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ ui32AllocSize,
+ (IMG_VOID **)&psDeviceCommandData, IMG_NULL,
+ "Array of Pointers for Command Store");
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc CC data"));
goto ErrorExit;
}
- for (i=0; i<ui32CmdCount; i++)
+ psSysData->apsDeviceCommandData[ui32DevIndex] = psDeviceCommandData;
+
+ for (ui32CmdTypeCounter = 0; ui32CmdTypeCounter < ui32CmdCount; ui32CmdTypeCounter++)
{
+ psDeviceCommandData[ui32CmdTypeCounter].pfnCmdProc = ppfnCmdProcList[ui32CmdTypeCounter];
+ psDeviceCommandData[ui32CmdTypeCounter].ui32CCBOffset = 0;
-
- ui32AllocSize = sizeof(COMMAND_COMPLETE_DATA)
- + ((ui32MaxSyncsPerCmd[i][0]
- + ui32MaxSyncsPerCmd[i][1])
- * sizeof(PVRSRV_SYNC_OBJECT));
-
- eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- ui32AllocSize,
- (IMG_VOID **)&psSysData->ppsCmdCompleteData[ui32DevIndex][i],
- IMG_NULL,
- "Command Complete Data");
- if (eError != PVRSRV_OK)
+ for (ui32CmdCounter = 0; ui32CmdCounter < DC_NUM_COMMANDS_PER_TYPE; ui32CmdCounter++)
{
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc cmd %d",i));
- goto ErrorExit;
- }
+
-
- OSMemSet(psSysData->ppsCmdCompleteData[ui32DevIndex][i], 0x00, ui32AllocSize);
+ ui32AllocSize = sizeof(COMMAND_COMPLETE_DATA)
+ + ((ui32MaxSyncsPerCmd[ui32CmdTypeCounter][0]
+ + ui32MaxSyncsPerCmd[ui32CmdTypeCounter][1])
+ * sizeof(PVRSRV_SYNC_OBJECT));
- psCmdCompleteData = psSysData->ppsCmdCompleteData[ui32DevIndex][i];
+ eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ ui32AllocSize,
+ (IMG_VOID **)&psCmdCompleteData,
+ IMG_NULL,
+ "Command Complete Data");
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc cmd %d", ui32CmdTypeCounter));
+ goto ErrorExit;
+ }
+
+ psDeviceCommandData[ui32CmdTypeCounter].apsCmdCompleteData[ui32CmdCounter] = psCmdCompleteData;
+
+
+ OSMemSet(psCmdCompleteData, 0x00, ui32AllocSize);
-
- psCmdCompleteData->psDstSync = (PVRSRV_SYNC_OBJECT*)
- (((IMG_UINTPTR_T)psCmdCompleteData)
- + sizeof(COMMAND_COMPLETE_DATA));
- psCmdCompleteData->psSrcSync = (PVRSRV_SYNC_OBJECT*)
- (((IMG_UINTPTR_T)psCmdCompleteData->psDstSync)
- + (sizeof(PVRSRV_SYNC_OBJECT) * ui32MaxSyncsPerCmd[i][0]));
-
- psCmdCompleteData->ui32AllocSize = ui32AllocSize;
+
+ psCmdCompleteData->psDstSync = (PVRSRV_SYNC_OBJECT*)
+ (((IMG_UINTPTR_T)psCmdCompleteData)
+ + sizeof(COMMAND_COMPLETE_DATA));
+ psCmdCompleteData->psSrcSync = (PVRSRV_SYNC_OBJECT*)
+ (((IMG_UINTPTR_T)psCmdCompleteData->psDstSync)
+ + (sizeof(PVRSRV_SYNC_OBJECT) * ui32MaxSyncsPerCmd[ui32CmdTypeCounter][0]));
+
+ psCmdCompleteData->ui32AllocSize = ui32AllocSize;
+ }
}
return PVRSRV_OK;
- if(psSysData->ppsCmdCompleteData[ui32DevIndex] != IMG_NULL)
- {
- for (i=0; i<ui32CmdCount; i++)
- {
- if (psSysData->ppsCmdCompleteData[ui32DevIndex][i] != IMG_NULL)
- {
- ui32AllocSize = sizeof(COMMAND_COMPLETE_DATA)
- + ((ui32MaxSyncsPerCmd[i][0]
- + ui32MaxSyncsPerCmd[i][1])
- * sizeof(PVRSRV_SYNC_OBJECT));
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppsCmdCompleteData[ui32DevIndex][i], IMG_NULL);
- psSysData->ppsCmdCompleteData[ui32DevIndex][i] = IMG_NULL;
- }
- }
- ui32AllocSize = ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*);
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppsCmdCompleteData[ui32DevIndex], IMG_NULL);
- psSysData->ppsCmdCompleteData[ui32DevIndex] = IMG_NULL;
- }
+ if (PVRSRVRemoveCmdProcListKM(ui32DevIndex, ui32CmdCount) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "PVRSRVRegisterCmdProcListKM: Failed to clean up after error, device 0x%x",
+ ui32DevIndex));
+ }
- if(psSysData->ppfnCmdProcList[ui32DevIndex] != IMG_NULL)
- {
- ui32AllocSize = ui32CmdCount * sizeof(PFN_CMD_PROC);
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psSysData->ppfnCmdProcList[ui32DevIndex], IMG_NULL);
- psSysData->ppfnCmdProcList[ui32DevIndex] = IMG_NULL;
- }
-
return eError;
}
PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32 ui32DevIndex,
IMG_UINT32 ui32CmdCount)
{
- SYS_DATA *psSysData;
- IMG_UINT32 i;
+ SYS_DATA *psSysData;
+ IMG_UINT32 ui32CmdTypeCounter, ui32CmdCounter;
+ DEVICE_COMMAND_DATA *psDeviceCommandData;
+ COMMAND_COMPLETE_DATA *psCmdCompleteData;
+ IMG_SIZE_T ui32AllocSize;
if(ui32DevIndex >= SYS_DEVICE_COUNT)
{
PVR_DPF((PVR_DBG_ERROR,
- "PVRSRVRemoveCmdProcListKM: invalid DeviceType 0x%x",
- ui32DevIndex));
+ "PVRSRVRemoveCmdProcListKM: invalid DeviceType 0x%x",
+ ui32DevIndex));
return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
- if(psSysData->ppsCmdCompleteData[ui32DevIndex] == IMG_NULL)
- {
- PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveCmdProcListKM: Invalid command array"));
- return PVRSRV_ERROR_INVALID_PARAMS;
- }
- else
+ psDeviceCommandData = psSysData->apsDeviceCommandData[ui32DevIndex];
+ if(psDeviceCommandData != IMG_NULL)
{
- for(i=0; i<ui32CmdCount; i++)
+ for (ui32CmdTypeCounter = 0; ui32CmdTypeCounter < ui32CmdCount; ui32CmdTypeCounter++)
{
-
- if(psSysData->ppsCmdCompleteData[ui32DevIndex][i] != IMG_NULL)
+ for (ui32CmdCounter = 0; ui32CmdCounter < DC_NUM_COMMANDS_PER_TYPE; ui32CmdCounter++)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- psSysData->ppsCmdCompleteData[ui32DevIndex][i]->ui32AllocSize,
- psSysData->ppsCmdCompleteData[ui32DevIndex][i],
- IMG_NULL);
- psSysData->ppsCmdCompleteData[ui32DevIndex][i] = IMG_NULL;
+ psCmdCompleteData = psDeviceCommandData[ui32CmdTypeCounter].apsCmdCompleteData[ui32CmdCounter];
+
+
+ if (psCmdCompleteData != IMG_NULL)
+ {
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, psCmdCompleteData->ui32AllocSize,
+ psCmdCompleteData, IMG_NULL);
+ psDeviceCommandData[ui32CmdTypeCounter].apsCmdCompleteData[ui32CmdCounter] = IMG_NULL;
+ }
}
}
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- ui32CmdCount * sizeof(COMMAND_COMPLETE_DATA*),
- psSysData->ppsCmdCompleteData[ui32DevIndex],
- IMG_NULL);
- psSysData->ppsCmdCompleteData[ui32DevIndex] = IMG_NULL;
- }
-
-
- if(psSysData->ppfnCmdProcList[ui32DevIndex] != IMG_NULL)
- {
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- ui32CmdCount * sizeof(PFN_CMD_PROC),
- psSysData->ppfnCmdProcList[ui32DevIndex],
- IMG_NULL);
- psSysData->ppfnCmdProcList[ui32DevIndex] = IMG_NULL;
+ ui32AllocSize = ui32CmdCount * sizeof(*psDeviceCommandData);
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, ui32AllocSize, psDeviceCommandData, IMG_NULL);
+ psSysData->apsDeviceCommandData[ui32DevIndex] = IMG_NULL;
}
return PVRSRV_OK;
#if defined(VALIDATE_ARENA_TEST)
typedef enum RESOURCE_DESCRIPTOR_TAG {
-
+
RESOURCE_SPAN_LIVE = 10,
- RESOURCE_SPAN_FREE,
+ RESOURCE_SPAN_FREE,
IMPORTED_RESOURCE_SPAN_START,
- IMPORTED_RESOURCE_SPAN_LIVE,
- IMPORTED_RESOURCE_SPAN_FREE,
- IMPORTED_RESOURCE_SPAN_END,
+ IMPORTED_RESOURCE_SPAN_LIVE,
+ IMPORTED_RESOURCE_SPAN_FREE,
+ IMPORTED_RESOURCE_SPAN_END,
} RESOURCE_DESCRIPTOR;
RA_STATISTICS sStatistics;
#endif
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
#define PROC_NAME_SIZE 32
-#ifdef PVR_PROC_USE_SEQ_FILE
struct proc_dir_entry* pProcInfo;
struct proc_dir_entry* pProcSegs;
-#else
- IMG_CHAR szProcInfoName[PROC_NAME_SIZE];
- IMG_CHAR szProcSegsName[PROC_NAME_SIZE];
-#endif
IMG_BOOL bInitProcEntry;
#endif
IMG_VOID RA_Dump (RA_ARENA *pArena);
#endif
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
-
-#ifdef PVR_PROC_USE_SEQ_FILE
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
static void RA_ProcSeqShowInfo(struct seq_file *sfile, void* el);
static void* RA_ProcSeqOff2ElementInfo(struct seq_file * sfile, loff_t off);
static void RA_ProcSeqShowRegs(struct seq_file *sfile, void* el);
static void* RA_ProcSeqOff2ElementRegs(struct seq_file * sfile, loff_t off);
-#else
-static IMG_INT
-RA_DumpSegs(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
-static IMG_INT
-RA_DumpInfo(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
-#endif
-
#endif
#ifdef USE_BM_FREESPACE_CHECK
IMG_VOID CheckBMFreespace(IMG_VOID);
#endif
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
static IMG_CHAR *ReplaceSpaces(IMG_CHAR * const pS)
{
IMG_CHAR *pT;
static IMG_BOOL
_RequestAllocFail (IMG_VOID *_h,
IMG_SIZE_T _uSize,
- IMG_SIZE_T *_pActualSize,
+ IMG_SIZE_T *_pActualSize,
BM_MAPPING **_ppsMapping,
IMG_UINT32 _uFlags,
IMG_UINTPTR_T *_pBase)
if ((pInsertionPoint == IMG_NULL) || (pArena == IMG_NULL))
{
PVR_DPF ((PVR_DBG_ERROR,"_SegmentListInsertAfter: invalid parameters"));
- return PVRSRV_ERROR_INVALID_PARAMS;
+ return PVRSRV_ERROR_INVALID_PARAMS;
}
pBT->pNextSegment = pInsertionPoint->pNextSegment;
if (pInsertionPoint->pNextSegment == IMG_NULL)
pArena->pTailSegment = pBT;
else
- pInsertionPoint->pNextSegment->pPrevSegment = pBT;
+ pInsertionPoint->pNextSegment->pPrevSegment = pBT;
pInsertionPoint->pNextSegment = pBT;
return PVRSRV_OK;
eError = _SegmentListInsertAfter (pArena, pBTScan, pBT);
if (eError != PVRSRV_OK)
{
- return eError;
+ return eError;
}
}
}
PVR_DPF ((PVR_DBG_ERROR,"_SegmentSplit: invalid parameter - pArena"));
return IMG_NULL;
}
-
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- sizeof(BT),
+
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(BT),
(IMG_VOID **)&pNeighbour, IMG_NULL,
"Boundary Tag") != PVRSRV_OK)
{
}
OSMemSet(pBT, 0, sizeof(BT));
-
+
#if defined(VALIDATE_ARENA_TEST)
pBT->ui32BoundaryTagID = ++ui32BoundaryTagID;
#endif
_BuildBT (IMG_UINTPTR_T base, IMG_SIZE_T uSize)
{
BT *pBT;
-
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
- sizeof(BT),
+
+ if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+ sizeof(BT),
(IMG_VOID **)&pBT, IMG_NULL,
"Boundary Tag") != PVRSRV_OK)
{
eError = _SegmentListInsert (pArena, pSpanStart);
if (eError != PVRSRV_OK)
{
- goto fail_SegListInsert;
+ goto fail_SegListInsert;
}
eError = _SegmentListInsertAfter (pArena, pSpanStart, pBT);
if (eError != PVRSRV_OK)
{
- goto fail_SegListInsert;
- }
-
+ goto fail_SegListInsert;
+ }
+
_FreeListInsert (pArena, pBT);
eError = _SegmentListInsertAfter (pArena, pBT, pSpanEnd);
if (eError != PVRSRV_OK)
{
- goto fail_SegListInsert;
+ goto fail_SegListInsert;
}
#ifdef RA_STATS
{
uRoundedEnd -= pArena->uQuantum;
}
-
+
if (uRoundedStart < uRoundedEnd)
{
- pArena->pBackingStoreFree(pArena->pImportHandle, uRoundedStart, uRoundedEnd, (IMG_HANDLE)0);
+ pArena->pBackingStoreFree(pArena->pImportHandle, (IMG_SIZE_T)uRoundedStart, (IMG_SIZE_T)uRoundedEnd, (IMG_HANDLE)0);
}
}
if (aligned_base > pBT->base)
{
BT *pNeighbour;
-
- pNeighbour = _SegmentSplit (pArena, pBT, aligned_base-pBT->base);
+ pNeighbour = _SegmentSplit (pArena, pBT, (IMG_SIZE_T)(aligned_base - pBT->base));
if (pNeighbour==IMG_NULL)
{
PVR_DPF ((PVR_DBG_ERROR,"_AttemptAllocAligned: Front split failed"));
- _FreeListInsert (pArena, pBT);
+ _FreeListInsert (pArena, pBT);
return IMG_FALSE;
}
{
PVR_DPF ((PVR_DBG_ERROR,"_AttemptAllocAligned: Back split failed"));
- _FreeListInsert (pArena, pBT);
+ _FreeListInsert (pArena, pBT);
return IMG_FALSE;
}
*ppsMapping = pBT->psMapping;
*base = pBT->base;
-
+
return IMG_TRUE;
}
else
}
pBT = pBT->pNextFree;
}
-
+
}
uIndex++;
}
RA_ARENA *
RA_Create (IMG_CHAR *name,
- IMG_UINTPTR_T base,
- IMG_SIZE_T uSize,
+ IMG_UINTPTR_T base,
+ IMG_SIZE_T uSize,
BM_MAPPING *psMapping,
IMG_SIZE_T uQuantum,
IMG_BOOL (*imp_alloc)(IMG_VOID *, IMG_SIZE_T uSize, IMG_SIZE_T *pActualSize,
PVR_DPF ((PVR_DBG_MESSAGE,
"RA_Create: name='%s', base=0x%x, uSize=0x%x, alloc=0x%x, free=0x%x",
- name, base, uSize, imp_alloc, imp_free));
+ name, base, uSize, (IMG_UINTPTR_T)imp_alloc, (IMG_UINTPTR_T)imp_free));
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
}
pArena->name = name;
- pArena->pImportAlloc = (imp_alloc!=IMG_NULL) ? imp_alloc : _RequestAllocFail;
+ pArena->pImportAlloc = (imp_alloc!=IMG_NULL) ? imp_alloc : &_RequestAllocFail;
pArena->pImportFree = imp_free;
pArena->pBackingStoreFree = backingstore_free;
pArena->pImportHandle = pImportHandle;
pArena->sStatistics.uExportCount = 0;
#endif
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
if(strcmp(pArena->name,"") != 0)
{
-
-#ifndef PVR_PROC_USE_SEQ_FILE
- IMG_INT ret;
- IMG_INT (*pfnCreateProcEntry)(const IMG_CHAR *, read_proc_t, write_proc_t, IMG_VOID *);
-
- pArena->bInitProcEntry = !PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL);
-
-
- pfnCreateProcEntry = pArena->bInitProcEntry ? CreateProcEntry : CreatePerProcessProcEntry;
-
- ret = snprintf(pArena->szProcInfoName, sizeof(pArena->szProcInfoName), "ra_info_%s", pArena->name);
- if (ret > 0 && ret < sizeof(pArena->szProcInfoName))
- {
- (IMG_VOID) pfnCreateProcEntry(ReplaceSpaces(pArena->szProcInfoName), RA_DumpInfo, 0, pArena);
- }
- else
- {
- pArena->szProcInfoName[0] = 0;
- PVR_DPF((PVR_DBG_ERROR, "RA_Create: couldn't create ra_info proc entry for arena %s", pArena->name));
- }
-
- ret = snprintf(pArena->szProcSegsName, sizeof(pArena->szProcSegsName), "ra_segs_%s", pArena->name);
- if (ret > 0 && ret < sizeof(pArena->szProcSegsName))
- {
- (IMG_VOID) pfnCreateProcEntry(ReplaceSpaces(pArena->szProcSegsName), RA_DumpSegs, 0, pArena);
- }
- else
- {
- pArena->szProcSegsName[0] = 0;
- PVR_DPF((PVR_DBG_ERROR, "RA_Create: couldn't create ra_segs proc entry for arena %s", pArena->name));
- }
-#else
-
IMG_INT ret;
IMG_CHAR szProcInfoName[PROC_NAME_SIZE];
IMG_CHAR szProcSegsName[PROC_NAME_SIZE];
- struct proc_dir_entry* (*pfnCreateProcEntrySeq)(const IMG_CHAR *,
- IMG_VOID*,
- pvr_next_proc_seq_t,
+ struct proc_dir_entry* (*pfnCreateProcEntrySeq)(const IMG_CHAR *,
+ IMG_VOID*,
+ pvr_next_proc_seq_t,
pvr_show_proc_seq_t,
pvr_off2element_proc_seq_t,
pvr_startstop_proc_seq_t,
write_proc_t);
pArena->bInitProcEntry = !PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL);
-
+
pfnCreateProcEntrySeq = pArena->bInitProcEntry ? CreateProcEntrySeq : CreatePerProcessProcEntrySeq;
ret = snprintf(szProcInfoName, sizeof(szProcInfoName), "ra_info_%s", pArena->name);
if (ret > 0 && ret < sizeof(szProcInfoName))
{
- pArena->pProcInfo = pfnCreateProcEntrySeq(ReplaceSpaces(szProcInfoName), pArena, NULL,
+ pArena->pProcInfo = pfnCreateProcEntrySeq(ReplaceSpaces(szProcInfoName), pArena, NULL,
RA_ProcSeqShowInfo, RA_ProcSeqOff2ElementInfo, NULL, NULL);
}
else
pArena->pProcSegs = 0;
PVR_DPF((PVR_DBG_ERROR, "RA_Create: couldn't create ra_segs proc entry for arena %s", pArena->name));
}
-
-#endif
-
}
#endif
goto insert_fail;
}
pBT->psMapping = psMapping;
-
+
}
return pArena;
pArena->sStatistics.uSpanCount--;
#endif
}
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
{
-
-#ifdef PVR_PROC_USE_SEQ_FILE
IMG_VOID (*pfnRemoveProcEntrySeq)(struct proc_dir_entry*);
pfnRemoveProcEntrySeq = pArena->bInitProcEntry ? RemoveProcEntrySeq : RemovePerProcessProcEntrySeq;
{
pfnRemoveProcEntrySeq( pArena->pProcSegs );
}
-
-#else
- IMG_VOID (*pfnRemoveProcEntry)(const IMG_CHAR *);
-
- pfnRemoveProcEntry = pArena->bInitProcEntry ? RemoveProcEntry : RemovePerProcessProcEntry;
-
- if (pArena->szProcInfoName[0] != 0)
- {
- pfnRemoveProcEntry(pArena->szProcInfoName);
- }
-
- if (pArena->szProcSegsName[0] != 0)
- {
- pfnRemoveProcEntry(pArena->szProcSegsName);
- }
-
-#endif
}
#endif
HASH_Delete (pArena->pSegmentHash);
#if defined(VALIDATE_ARENA_TEST)
ValidateArena(pArena);
-#endif
+#endif
#ifdef USE_BM_FREESPACE_CHECK
CheckBMFreespace();
}
PVR_DPF ((PVR_DBG_MESSAGE,
- "RA_Alloc: arena='%s', size=0x%x(0x%x), alignment=0x%x, offset=0x%x",
+ "RA_Alloc: arena='%s', size=0x%x(0x%x), alignment=0x%x, offset=0x%x",
pArena->name, uSize, uRequestSize, uAlignment, uAlignmentOffset));
uImportSize = ((uImportSize + pArena->uQuantum - 1)/pArena->uQuantum)*pArena->uQuantum;
-
+
bResult =
pArena->pImportAlloc (pArena->pImportHandle, uImportSize, &uImportSize,
&psImportMapping, uFlags, &import_base);
pArena->pImportFree(pArena->pImportHandle, import_base,
psImportMapping);
PVR_DPF ((PVR_DBG_MESSAGE,
- "RA_Alloc: name='%s', size=0x%x failed!",
+ "RA_Alloc: name='%s', size=0x%x failed!",
pArena->name, uSize));
return IMG_FALSE;
#if defined(VALIDATE_ARENA_TEST)
ValidateArena(pArena);
-#endif
+#endif
return bResult;
}
(eNextSpan == IMPORTED_RESOURCE_SPAN_END)))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
(eNextSpan == IMPORTED_RESOURCE_SPAN_END)))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
(eNextSpan == IMPORTED_RESOURCE_SPAN_END))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
(eNextSpan == IMPORTED_RESOURCE_SPAN_FREE)))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
break;
default:
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
(eNextSpan == RESOURCE_SPAN_LIVE)))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
(eNextSpan == RESOURCE_SPAN_LIVE)))
{
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
break;
default:
- PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
+ PVR_DPF((PVR_DBG_ERROR, "ValidateArena ERROR: adjacent boundary tags %d (base=0x%x) and %d (base=0x%x) are incompatible (arena: %s)",
pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
PVR_DBG_BREAK;
PVR_DPF ((PVR_DBG_MESSAGE,
"RA_Free: name='%s', base=0x%x", pArena->name, base));
-
+
pBT = (BT *) HASH_Remove (pArena->pSegmentHash, base);
PVR_ASSERT (pBT != IMG_NULL);
{
if (pBT->type == btt_live)
{
- psSegDetails->uiSize = pBT->uSize;
+ psSegDetails->uiSize = pBT->uSize;
psSegDetails->sCpuPhyAddr.uiAddr = pBT->base;
psSegDetails->hSegment = (IMG_HANDLE)pBT->pNextSegment;
pBT = pBT->pNextSegment;
}
- psSegDetails->uiSize = 0;
+ psSegDetails->uiSize = 0;
psSegDetails->sCpuPhyAddr.uiAddr = 0;
- psSegDetails->hSegment = (IMG_HANDLE)-1;
+ psSegDetails->hSegment = (IMG_HANDLE)IMG_UNDEF;
return IMG_FALSE;
}
-
+
#ifdef USE_BM_FREESPACE_CHECK
RA_ARENA* pJFSavedArena = IMG_NULL;
#endif
-#if (defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)) || defined (RA_STATS)
+#if (defined(CONFIG_PROC_FS) && defined(DEBUG)) || defined (RA_STATS)
static IMG_CHAR *
_BTType (IMG_INT eType)
{
BT *pBT;
PVR_ASSERT (pArena != IMG_NULL);
PVR_DPF ((PVR_DBG_MESSAGE,"Arena '%s':", pArena->name));
- PVR_DPF ((PVR_DBG_MESSAGE," alloc=%08X free=%08X handle=%08X quantum=%d",
+ PVR_DPF ((PVR_DBG_MESSAGE," alloc=%08X free=%08X handle=%08X quantum=%d",
pArena->pImportAlloc, pArena->pImportFree, pArena->pImportHandle,
pArena->uQuantum));
PVR_DPF ((PVR_DBG_MESSAGE," segment Chain:"));
for (pBT=pArena->pHeadSegment; pBT!=IMG_NULL; pBT=pBT->pNextSegment)
{
- PVR_DPF ((PVR_DBG_MESSAGE,"\tbase=0x%x size=0x%x type=%s ref=%08X",
+ PVR_DPF ((PVR_DBG_MESSAGE,"\tbase=0x%x size=0x%x type=%s ref=%08X",
(IMG_UINT32) pBT->base, pBT->uSize, _BTType (pBT->type),
pBT->pRef));
}
#endif
-#if defined(CONFIG_PROC_FS) && defined(DEBUG_PVR)
-
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
-#ifdef PVR_PROC_USE_SEQ_FILE
-static void RA_ProcSeqShowInfo(struct seq_file *sfile, void* el)
+static void RA_ProcSeqShowInfo(struct seq_file *sfile, void* el)
{
PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)sfile->private;
RA_ARENA *pArena = (RA_ARENA *)handlers->data;
switch (off)
{
case 1:
- seq_printf(sfile, "quantum\t\t\t%lu\n", pArena->uQuantum);
+ seq_printf(sfile, "quantum\t\t\t%u\n", pArena->uQuantum);
break;
case 2:
seq_printf(sfile, "import_handle\t\t%08X\n", (IMG_UINT)pArena->pImportHandle);
break;
#ifdef RA_STATS
case 3:
- seq_printf(sfile,"span count\t\t%lu\n", pArena->sStatistics.uSpanCount);
+ seq_printf(sfile,"span count\t\t%u\n", pArena->sStatistics.uSpanCount);
break;
case 4:
- seq_printf(sfile, "live segment count\t%lu\n", pArena->sStatistics.uLiveSegmentCount);
+ seq_printf(sfile, "live segment count\t%u\n", pArena->sStatistics.uLiveSegmentCount);
break;
case 5:
- seq_printf(sfile, "free segment count\t%lu\n", pArena->sStatistics.uFreeSegmentCount);
+ seq_printf(sfile, "free segment count\t%u\n", pArena->sStatistics.uFreeSegmentCount);
break;
case 6:
- seq_printf(sfile, "free resource count\t%lu (0x%x)\n",
+ seq_printf(sfile, "free resource count\t%u (0x%x)\n",
pArena->sStatistics.uFreeResourceCount,
(IMG_UINT)pArena->sStatistics.uFreeResourceCount);
break;
case 7:
- seq_printf(sfile, "total allocs\t\t%lu\n", pArena->sStatistics.uCumulativeAllocs);
+ seq_printf(sfile, "total allocs\t\t%u\n", pArena->sStatistics.uCumulativeAllocs);
break;
case 8:
- seq_printf(sfile, "total frees\t\t%lu\n", pArena->sStatistics.uCumulativeFrees);
+ seq_printf(sfile, "total frees\t\t%u\n", pArena->sStatistics.uCumulativeFrees);
break;
case 9:
- seq_printf(sfile, "import count\t\t%lu\n", pArena->sStatistics.uImportCount);
+ seq_printf(sfile, "import count\t\t%u\n", pArena->sStatistics.uImportCount);
break;
case 10:
- seq_printf(sfile, "export count\t\t%lu\n", pArena->sStatistics.uExportCount);
+ seq_printf(sfile, "export count\t\t%u\n", pArena->sStatistics.uExportCount);
break;
#endif
}
static void* RA_ProcSeqOff2ElementInfo(struct seq_file * sfile, loff_t off)
{
#ifdef RA_STATS
- if(off <= 9)
+ if(off <= 9)
#else
- if(off <= 1)
+ if(off <= 1)
#endif
return (void*)(IMG_INT)(off+1);
return 0;
if (pBT)
{
- seq_printf(sfile, "%08x %8x %4s %08x\n",
+ seq_printf(sfile, "%08x %8x %4s %08x\n",
(IMG_UINT)pBT->base, (IMG_UINT)pBT->uSize, _BTType (pBT->type),
(IMG_UINT)pBT->psMapping);
}
}
-static void* RA_ProcSeqOff2ElementRegs(struct seq_file * sfile, loff_t off)
+static void* RA_ProcSeqOff2ElementRegs(struct seq_file * sfile, loff_t off)
{
PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)sfile->private;
RA_ARENA *pArena = (RA_ARENA *)handlers->data;
BT *pBT = 0;
- if(off == 0)
+ if(off == 0)
return PVR_PROC_SEQ_START_TOKEN;
for (pBT=pArena->pHeadSegment; --off && pBT; pBT=pBT->pNextSegment);
return (void*)pBT;
}
-
-
-#else
-static IMG_INT
-RA_DumpSegs(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
-{
- BT *pBT = 0;
- IMG_INT len = 0;
- RA_ARENA *pArena = (RA_ARENA *)data;
-
- if (count < 80)
- {
- *start = (IMG_CHAR *)0;
- return (0);
- }
- *eof = 0;
- *start = (IMG_CHAR *)1;
- if (off == 0)
- {
- return printAppend(page, count, 0, "Arena \"%s\"\nBase Size Type Ref\n", pArena->name);
- }
- for (pBT=pArena->pHeadSegment; --off && pBT; pBT=pBT->pNextSegment)
- ;
- if (pBT)
- {
- len = printAppend(page, count, 0, "%08x %8x %4s %08x\n",
- (IMG_UINT)pBT->base, (IMG_UINT)pBT->uSize, _BTType (pBT->type),
- (IMG_UINT)pBT->psMapping);
- }
- else
- {
- *eof = 1;
- }
- return (len);
-}
-
-static IMG_INT
-RA_DumpInfo(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
-{
- IMG_INT len = 0;
- RA_ARENA *pArena = (RA_ARENA *)data;
-
- if (count < 80)
- {
- *start = (IMG_CHAR *)0;
- return (0);
- }
- *eof = 0;
- switch (off)
- {
- case 0:
- len = printAppend(page, count, 0, "quantum\t\t\t%lu\n", pArena->uQuantum);
- break;
- case 1:
- len = printAppend(page, count, 0, "import_handle\t\t%08X\n", (IMG_UINT)pArena->pImportHandle);
- break;
-#ifdef RA_STATS
- case 2:
- len = printAppend(page, count, 0, "span count\t\t%lu\n", pArena->sStatistics.uSpanCount);
- break;
- case 3:
- len = printAppend(page, count, 0, "live segment count\t%lu\n", pArena->sStatistics.uLiveSegmentCount);
- break;
- case 4:
- len = printAppend(page, count, 0, "free segment count\t%lu\n", pArena->sStatistics.uFreeSegmentCount);
- break;
- case 5:
- len = printAppend(page, count, 0, "free resource count\t%lu (0x%x)\n",
- pArena->sStatistics.uFreeResourceCount,
- (IMG_UINT)pArena->sStatistics.uFreeResourceCount);
- break;
- case 6:
- len = printAppend(page, count, 0, "total allocs\t\t%lu\n", pArena->sStatistics.uCumulativeAllocs);
- break;
- case 7:
- len = printAppend(page, count, 0, "total frees\t\t%lu\n", pArena->sStatistics.uCumulativeFrees);
- break;
- case 8:
- len = printAppend(page, count, 0, "import count\t\t%lu\n", pArena->sStatistics.uImportCount);
- break;
- case 9:
- len = printAppend(page, count, 0, "export count\t\t%lu\n", pArena->sStatistics.uExportCount);
- break;
-#endif
-
- default:
- *eof = 1;
- }
- *start = (IMG_CHAR *)1;
- return (len);
-}
-#endif
#endif
#ifdef RA_STATS
PVRSRV_ERROR RA_GetStats(RA_ARENA *pArena,
- IMG_CHAR **ppszStr,
+ IMG_CHAR **ppszStr,
IMG_UINT32 *pui32StrLen)
{
IMG_CHAR *pszStr = *ppszStr;
IMG_UINT32 ui32StrLen = *pui32StrLen;
IMG_INT32 i32Count;
BT *pBT;
-
+
CHECK_SPACE(ui32StrLen);
i32Count = OSSNPrintf(pszStr, 100, "\nArena '%s':\n", pArena->name);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
-
-
+
+
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, " allocCB=%08X freeCB=%08X handle=%08X quantum=%d\n",
- pArena->pImportAlloc,
- pArena->pImportFree,
+ i32Count = OSSNPrintf(pszStr, 100, " allocCB=%p freeCB=%p handle=%p quantum=%d\n",
+ pArena->pImportAlloc,
+ pArena->pImportFree,
pArena->pImportHandle,
pArena->uQuantum);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "span count\t\t%lu\n", pArena->sStatistics.uSpanCount);
+ i32Count = OSSNPrintf(pszStr, 100, "span count\t\t%u\n", pArena->sStatistics.uSpanCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "live segment count\t%lu\n", pArena->sStatistics.uLiveSegmentCount);
+ i32Count = OSSNPrintf(pszStr, 100, "live segment count\t%u\n", pArena->sStatistics.uLiveSegmentCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "free segment count\t%lu\n", pArena->sStatistics.uFreeSegmentCount);
+ i32Count = OSSNPrintf(pszStr, 100, "free segment count\t%u\n", pArena->sStatistics.uFreeSegmentCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "free resource count\t%lu (0x%x)\n",
+ i32Count = OSSNPrintf(pszStr, 100, "free resource count\t%u (0x%x)\n",
pArena->sStatistics.uFreeResourceCount,
(IMG_UINT)pArena->sStatistics.uFreeResourceCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "total allocs\t\t%lu\n", pArena->sStatistics.uCumulativeAllocs);
+ i32Count = OSSNPrintf(pszStr, 100, "total allocs\t\t%u\n", pArena->sStatistics.uCumulativeAllocs);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "total frees\t\t%lu\n", pArena->sStatistics.uCumulativeFrees);
+ i32Count = OSSNPrintf(pszStr, 100, "total frees\t\t%u\n", pArena->sStatistics.uCumulativeFrees);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "import count\t\t%lu\n", pArena->sStatistics.uImportCount);
+ i32Count = OSSNPrintf(pszStr, 100, "import count\t\t%u\n", pArena->sStatistics.uImportCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "export count\t\t%lu\n", pArena->sStatistics.uExportCount);
+ i32Count = OSSNPrintf(pszStr, 100, "export count\t\t%u\n", pArena->sStatistics.uExportCount);
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
CHECK_SPACE(ui32StrLen);
i32Count = OSSNPrintf(pszStr, 100, " segment Chain:\n");
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
-
+
if (pArena->pHeadSegment != IMG_NULL &&
pArena->pHeadSegment->pPrevSegment != IMG_NULL)
{
i32Count = OSSNPrintf(pszStr, 100, " error: head boundary tag has invalid pPrevSegment\n");
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
}
-
+
if (pArena->pTailSegment != IMG_NULL &&
pArena->pTailSegment->pNextSegment != IMG_NULL)
{
i32Count = OSSNPrintf(pszStr, 100, " error: tail boundary tag has invalid pNextSegment\n");
UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
}
-
+
for (pBT=pArena->pHeadSegment; pBT!=IMG_NULL; pBT=pBT->pNextSegment)
{
CHECK_SPACE(ui32StrLen);
- i32Count = OSSNPrintf(pszStr, 100, "\tbase=0x%x size=0x%x type=%s ref=%08X\n",
+ i32Count = OSSNPrintf(pszStr, 100, "\tbase=0x%x size=0x%x type=%s ref=%p\n",
(IMG_UINT32) pBT->base,
pBT->uSize,
_BTType(pBT->type),
*ppszStr = pszStr;
*pui32StrLen = ui32StrLen;
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR RA_GetStatsFreeMem(RA_ARENA *pArena,
+ IMG_CHAR **ppszStr,
+ IMG_UINT32 *pui32StrLen)
+{
+ IMG_CHAR *pszStr = *ppszStr;
+ IMG_UINT32 ui32StrLen = *pui32StrLen;
+ IMG_INT32 i32Count;
+ CHECK_SPACE(ui32StrLen);
+ i32Count = OSSNPrintf(pszStr, 100, "Bytes free: Arena %-30s: %u (0x%x)\n", pArena->name,
+ pArena->sStatistics.uFreeResourceCount,
+ pArena->sStatistics.uFreeResourceCount);
+ UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+ *ppszStr = pszStr;
+ *pui32StrLen = ui32StrLen;
return PVRSRV_OK;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
static DEFINE_SEMAPHORE(lock);
#else
-static DECLARE_MUTEX(lock);
+ static DECLARE_MUTEX(lock);
#endif
#define ACQUIRE_SYNC_OBJ do { \
typedef struct _RESMAN_ITEM_
{
-#ifdef DEBUG_PVR
+#ifdef DEBUG
IMG_UINT32 ui32Signature;
#endif
struct _RESMAN_ITEM_ **ppsThis;
typedef struct _RESMAN_CONTEXT_
{
-#ifdef DEBUG_PVR
+#ifdef DEBUG
IMG_UINT32 ui32Signature;
#endif
struct _RESMAN_CONTEXT_ **ppsThis;
PRESMAN_LIST gpsResList = IMG_NULL;
-#include "lists.h"
+#include "lists.h"
static IMPLEMENT_LIST_ANY_VA(RESMAN_ITEM)
static IMPLEMENT_LIST_ANY_VA_2(RESMAN_ITEM, IMG_BOOL, IMG_FALSE)
static IMPLEMENT_LIST_INSERT(RESMAN_ITEM)
static IMPLEMENT_LIST_REMOVE(RESMAN_ITEM)
+static IMPLEMENT_LIST_REVERSE(RESMAN_ITEM)
static IMPLEMENT_LIST_REMOVE(RESMAN_CONTEXT)
static IMPLEMENT_LIST_INSERT(RESMAN_CONTEXT)
static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, IMG_BOOL bExecuteCallback);
static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psContext,
- IMG_UINT32 ui32SearchCriteria,
- IMG_UINT32 ui32ResType,
- IMG_PVOID pvParam,
- IMG_UINT32 ui32Param,
+ IMG_UINT32 ui32SearchCriteria,
+ IMG_UINT32 ui32ResType,
+ IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param,
IMG_BOOL bExecuteCallback);
-#ifdef DEBUG_PVR
+#ifdef DEBUG
static IMG_VOID ValidateResList(PRESMAN_LIST psResList);
#define VALIDATERESLIST() ValidateResList(gpsResList)
#else
PVRSRV_ERROR ResManInit(IMG_VOID)
{
if (gpsResList == IMG_NULL)
- {
+ {
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(*gpsResList),
gpsResList->psContextList = IMG_NULL;
-
+
VALIDATERESLIST();
}
-
+
return PVRSRV_OK;
}
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVResManConnect: ERROR allocating new RESMAN context struct"));
-
+
VALIDATERESLIST();
return eError;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
psResManContext->ui32Signature = RESMAN_SIGNATURE;
#endif
psResManContext->psResItemList = IMG_NULL;
RELEASE_SYNC_OBJ;
*phResManContext = psResManContext;
-
+
return PVRSRV_OK;
}
IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext,
IMG_BOOL bKernelContext)
-{
+{
ACQUIRE_SYNC_OBJ;
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_EVENT_OBJECT, 0, 0, IMG_TRUE);
- FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_MODIFY_SYNC_OPS, 0, 0, IMG_TRUE);
+ List_RESMAN_ITEM_Reverse(&psResManContext->psResItemList);
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_MODIFY_SYNC_OPS, 0, 0, IMG_TRUE);
+ List_RESMAN_ITEM_Reverse(&psResManContext->psResItemList);
+
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_RENDER_CONTEXT, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_TRANSFER_CONTEXT, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_2D_CONTEXT, 0, 0, IMG_TRUE);
- FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_TRANSFER_CONTEXT, 0, 0, IMG_TRUE);
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_TRANSFER_CONTEXT, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_PB_DESC_CREATE_LOCK, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_PB_DESC, 0, 0, IMG_TRUE);
+
-
- FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN, 0, 0, IMG_TRUE);
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN_REF, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_DEVICE, 0, 0, IMG_TRUE);
-
+
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_BUFFERCLASS_DEVICE, 0, 0, IMG_TRUE);
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SYNC_INFO, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICECLASSMEM_MAPPING, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_WRAP, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_MAPPING, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_CONTEXT, 0, 0, IMG_TRUE);
+ FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_MEM_INFO, 0, 0, IMG_TRUE);
}
-
+
PVR_ASSERT(psResManContext->psResItemList == IMG_NULL);
PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT psResManContext,
- IMG_UINT32 ui32ResType,
- IMG_PVOID pvParam,
- IMG_UINT32 ui32Param,
+ IMG_UINT32 ui32ResType,
+ IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param,
RESMAN_FREE_FN pfnFreeResource)
{
PRESMAN_ITEM psNewResItem;
PVR_DPF((PVR_DBG_MESSAGE, "ResManRegisterRes: register resource "
"Context 0x%x, ResType 0x%x, pvParam 0x%x, ui32Param 0x%x, "
"FreeFunc %08X",
- psResManContext, ui32ResType, (IMG_UINT32)pvParam,
- ui32Param, pfnFreeResource));
+ (IMG_UINTPTR_T)psResManContext,
+ ui32ResType,
+ (IMG_UINTPTR_T)pvParam,
+ ui32Param,
+ (IMG_UINTPTR_T)pfnFreeResource));
if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
psNewResItem->ui32Signature = RESMAN_SIGNATURE;
#endif
psNewResItem->ui32ResType = ui32ResType;
psNewResItem->ui32Param = ui32Param;
psNewResItem->pfnFreeResource = pfnFreeResource;
psNewResItem->ui32Flags = 0;
-
+
List_RESMAN_ITEM_Insert(&psResManContext->psResItemList, psNewResItem);
return PVRSRV_OK;
}
- PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: freeing resource at %08X", psResItem));
+ PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: freeing resource at %08X",
+ (IMG_UINTPTR_T)psResItem));
ACQUIRE_SYNC_OBJ;
PVRSRV_ERROR ResManFreeResByCriteria(PRESMAN_CONTEXT psResManContext,
- IMG_UINT32 ui32SearchCriteria,
- IMG_UINT32 ui32ResType,
- IMG_PVOID pvParam,
+ IMG_UINT32 ui32SearchCriteria,
+ IMG_UINT32 ui32ResType,
+ IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
{
PVRSRV_ERROR eError;
PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByCriteria: "
"Context 0x%x, Criteria 0x%x, Type 0x%x, Addr 0x%x, Param 0x%x",
- psResManContext, ui32SearchCriteria, ui32ResType,
- (IMG_UINT32)pvParam, ui32Param));
+ (IMG_UINTPTR_T)psResManContext, ui32SearchCriteria, ui32ResType,
+ (IMG_UINTPTR_T)pvParam, ui32Param));
eError = FreeResourceByCriteria(psResManContext, ui32SearchCriteria,
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
PVR_ASSERT(psResItem->ui32Signature == RESMAN_SIGNATURE);
#endif
List_RESMAN_ITEM_Insert(&psNewResManContext->psResItemList, psResItem);
-
+
}
else
{
return eError;
}
-IMG_BOOL ResManFindResourceByPtr_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
+static IMG_BOOL ResManFindResourceByPtr_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
{
RESMAN_ITEM *psItem;
-
+
psItem = va_arg(va, RESMAN_ITEM*);
-
+
return (IMG_BOOL)(psCurItem == psItem);
}
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
#endif
PVR_DPF((PVR_DBG_MESSAGE,
"FindResourceByPtr: psItem=%08X, psItem->psNext=%08X",
- psItem, psItem->psNext));
+ (IMG_UINTPTR_T)psItem, (IMG_UINTPTR_T)psItem->psNext));
PVR_DPF((PVR_DBG_MESSAGE,
"FindResourceByPtr: Resource Ctx 0x%x, Type 0x%x, Addr 0x%x, "
"Param 0x%x, FnCall %08X, Flags 0x%x",
- psResManContext,
- psItem->ui32ResType, (IMG_UINT32)psItem->pvParam, psItem->ui32Param,
- psItem->pfnFreeResource, psItem->ui32Flags));
+ (IMG_UINTPTR_T)psResManContext,
+ psItem->ui32ResType,
+ (IMG_UINTPTR_T)psItem->pvParam,
+ psItem->ui32Param,
+ (IMG_UINTPTR_T)psItem->pfnFreeResource,
+ psItem->ui32Flags));
if(List_RESMAN_ITEM_IMG_BOOL_Any_va(psResManContext->psResItemList,
- ResManFindResourceByPtr_AnyVaCb,
+ &ResManFindResourceByPtr_AnyVaCb,
psItem))
{
eResult = PVRSRV_OK;
static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem,
IMG_BOOL bExecuteCallback)
{
- PVRSRV_ERROR eError = PVRSRV_OK;
+ PVRSRV_ERROR eError;
PVR_ASSERT(psItem != IMG_NULL);
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
#endif
PVR_DPF((PVR_DBG_MESSAGE,
"FreeResourceByPtr: psItem=%08X, psItem->psNext=%08X",
- psItem, psItem->psNext));
+ (IMG_UINTPTR_T)psItem, (IMG_UINTPTR_T)psItem->psNext));
PVR_DPF((PVR_DBG_MESSAGE,
"FreeResourceByPtr: Type 0x%x, Addr 0x%x, "
"Param 0x%x, FnCall %08X, Flags 0x%x",
- psItem->ui32ResType, (IMG_UINT32)psItem->pvParam, psItem->ui32Param,
- psItem->pfnFreeResource, psItem->ui32Flags));
+ psItem->ui32ResType,
+ (IMG_UINTPTR_T)psItem->pvParam, psItem->ui32Param,
+ (IMG_UINTPTR_T)psItem->pfnFreeResource, psItem->ui32Flags));
List_RESMAN_ITEM_Remove(psItem);
-
+
RELEASE_SYNC_OBJ;
ACQUIRE_SYNC_OBJ;
- if(OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_ITEM), psItem, IMG_NULL) != PVRSRV_OK)
+ eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_ITEM), psItem, IMG_NULL);
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: ERROR freeing resource list item memory"));
- eError = PVRSRV_ERROR_GENERIC;
}
return(eError);
}
-IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
+static IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
{
IMG_UINT32 ui32SearchCriteria;
IMG_UINT32 ui32ResType;
pvParam = va_arg(va, IMG_PVOID);
ui32Param = va_arg(va, IMG_UINT32);
-
+
if(
(((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) == 0UL) ||
}
static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psResManContext,
- IMG_UINT32 ui32SearchCriteria,
- IMG_UINT32 ui32ResType,
- IMG_PVOID pvParam,
- IMG_UINT32 ui32Param,
+ IMG_UINT32 ui32SearchCriteria,
+ IMG_UINT32 ui32ResType,
+ IMG_PVOID pvParam,
+ IMG_UINT32 ui32Param,
IMG_BOOL bExecuteCallback)
{
PRESMAN_ITEM psCurItem;
while((psCurItem = (PRESMAN_ITEM)
List_RESMAN_ITEM_Any_va(psResManContext->psResItemList,
- FreeResourceByCriteria_AnyVaCb,
+ &FreeResourceByCriteria_AnyVaCb,
ui32SearchCriteria,
ui32ResType,
pvParam,
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
static IMG_VOID ValidateResList(PRESMAN_LIST psResList)
{
PRESMAN_ITEM psCurItem, *ppsThisItem;
{
PVR_DPF((PVR_DBG_WARNING,
"psCC=%08X psCC->ppsThis=%08X psCC->psNext=%08X ppsTC=%08X",
- psCurContext, psCurContext->ppsThis,
- psCurContext->psNext, ppsThisContext));
+ (IMG_UINTPTR_T)psCurContext,
+ (IMG_UINTPTR_T)psCurContext->ppsThis,
+ (IMG_UINTPTR_T)psCurContext->psNext,
+ (IMG_UINTPTR_T)ppsThisContext));
PVR_ASSERT(psCurContext->ppsThis == ppsThisContext);
}
-
+
psCurItem = psCurContext->psResItemList;
ppsThisItem = &psCurContext->psResItemList;
{
PVR_DPF((PVR_DBG_WARNING,
"psCurItem=%08X psCurItem->ppsThis=%08X psCurItem->psNext=%08X ppsThisItem=%08X",
- psCurItem, psCurItem->ppsThis, psCurItem->psNext, ppsThisItem));
+ (IMG_UINTPTR_T)psCurItem,
+ (IMG_UINTPTR_T)psCurItem->ppsThis,
+ (IMG_UINTPTR_T)psCurItem->psNext,
+ (IMG_UINTPTR_T)ppsThisItem));
PVR_ASSERT(psCurItem->ppsThis == ppsThisItem);
}
#include "sgxinfokm.h"
#include "mmu.h"
#include "sgxconfig.h"
+#include "sgx_bridge_km.h"
#define UINT32_MAX_VALUE 0xFFFFFFFFUL
#if defined(PDUMP)
IMG_UINT32 ui32PDumpMMUContextID;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ IMG_BOOL bPDumpActive;
+#endif
#endif
struct _MMU_CONTEXT_ *psNext;
RA_ARENA *psVMArena;
DEV_ARENA_DESCRIPTOR *psDevArena;
+#if defined(PDUMP)
+ PDUMP_MMU_ATTRIB sMMUAttrib;
+#endif
};
for(i = 0; i < 1024; i += 8)
{
PVR_DPF((PVR_DBG_WARNING,
- "%.8lx %.8lx %.8lx %.8lx %.8lx %.8lx %.8lx %.8lx\n",
+ "%08X %08X %08X %08X %08X %08X %08X %08X\n",
p[i + 0], p[i + 1], p[i + 2], p[i + 3],
p[i + 4], p[i + 5], p[i + 6], p[i + 7]));
}
if(psPTInfoList->ui32ValidPTECount != ui32Count)
{
- PVR_DPF((PVR_DBG_WARNING, "ui32ValidPTECount: %lu ui32Count: %lu\n",
+ PVR_DPF((PVR_DBG_WARNING, "ui32ValidPTECount: %u ui32Count: %u\n",
psPTInfoList->ui32ValidPTECount, ui32Count));
DumpPT(psPTInfoList);
BUG();
}
#endif
+
+IMG_BOOL MMU_IsHeapShared(MMU_HEAP* pMMUHeap)
+{
+ switch(pMMUHeap->psDevArena->DevMemHeapType)
+ {
+ case DEVICE_MEMORY_HEAP_SHARED :
+ case DEVICE_MEMORY_HEAP_SHARED_EXPORTED :
+ return IMG_TRUE;
+ case DEVICE_MEMORY_HEAP_PERCONTEXT :
+ case DEVICE_MEMORY_HEAP_KERNEL :
+ return IMG_FALSE;
+ default:
+ {
+ PVR_DPF((PVR_DBG_ERROR, "MMU_IsHeapShared: ERROR invalid heap type"));
+ return IMG_FALSE;
+ }
+ }
+}
+
#ifdef SUPPORT_SGX_MMU_BYPASS
IMG_VOID
EnableHostAccess (MMU_CONTEXT *psMMUContext)
EUR_CR_BIF_CTRL,
ui32RegVal | EUR_CR_BIF_CTRL_MMU_BYPASS_HOST_MASK);
- PDUMPREG(EUR_CR_BIF_CTRL, EUR_CR_BIF_CTRL_MMU_BYPASS_HOST_MASK);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, EUR_CR_BIF_CTRL_MMU_BYPASS_HOST_MASK);
}
IMG_VOID
EUR_CR_BIF_CTRL,
ui32RegVal & ~EUR_CR_BIF_CTRL_MMU_BYPASS_HOST_MASK);
- PDUMPREG(EUR_CR_BIF_CTRL, 0);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, 0);
}
#endif
-IMG_VOID MMU_InvalidateSystemLevelCache(PVRSRV_SGXDEV_INFO *psDevInfo)
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+static IMG_VOID MMU_InvalidateSystemLevelCache(PVRSRV_SGXDEV_INFO *psDevInfo)
{
#if defined(SGX_FEATURE_MP)
- psDevInfo->ui32CacheControl |= SGX_BIF_INVALIDATE_SLCACHE;
+ psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_SL;
#else
PVR_UNREFERENCED_PARAMETER(psDevInfo);
#endif
}
-
+#endif
IMG_VOID MMU_InvalidateDirectoryCache(PVRSRV_SGXDEV_INFO *psDevInfo)
{
- psDevInfo->ui32CacheControl |= SGX_BIF_INVALIDATE_PDCACHE;
+ psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_PD;
#if defined(SGX_FEATURE_SYSTEM_CACHE)
MMU_InvalidateSystemLevelCache(psDevInfo);
#endif
}
-IMG_VOID MMU_InvalidatePageTableCache(PVRSRV_SGXDEV_INFO *psDevInfo)
+static IMG_VOID MMU_InvalidatePageTableCache(PVRSRV_SGXDEV_INFO *psDevInfo)
{
- psDevInfo->ui32CacheControl |= SGX_BIF_INVALIDATE_PTCACHE;
+ psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_PT;
#if defined(SGX_FEATURE_SYSTEM_CACHE)
MMU_InvalidateSystemLevelCache(psDevInfo);
#endif
if(psPTInfoList->PTPageCpuVAddr)
{
- sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->PTPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->hPTPageOSMemHandle,
+ psPTInfoList->PTPageCpuVAddr);
}
else
{
for(i=0; i<pMMUHeap->ui32PTECount; i++)
{
- pui32Tmp[i] = (pMMUHeap->psMMUContext->psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+ pui32Tmp[i] = (pMMUHeap->psMMUContext->psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
| SGX_MMU_PTE_VALID;
}
}
OSMemSet(psPTInfoList->PTPageCpuVAddr, 0, pMMUHeap->ui32PTSize);
#endif
+#if defined(PDUMP)
+ {
+ IMG_UINT32 ui32Flags = 0;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ ui32Flags |= ( MMU_IsHeapShared(pMMUHeap) ) ? PDUMP_FLAGS_PERSISTENT : 0;
+#endif
+
+ PDUMPMALLOCPAGETABLE(&pMMUHeap->psMMUContext->psDeviceNode->sDevId, psPTInfoList->hPTPageOSMemHandle, 0, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, ui32Flags, PDUMP_PT_UNIQUETAG);
+
+ PDUMPMEMPTENTRIES(&pMMUHeap->sMMUAttrib, psPTInfoList->hPTPageOSMemHandle, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, ui32Flags, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ }
+#endif
- PDUMPMALLOCPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, PDUMP_PT_UNIQUETAG);
-
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
-
*psDevPAddr = sDevPAddr;
IMG_CPU_PHYADDR sCpuPAddr;
- sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->PTPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->hPTPageOSMemHandle,
+ psPTInfoList->PTPageCpuVAddr);
sSysPAddr = SysCpuPAddrToSysPAddr (sCpuPAddr);
PVR_ASSERT(ppsPTInfoList[ui32PTIndex] == IMG_NULL || ppsPTInfoList[ui32PTIndex]->ui32ValidPTECount == 0);
}
-
- PDUMPCOMMENT("Free page table (page count == %08X)", pMMUHeap->ui32PageTableCount);
- if(ppsPTInfoList[ui32PTIndex] && ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr)
+#if defined(PDUMP)
{
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr, pMMUHeap->ui32PTSize, PDUMP_PT_UNIQUETAG);
+ IMG_UINT32 ui32Flags = 0;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ ui32Flags |= ( MMU_IsHeapShared(pMMUHeap) ) ? PDUMP_FLAGS_PERSISTENT : 0;
+#endif
+
+ PDUMPCOMMENT("Free page table (page count == %08X)", pMMUHeap->ui32PageTableCount);
+ if(ppsPTInfoList[ui32PTIndex] && ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr)
+ {
+ PDUMPFREEPAGETABLE(&pMMUHeap->psMMUContext->psDeviceNode->sDevId, ppsPTInfoList[ui32PTIndex]->hPTPageOSMemHandle, ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr, pMMUHeap->ui32PTSize, ui32Flags, PDUMP_PT_UNIQUETAG);
+ }
}
+#endif
switch(pMMUHeap->psDevArena->DevMemHeapType)
{
pui32PDEntry[ui32PTIndex] = 0;
}
#endif
-
+ #if defined(PDUMP)
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
-
+ #if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if(psMMUContext->bPDumpActive)
+ #endif
+ {
+ PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ }
+ #endif
psMMUContext = psMMUContext->psNext;
}
#endif
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, pMMUHeap->psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
break;
}
default:
_DeferredFreePageTables (MMU_HEAP *pMMUHeap)
{
IMG_UINT32 i;
-
+#if defined(PDUMP)
+ PDUMPCOMMENT("Free PTs (MMU Context ID == %u, PDBaseIndex == %u, PT count == 0x%x)",
+ pMMUHeap->psMMUContext->ui32PDumpMMUContextID,
+ pMMUHeap->ui32PDBaseIndex,
+ pMMUHeap->ui32PageTableCount);
+#endif
for(i=0; i<pMMUHeap->ui32PageTableCount; i++)
{
_DeferredFreePageTable(pMMUHeap, i, IMG_TRUE);
ppsPTInfoList = &pMMUHeap->psMMUContext->apsPTInfoList[ui32PDIndex];
+#if defined(PDUMP)
+ PDUMPCOMMENT("Alloc PTs (MMU Context ID == %u, PDBaseIndex == %u, Size == 0x%x)",
+ pMMUHeap->psMMUContext->ui32PDumpMMUContextID,
+ pMMUHeap->ui32PDBaseIndex,
+ ui32Size);
PDUMPCOMMENT("Alloc page table (page count == %08X)", ui32PageTableCount);
PDUMPCOMMENT("Page directory mods (page count == %08X)", ui32PageTableCount);
-
+#endif
for(i=0; i<ui32PageTableCount; i++)
{
| pMMUHeap->ui32PDEPageSizeCtrl
| SGX_MMU_PDE_VALID;
+ #if defined(PDUMP)
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ #if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if(psMMUContext->bPDumpActive)
+ #endif
+ {
+
+ PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ }
+ #endif
psMMUContext = psMMUContext->psNext;
| SGX_MMU_PDE_VALID;
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, pMMUHeap->psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
break;
}
default:
}
+#if defined(PDUMP)
+IMG_UINT32 MMU_GetPDumpContextID(IMG_HANDLE hDevMemContext)
+{
+ BM_CONTEXT *pBMContext = hDevMemContext;
+ PVR_ASSERT(pBMContext);
+ return pBMContext->psMMUContext->ui32PDumpMMUContextID;
+}
+
+static IMG_VOID MMU_SetPDumpAttribs(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ PVRSRV_DEVICE_NODE *psDeviceNode,
+ IMG_UINT32 ui32DataPageMask,
+ IMG_UINT32 ui32PTSize)
+{
+
+ psMMUAttrib->sDevId = psDeviceNode->sDevId;
+
+ psMMUAttrib->pszPDRegRegion = IMG_NULL;
+ psMMUAttrib->ui32DataPageMask = ui32DataPageMask;
+
+ psMMUAttrib->ui32PTEValid = SGX_MMU_PTE_VALID;
+ psMMUAttrib->ui32PTSize = ui32PTSize;
+ psMMUAttrib->ui32PTEAlignShift = SGX_MMU_PTE_ADDR_ALIGNSHIFT;
+
+ psMMUAttrib->ui32PDEMask = SGX_MMU_PDE_ADDR_MASK;
+ psMMUAttrib->ui32PDEAlignShift = SGX_MMU_PDE_ADDR_ALIGNSHIFT;
+}
+#endif
+
PVRSRV_ERROR
MMU_Initialise (PVRSRV_DEVICE_NODE *psDeviceNode, MMU_CONTEXT **ppsMMUContext, IMG_DEV_PHYADDR *psPDDevPAddr)
{
IMG_HANDLE hPDOSMemHandle;
SYS_DATA *psSysData;
PVRSRV_SGXDEV_INFO *psDevInfo;
-
+#if defined(PDUMP)
+ PDUMP_MMU_ATTRIB sMMUAttrib;
+#endif
PVR_DPF ((PVR_DBG_MESSAGE, "MMU_Initialise"));
SysAcquireData(&psSysData);
+#if defined(PDUMP)
+
+
+ MMU_SetPDumpAttribs(&sMMUAttrib, psDeviceNode,
+ SGX_MMU_PAGE_MASK,
+ SGX_MMU_PT_SIZE * sizeof(IMG_UINT32));
+#endif
OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof (MMU_CONTEXT),
if (psMMUContext == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocMem failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
}
OSMemSet (psMMUContext, 0, sizeof(MMU_CONTEXT));
&hPDOSMemHandle) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
}
if(pvPDCpuVAddr)
{
- sCpuPAddr = OSMapLinToCPUPhys(pvPDCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(hPDOSMemHandle,
+ pvPDCpuVAddr);
}
else
{
&psDevInfo->hDummyPTPageOSMemHandle) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
}
if(psDevInfo->pvDummyPTPageCpuVAddr)
{
- sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->pvDummyPTPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+ psDevInfo->pvDummyPTPageCpuVAddr);
}
else
{
&psDevInfo->hDummyDataPageOSMemHandle) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
}
if(psDevInfo->pvDummyDataPageCpuVAddr)
{
- sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->pvDummyDataPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+ psDevInfo->pvDummyDataPageCpuVAddr);
}
else
{
&(sSysPAddr.uiAddr))!= IMG_TRUE)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
}
if(!pvPDCpuVAddr)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
}
#if PAGE_TEST
&(sSysPAddr.uiAddr))!= IMG_TRUE)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
}
if(!psDevInfo->pvDummyPTPageCpuVAddr)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
}
&(sSysPAddr.uiAddr))!= IMG_TRUE)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
}
if(!psDevInfo->pvDummyDataPageCpuVAddr)
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
}
}
#endif
}
+#if defined(PDUMP)
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
- PDUMPCOMMENT("Alloc page directory");
+ {
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc == IMG_NULL)
+ {
+
+ psMMUContext->bPDumpActive = IMG_TRUE;
+ }
+ else
+ {
+ psMMUContext->bPDumpActive = psPerProc->bPDumpActive;
+ }
+ }
+#endif
+
+#if IMG_ADDRSPACE_PHYSADDR_BITS == 32
+ PDUMPCOMMENT("Alloc page directory for new MMU context (PDDevPAddr == 0x%08x)",
+ sPDDevPAddr.uiAddr);
+#else
+ PDUMPCOMMENT("Alloc page directory for new MMU context, 64-bit arch detected (PDDevPAddr == 0x%08x%08x)",
+ sPDDevPAddr.uiHighAddr, sPDDevPAddr.uiAddr);
+#endif
+ PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevId, hPDOSMemHandle, 0, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, 0, PDUMP_PD_UNIQUETAG);
+#endif
#ifdef SUPPORT_SGX_MMU_BYPASS
EnableHostAccess(psMMUContext);
#endif
- PDUMPMALLOCPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
-
if (pvPDCpuVAddr)
{
pui32Tmp = (IMG_UINT32 *)pvPDCpuVAddr;
else
{
PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: pvPDCpuVAddr invalid"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_CPU_ADDR;
}
#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
}
PDUMPCOMMENT("Dummy Page table contents");
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&sMMUAttrib, psDevInfo->hDummyPTOSMemHandle, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
}
PDUMPCOMMENT("Dummy Data Page contents");
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->hDummyDataPageOSMemHandle, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
}
#else
}
#endif
+#if defined(PDUMP)
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if(psMMUContext->bPDumpActive)
+#endif
+ {
+
+ PDUMPCOMMENT("Page directory contents");
+ PDUMPPDENTRIES(&sMMUAttrib, hPDOSMemHandle, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ }
- PDUMPCOMMENT("Page directory contents");
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
-
-#if defined(PDUMP)
- if(PDumpSetMMUContext(PVRSRV_DEVICE_TYPE_SGX,
- "SGXMEM",
- &psMMUContext->ui32PDumpMMUContextID,
- 2,
- PDUMP_PT_UNIQUETAG,
- pvPDCpuVAddr) != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to PDumpSetMMUContext failed"));
- return PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eError;
+
+ IMG_UINT32 ui32MMUType = 1;
+
+ #if defined(SGX_FEATURE_36BIT_MMU)
+ ui32MMUType = 3;
+ #else
+ #if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)
+ ui32MMUType = 2;
+ #endif
+ #endif
+
+ eError = PDumpSetMMUContext(PVRSRV_DEVICE_TYPE_SGX,
+ psDeviceNode->sDevId.pszPDumpDevName,
+ &psMMUContext->ui32PDumpMMUContextID,
+ ui32MMUType,
+ PDUMP_PT_UNIQUETAG,
+ hPDOSMemHandle,
+ pvPDCpuVAddr);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to PDumpSetMMUContext failed"));
+ return eError;
+ }
}
+
+
+ PDUMPCOMMENT("Set MMU context complete (MMU Context ID == %u)", psMMUContext->ui32PDumpMMUContextID);
#endif
SysAcquireData(&psSysData);
+#if defined(PDUMP)
- PDUMPCLEARMMUCONTEXT(PVRSRV_DEVICE_TYPE_SGX, "SGXMEM", psMMUContext->ui32PDumpMMUContextID, 2);
+ PDUMPCOMMENT("Clear MMU context (MMU Context ID == %u)", psMMUContext->ui32PDumpMMUContextID);
+ PDUMPCLEARMMUCONTEXT(PVRSRV_DEVICE_TYPE_SGX, psMMUContext->psDeviceNode->sDevId.pszPDumpDevName, psMMUContext->ui32PDumpMMUContextID, 2);
- PDUMPCOMMENT("Free page directory");
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psMMUContext->pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+#if IMG_ADDRSPACE_PHYSADDR_BITS == 32
+ PDUMPCOMMENT("Free page directory (PDDevPAddr == 0x%08x)",
+ psMMUContext->sPDDevPAddr.uiAddr);
+#else
+ PDUMPCOMMENT("Free page directory, 64-bit arch detected (PDDevPAddr == 0x%08x%08x)",
+ psMMUContext->sPDDevPAddr.uiHighAddr, psMMUContext->sPDDevPAddr.uiAddr);
+#endif
+#endif
+
+ PDUMPFREEPAGETABLE(&psMMUContext->psDeviceNode->sDevId, psMMUContext->hPDOSMemHandle, psMMUContext->pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+ PDUMPFREEPAGETABLE(&psMMUContext->psDeviceNode->sDevId, psDevInfo->hDummyPTPageOSMemHandle, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
+ PDUMPFREEPAGETABLE(&psMMUContext->psDeviceNode->sDevId, psDevInfo->hDummyDataPageOSMemHandle, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
#endif
pui32Tmp = (IMG_UINT32 *)psMMUContext->pvPDCpuVAddr;
IMG_CPU_PHYADDR sCpuPAddr;
- sCpuPAddr = OSMapLinToCPUPhys(psMMUContext->pvPDCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psMMUContext->hPDOSMemHandle,
+ psMMUContext->pvPDCpuVAddr);
sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
if(!psMMUContextList->psNext)
{
- sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->pvDummyPTPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+ psDevInfo->pvDummyPTPageCpuVAddr);
sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
RA_Free (psMMUContext->psDeviceNode->psLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
- sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->pvDummyDataPageCpuVAddr);
+ sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyDataPageOSMemHandle,
+ psDevInfo->pvDummyDataPageCpuVAddr);
sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
+#if defined(PDUMP)
PDUMPCOMMENT("Page directory shared heap range copy");
+ PDUMPCOMMENT(" (Source heap MMU Context ID == %u, PT count == 0x%x)",
+ psMMUHeap->psMMUContext->ui32PDumpMMUContextID,
+ psMMUHeap->ui32PageTableCount);
+ PDUMPCOMMENT(" (Destination MMU Context ID == %u)", psMMUContext->ui32PDumpMMUContextID);
+#endif
#ifdef SUPPORT_SGX_MMU_BYPASS
EnableHostAccess(psMMUContext);
#endif
pui32PDCpuVAddr[ui32PDEntry] = pui32KernelPDCpuVAddr[ui32PDEntry];
if (pui32PDCpuVAddr[ui32PDEntry])
{
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID *) &pui32PDCpuVAddr[ui32PDEntry], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
-
+
+ #if defined(PDUMP)
+
+ #if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ if(psMMUContext->bPDumpActive)
+ #endif
+ {
+ PDUMPPDENTRIES(&psMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID *) &pui32PDCpuVAddr[ui32PDEntry], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ }
+ #endif
#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
bInvalidateDirectoryCache = IMG_TRUE;
#endif
if (!ppsPTInfoList[0])
{
- PVR_DPF((PVR_DBG_MESSAGE, "MMU_UnmapPagesAndFreePTs: Invalid PT for alloc at VAddr:0x%08lX (VaddrIni:0x%08lX AllocPage:%u) PDIdx:%u PTIdx:%u",sTmpDevVAddr.uiAddr, sDevVAddr.uiAddr,i, ui32PDIndex, ui32PTIndex ));
+ PVR_DPF((PVR_DBG_MESSAGE, "MMU_UnmapPagesAndFreePTs: Invalid PT for alloc at VAddr:0x%08X (VaddrIni:0x%08X AllocPage:%u) PDIdx:%u PTIdx:%u",sTmpDevVAddr.uiAddr, sDevVAddr.uiAddr,i, ui32PDIndex, ui32PTIndex ));
sTmpDevVAddr.uiAddr += psMMUHeap->ui32DataPageSize;
}
else
{
- PVR_DPF((PVR_DBG_MESSAGE, "MMU_UnmapPagesAndFreePTs: Page is already invalid for alloc at VAddr:0x%08lX (VAddrIni:0x%08lX AllocPage:%u) PDIdx:%u PTIdx:%u",sTmpDevVAddr.uiAddr, sDevVAddr.uiAddr,i, ui32PDIndex, ui32PTIndex ));
+ PVR_DPF((PVR_DBG_MESSAGE, "MMU_UnmapPagesAndFreePTs: Page is already invalid for alloc at VAddr:0x%08X (VAddrIni:0x%08X AllocPage:%u) PDIdx:%u PTIdx:%u",sTmpDevVAddr.uiAddr, sDevVAddr.uiAddr,i, ui32PDIndex, ui32PTIndex ));
}
if (ppsPTInfoList[0] && ppsPTInfoList[0]->ui32ValidPTECount == 0)
{
-#if defined(ANDROID)
- _DeferredFreePageTable(psMMUHeap, ui32PDIndex - psMMUHeap->ui32PDBaseIndex, IMG_FALSE);
-#else
_DeferredFreePageTable(psMMUHeap, ui32PDIndex - psMMUHeap->ui32PDBaseIndex, IMG_TRUE);
-#endif
bInvalidateDirectoryCache = IMG_TRUE;
}
}
-IMG_VOID MMU_FreePageTables(IMG_PVOID pvMMUHeap,
- IMG_SIZE_T ui32Start,
- IMG_SIZE_T ui32End,
- IMG_HANDLE hUniqueTag)
+static IMG_VOID MMU_FreePageTables(IMG_PVOID pvMMUHeap,
+ IMG_SIZE_T ui32Start,
+ IMG_SIZE_T ui32End,
+ IMG_HANDLE hUniqueTag)
{
MMU_HEAP *pMMUHeap = (MMU_HEAP*)pvMMUHeap;
IMG_DEV_VIRTADDR Start;
MMU_HEAP *
MMU_Create (MMU_CONTEXT *psMMUContext,
DEV_ARENA_DESCRIPTOR *psDevArena,
- RA_ARENA **ppsVMArena)
+ RA_ARENA **ppsVMArena,
+ PDUMP_MMU_ATTRIB **ppsMMUAttrib)
{
MMU_HEAP *pMMUHeap;
IMG_UINT32 ui32ScaleSize;
+ PVR_UNREFERENCED_PARAMETER(ppsMMUAttrib);
+
PVR_ASSERT (psDevArena != IMG_NULL);
if (psDevArena == IMG_NULL)
pMMUHeap->ui32PTShift = pMMUHeap->ui32DataPageBitWidth;
pMMUHeap->ui32PTBitWidth = SGX_MMU_PT_SHIFT - ui32ScaleSize;
pMMUHeap->ui32PTMask = SGX_MMU_PT_MASK & (SGX_MMU_PT_MASK<<ui32ScaleSize);
- pMMUHeap->ui32PTSize = (1UL<<pMMUHeap->ui32PTBitWidth) * sizeof(IMG_UINT32);
+ pMMUHeap->ui32PTSize = (
IMG_UINT32)(1UL<<pMMUHeap->ui32PTBitWidth) * sizeof(IMG_UINT32);
if(pMMUHeap->ui32PTSize < 4 * sizeof(IMG_UINT32))
{
psDevArena->BaseDevVAddr.uiAddr,
psDevArena->ui32Size,
IMG_NULL,
- pMMUHeap->ui32DataPageSize,
+ MAX(HOST_PAGESIZE(), pMMUHeap->ui32DataPageSize),
IMG_NULL,
IMG_NULL,
- MMU_FreePageTables,
+ &MMU_FreePageTables,
pMMUHeap);
if (pMMUHeap->psVMArena == IMG_NULL)
goto ErrorFreePagetables;
}
+#if defined(PDUMP)
+
+ MMU_SetPDumpAttribs(&pMMUHeap->sMMUAttrib,
+ psMMUContext->psDeviceNode,
+ pMMUHeap->ui32DataPageMask,
+ pMMUHeap->ui32PTSize);
+ *ppsMMUAttrib = &pMMUHeap->sMMUAttrib;
+
+ PDUMPCOMMENT("Create MMU device from arena %s (Size == 0x%x, DataPageSize == 0x%x, BaseDevVAddr == 0x%x)",
+ psDevArena->pszName,
+ psDevArena->ui32Size,
+ pMMUHeap->ui32DataPageSize,
+ psDevArena->BaseDevVAddr.uiAddr);
+#endif
+
#if 0
if(psDevArena->ui32HeapID == SGX_TILED_HEAP_ID)
<< EUR_CR_BIF_TILE0_MAX_ADDRESS_SHIFT))
|(EUR_CR_BIF_TILE0_CFG_MASK
& (((ui32XTileStride<<1)|8) << EUR_CR_BIF_TILE0_CFG_SHIFT));
- PDUMPREG(EUR_CR_BIF_TILE0, ui32RegVal);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_TILE0, ui32RegVal);
}
#endif
RA_Delete (pMMUHeap->psVMArena);
}
+#if defined(PDUMP)
+ PDUMPCOMMENT("Delete MMU device from arena %s (BaseDevVAddr == 0x%x, PT count for deferred free == 0x%x)",
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->BaseDevVAddr.uiAddr,
+ pMMUHeap->ui32PageTableCount);
+#endif
+
#ifdef SUPPORT_SGX_MMU_BYPASS
EnableHostAccess(pMMUHeap->psMMUContext);
#endif
if(!bStatus)
{
PVR_DPF((PVR_DBG_ERROR,"MMU_Alloc: RA_Alloc of VMArena failed"));
+ PVR_DPF((PVR_DBG_ERROR,"MMU_Alloc: Alloc of DevVAddr failed from heap %s ID%d",
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->ui32HeapID));
return bStatus;
}
-
+
psDevVAddr->uiAddr = IMG_CAST_TO_DEVVADDR_UINT(uiAddr);
}
if (!bStatus)
{
PVR_DPF((PVR_DBG_ERROR,"MMU_Alloc: _DeferredAllocPagetables failed"));
+ PVR_DPF((PVR_DBG_ERROR,"MMU_Alloc: Failed to alloc pagetable(s) for DevVAddr 0x%8.8x from heap %s ID%d",
+ psDevVAddr->uiAddr,
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->ui32HeapID));
if((uFlags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR) == 0)
{
return;
}
- PVR_DPF ((PVR_DBG_MESSAGE,
- "MMU_Free: mmu=%08X, dev_vaddr=%08X", pMMUHeap, DevVAddr.uiAddr));
+ PVR_DPF((PVR_DBG_MESSAGE, "MMU_Free: Freeing DevVAddr 0x%08X from heap %s ID%d",
+ DevVAddr.uiAddr,
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->ui32HeapID));
if((DevVAddr.uiAddr >= pMMUHeap->psDevArena->BaseDevVAddr.uiAddr) &&
(DevVAddr.uiAddr + ui32Size <= pMMUHeap->psDevArena->BaseDevVAddr.uiAddr + pMMUHeap->psDevArena->ui32Size))
return;
}
- PVR_DPF((PVR_DBG_ERROR,"MMU_Free: Couldn't find DevVAddr %08X in a DevArena",DevVAddr.uiAddr));
+ PVR_DPF((PVR_DBG_ERROR,"MMU_Free: Couldn't free DevVAddr %08X from heap %s ID%d (not in range of heap))",
+ DevVAddr.uiAddr,
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->ui32HeapID));
}
IMG_VOID
if (psPTInfo)
{
+ IMG_UINT32 ui32Flags = 0;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ ui32Flags |= ( MMU_IsHeapShared(pMMUHeap) ) ? PDUMP_FLAGS_PERSISTENT : 0;
+#endif
pui32PTEntry = (IMG_UINT32*)psPTInfo->PTPageCpuVAddr;
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, (IMG_VOID *) &pui32PTEntry[ui32PTIndex], ui32PTDumpCount * sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PT_UNIQUETAG, hUniqueTag);
+ PDUMPMEMPTENTRIES(&pMMUHeap->sMMUAttrib, psPTInfo->hPTPageOSMemHandle, (IMG_VOID *) &pui32PTEntry[ui32PTIndex], ui32PTDumpCount * sizeof(IMG_UINT32), ui32Flags, IMG_FALSE, PDUMP_PT_UNIQUETAG, hUniqueTag);
}
pui32Tmp = (IMG_UINT32*)ppsPTInfoList[0]->PTPageCpuVAddr;
#if !defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
-
- if (pui32Tmp[ui32Index] & SGX_MMU_PTE_VALID)
{
- PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Page is already valid for alloc at VAddr:0x%08lX PDIdx:%u PTIdx:%u",
- DevVAddr.uiAddr,
- DevVAddr.uiAddr >> pMMUHeap->ui32PDShift,
- ui32Index ));
- PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Page table entry value: 0x%08lX", pui32Tmp[ui32Index]));
- PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Physical page to map: 0x%08lX", DevPAddr.uiAddr));
+ IMG_UINT32 uTmp = pui32Tmp[ui32Index];
+
+
+ if (uTmp & SGX_MMU_PTE_VALID)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Page is already valid for alloc at VAddr:0x%08X PDIdx:%u PTIdx:%u",
+ DevVAddr.uiAddr,
+ DevVAddr.uiAddr >> pMMUHeap->ui32PDShift,
+ ui32Index ));
+ PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Page table entry value: 0x%08X", uTmp));
+ PVR_DPF((PVR_DBG_ERROR, "MMU_MapPage: Physical page to map: 0x%08X", DevPAddr.uiAddr));
+ }
+
+ PVR_ASSERT((uTmp & SGX_MMU_PTE_VALID) == 0);
}
-
- PVR_ASSERT((pui32Tmp[ui32Index] & SGX_MMU_PTE_VALID) == 0);
#endif
ppsPTInfoList[0]->ui32ValidPTECount++;
- pui32Tmp[ui32Index] = ((DevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+ pui32Tmp[ui32Index] = ((DevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
& ((~pMMUHeap->ui32DataPageMask)>>SGX_MMU_PTE_ADDR_ALIGNSHIFT))
| SGX_MMU_PTE_VALID
| ui32MMUFlags;
PVR_ASSERT (pMMUHeap != IMG_NULL);
- PVR_DPF ((PVR_DBG_MESSAGE,
- "MMU_MapPages: mmu=%08X, devVAddr=%08X, SysPAddr=%08X, size=0x%x",
- pMMUHeap, DevVAddr.uiAddr, SysPAddr.uiAddr, uSize));
+ PVR_DPF ((PVR_DBG_MESSAGE, "MMU_MapPages: heap:%s, heap_id:%d devVAddr=%08X, SysPAddr=%08X, size=0x%x",
+ pMMUHeap->psDevArena->pszName,
+ pMMUHeap->psDevArena->ui32HeapID,
+ DevVAddr.uiAddr,
+ SysPAddr.uiAddr,
+ uSize));
ui32VAdvance = pMMUHeap->ui32DataPageSize;
#endif
PVR_DPF ((PVR_DBG_MESSAGE,
- "MMU_MapShadow: %08X, 0x%x, %08X",
+ "MMU_MapShadow: DevVAddr:%08X, Bytes:0x%x, CPUVAddr:%08X",
MapBaseDevVAddr.uiAddr,
uByteSize,
- CpuVAddr));
+ (IMG_UINTPTR_T)CpuVAddr));
ui32VAdvance = pMMUHeap->ui32DataPageSize;
ui32PAdvance = pMMUHeap->ui32DataPageSize;
- PVR_ASSERT(((IMG_UINT32)CpuVAddr & (SGX_MMU_PAGE_SIZE - 1)) == 0);
+ PVR_ASSERT(((IMG_UINTPTR_T)CpuVAddr & (SGX_MMU_PAGE_SIZE - 1)) == 0);
PVR_ASSERT(((IMG_UINT32)uByteSize & pMMUHeap->ui32DataPageMask) == 0);
pDevVAddr->uiAddr = MapBaseDevVAddr.uiAddr;
if(CpuVAddr)
{
- CpuPAddr = OSMapLinToCPUPhys ((IMG_VOID *)((IMG_UINT32)CpuVAddr + uOffset));
+ CpuPAddr = OSMapLinToCPUPhys (hOSMemHandle,
+ (IMG_VOID *)((IMG_UINTPTR_T)CpuVAddr + uOffset));
}
else
{
PVR_ASSERT((DevPAddr.uiAddr & pMMUHeap->ui32DataPageMask) == 0);
PVR_DPF ((PVR_DBG_MESSAGE,
- "0x%x: CpuVAddr=%08X, CpuPAddr=%08X, DevVAddr=%08X, DevPAddr=%08X",
+ "Offset=0x%x: CpuVAddr=%08X, CpuPAddr=%08X, DevVAddr=%08X, DevPAddr=%08X",
uOffset,
(IMG_UINTPTR_T)CpuVAddr + uOffset,
CpuPAddr.uiAddr,
if (!ppsPTInfoList[0])
{
- PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: ERROR Invalid PT for alloc at VAddr:0x%08lX (VaddrIni:0x%08lX AllocPage:%u) PDIdx:%u PTIdx:%u",
+ PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: ERROR Invalid PT for alloc at VAddr:0x%08X (VaddrIni:0x%08X AllocPage:%u) PDIdx:%u PTIdx:%u",
sTmpDevVAddr.uiAddr,
sDevVAddr.uiAddr,
i,
}
else
{
- PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: Page is already invalid for alloc at VAddr:0x%08lX (VAddrIni:0x%08lX AllocPage:%u) PDIdx:%u PTIdx:%u",
+ PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: Page is already invalid for alloc at VAddr:0x%08X (VAddrIni:0x%08X AllocPage:%u) PDIdx:%u PTIdx:%u",
sTmpDevVAddr.uiAddr,
sDevVAddr.uiAddr,
i,
ui32PDIndex,
ui32PTIndex));
- PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: Page table entry value: 0x%08lX", pui32Tmp[ui32PTIndex]));
+ PVR_DPF((PVR_DBG_ERROR, "MMU_UnmapPages: Page table entry value: 0x%08X", pui32Tmp[ui32PTIndex]));
}
sDevPAddr.uiAddr <<= SGX_MMU_PTE_ADDR_ALIGNSHIFT;
-
+
return sDevPAddr;
}
if(pui8MemBlock)
{
- sMemBlockCpuPAddr = OSMapLinToCPUPhys(pui8MemBlock);
+ sMemBlockCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle,
+ pui8MemBlock);
}
else
{
#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
-PVRSRV_ERROR WorkaroundBRN22997Alloc(PVRSRV_SGXDEV_INFO *psDevInfo)
+PVRSRV_ERROR WorkaroundBRN22997Alloc(PVRSRV_DEVICE_NODE *psDeviceNode)
{
PVRSRV_ERROR eError;
SYS_DATA *psSysData;
IMG_CPU_PHYADDR sCpuPAddr;
IMG_DEV_PHYADDR sPTDevPAddr;
IMG_DEV_PHYADDR sPDDevPAddr;
+ PVRSRV_SGXDEV_INFO *psDevInfo;
+ IMG_UINT32 ui32PDOffset;
+ IMG_UINT32 ui32PTOffset;
+
+ psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
SysAcquireData(&psSysData);
PVR_DPF((PVR_DBG_ERROR, "WorkaroundBRN22997: ERROR call to OSAllocPages failed"));
return eError;
}
+ ui32PTOffset = 0;
eError = OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
SGX_MMU_PAGE_SIZE,
PVR_DPF((PVR_DBG_ERROR, "WorkaroundBRN22997: ERROR call to OSAllocPages failed"));
return eError;
}
+ ui32PDOffset = 0;
if(pui32PT)
{
- sCpuPAddr = OSMapLinToCPUPhys(pui32PT);
+ sCpuPAddr = OSMapLinToCPUPhys(hPTPageOSMemHandle,
+ pui32PT);
}
else
{
if(pui32PD)
{
- sCpuPAddr = OSMapLinToCPUPhys(pui32PD);
+ sCpuPAddr = OSMapLinToCPUPhys(hPDPageOSMemHandle,
+ pui32PD);
}
else
{
PVR_DPF((PVR_DBG_ERROR, "WorkaroundBRN22997: ERROR failed to map page tables"));
return PVRSRV_ERROR_BAD_MAPPING;
}
+ ui32PTOffset = 0;
sPTDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
- pui32PD = pui32PT + 1024;
- sPDDevPAddr.uiAddr = sPTDevPAddr.uiAddr + 4096;
+ pui32PD = pui32PT + SGX_MMU_PAGE_SIZE/sizeof(IMG_UINT32);
+ ui32PDOffset = SGX_MMU_PAGE_SIZE;
+ hPDPageOSMemHandle = hPTPageOSMemHandle;
+ sPDDevPAddr.uiAddr = sPTDevPAddr.uiAddr + SGX_MMU_PAGE_SIZE;
}
OSMemSet(pui32PD, 0, SGX_MMU_PAGE_SIZE);
OSMemSet(pui32PT, 0, SGX_MMU_PAGE_SIZE);
- PDUMPMALLOCPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
- PDUMPMALLOCPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
+ PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevId, hPDPageOSMemHandle, ui32PDOffset, pui32PD, SGX_MMU_PAGE_SIZE, 0, PDUMP_PD_UNIQUETAG);
+ PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevId, hPTPageOSMemHandle, ui32PTOffset, pui32PT, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, hPDPageOSMemHandle, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, hPTPageOSMemHandle, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
psDevInfo->hBRN22997PTPageOSMemHandle = hPTPageOSMemHandle;
psDevInfo->hBRN22997PDPageOSMemHandle = hPDPageOSMemHandle;
ui32PTIndex = (sDevVAddr.uiAddr & SGX_MMU_PT_MASK) >> SGX_MMU_PAGE_SHIFT;
- pui32PD[ui32PDIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+ pui32PD[ui32PDIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
| SGX_MMU_PDE_VALID;
- pui32PT[ui32PTIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+ pui32PT[ui32PTIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
| SGX_MMU_PTE_VALID;
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, psDevInfo->hBRN22997PDPageOSMemHandle, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, psDevInfo->hBRN22997PTPageOSMemHandle, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0,
psDevInfo->sBRN22997PDDevPAddr.uiAddr);
- PDUMPPDREG(EUR_CR_BIF_DIR_LIST_BASE0, psDevInfo->sBRN22997PDDevPAddr.uiAddr, PDUMP_PD_UNIQUETAG);
+ PDUMPPDREG(&psDevInfo->sMMUAttrib, EUR_CR_BIF_DIR_LIST_BASE0, psDevInfo->sBRN22997PDDevPAddr.uiAddr, PDUMP_PD_UNIQUETAG);
ui32BIFCtrl = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
- PDUMPREG(EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl);
- PDUMPREG(EUR_CR_BIF_CTRL, ui32BIFCtrl);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl);
if (pui32HostPort)
- PDUMPCOMMENT("RDW :SGXMEM:v4:%08lX\r\n", sDevVAddr.uiAddr);
+ PDUMPCOMMENT("RDW :SGXMEM:v4:%08X\r\n", sDevVAddr.uiAddr);
- PDUMPCOMMENT("SAB :SGXMEM:v4:%08lX 4 0 hostport.bin", sDevVAddr.uiAddr);
+ PDUMPCOMMENT("SAB :SGXMEM:v4:%08X 4 0 hostport.bin", sDevVAddr.uiAddr);
pui32PD[ui32PDIndex] = 0;
pui32PT[ui32PTIndex] = 0;
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, psDevInfo->hBRN22997PDPageOSMemHandle, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(&psDevInfo->sMMUAttrib, psDevInfo->hBRN22997PTPageOSMemHandle, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
- PDUMPREG(EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl);
- PDUMPREG(EUR_CR_BIF_CTRL, ui32BIFCtrl);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl);
}
-IMG_VOID WorkaroundBRN22997Free(PVRSRV_SGXDEV_INFO *psDevInfo)
+IMG_VOID WorkaroundBRN22997Free(PVRSRV_DEVICE_NODE *psDeviceNode)
{
SYS_DATA *psSysData;
RA_ARENA *psLocalDevMemArena;
+ PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+
SysAcquireData(&psSysData);
psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pui32BRN22997PD, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pui32BRN22997PT, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+ PDUMPFREEPAGETABLE(&psDeviceNode->sDevId, psDevInfo->hBRN22997PDPageOSMemHandle, psDevInfo->pui32BRN22997PD, SGX_MMU_PAGE_SIZE, 0, PDUMP_PD_UNIQUETAG);
+ PDUMPFREEPAGETABLE(&psDeviceNode->sDevId, psDevInfo->hBRN22997PTPageOSMemHandle, psDevInfo->pui32BRN22997PT, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
if(psLocalDevMemArena == IMG_NULL)
if(pui32PT)
{
- sCpuPAddr = OSMapLinToCPUPhys(pui32PT);
+ sCpuPAddr = OSMapLinToCPUPhys(hPTPageOSMemHandle,
+ pui32PT);
}
else
{
else
{
IMG_SYS_PHYADDR sSysPAddr;
-
+
if(RA_Alloc(psLocalDevMemArena,
SGX_MMU_PAGE_SIZE,
sPTDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
- psDevInfo->sExtSystemCacheRegsPTSysPAddr = sSysPAddr;
+ psDevInfo->sExtSystemCacheRegsPTSysPAddr = sSysPAddr;
}
OSMemSet(pui32PT, 0, SGX_MMU_PAGE_SIZE);
ui32PTIndex = (SGX_EXT_SYSTEM_CACHE_REGS_DEVVADDR_BASE & SGX_MMU_PT_MASK) >> SGX_MMU_PAGE_SHIFT;
- pui32PD[ui32PDIndex] = (sPTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+ pui32PD[ui32PDIndex] = (sPTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
| SGX_MMU_PDE_VALID;
- pui32PT[ui32PTIndex] = (psDevInfo->sExtSysCacheRegsDevPBase.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+ pui32PT[ui32PTIndex] = (psDevInfo->sExtSysCacheRegsDevPBase.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
| SGX_MMU_PTE_VALID;
- PDUMPMALLOCPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
+ PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevID, hPTPageOSMemHandle, 0, pui32PT, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(PVRSRV_DEVICE_TYPE_SGX, hPDPageOSMemHandle, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(PVRSRV_DEVICE_TYPE_SGX, hPTPageOSMemHandle, pui32PT, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PD_UNIQUETAG);
psDevInfo->pui32ExtSystemCacheRegsPT = pui32PT;
ui32PDIndex = (SGX_EXT_SYSTEM_CACHE_REGS_DEVVADDR_BASE & SGX_MMU_PD_MASK) >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
pui32PD[ui32PDIndex] = 0;
- PDUMPMEM2(PVRSRV_DEVICE_TYPE_SGX, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
- PDUMPFREEPAGETABLE(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->pui32ExtSystemCacheRegsPT, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+ PDUMPMEMPTENTRIES(PVRSRV_DEVICE_TYPE_SGX, psDeviceNode->sDevMemoryInfo.pBMKernelContext->psMMUContext->hPDOSMemHandle, pui32PD, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+ PDUMPFREEPAGETABLE(&psDeviceNode->sDevId, psDevInfo->hExtSystemCacheRegsPTPageOSMemHandle, psDevInfo->pui32ExtSystemCacheRegsPT, SGX_MMU_PAGE_SIZE, 0, PDUMP_PT_UNIQUETAG);
if(psLocalDevMemArena == IMG_NULL)
MMU_HEAP *
MMU_Create (MMU_CONTEXT *psMMUContext,
DEV_ARENA_DESCRIPTOR *psDevArena,
- RA_ARENA **ppsVMArena);
+ RA_ARENA **ppsVMArena,
+ PDUMP_MMU_ATTRIB **ppsMMUAttrib);
IMG_VOID
-MMU_Delete (MMU_HEAP *pMMU);
+MMU_Delete (MMU_HEAP *pMMUHeap);
IMG_BOOL
-MMU_Alloc (MMU_HEAP *pMMU,
+MMU_Alloc (MMU_HEAP *pMMUHeap,
IMG_SIZE_T uSize,
IMG_SIZE_T *pActualSize,
IMG_UINT32 uFlags,
IMG_DEV_VIRTADDR *pDevVAddr);
IMG_VOID
-MMU_Free (MMU_HEAP *pMMU,
+MMU_Free (MMU_HEAP *pMMUHeap,
IMG_DEV_VIRTADDR DevVAddr,
IMG_UINT32 ui32Size);
IMG_VOID
-MMU_Enable (MMU_HEAP *pMMU);
+MMU_Enable (MMU_HEAP *pMMUHeap);
IMG_VOID
-MMU_Disable (MMU_HEAP *pMMU);
+MMU_Disable (MMU_HEAP *pMMUHeap);
IMG_VOID
-MMU_MapPages (MMU_HEAP *pMMU,
- IMG_DEV_VIRTADDR devVAddr,
+MMU_MapPages (MMU_HEAP *pMMUHeap,
+ IMG_DEV_VIRTADDR DevVAddr,
IMG_SYS_PHYADDR SysPAddr,
IMG_SIZE_T uSize,
IMG_UINT32 ui32MemFlags,
IMG_HANDLE hUniqueTag);
IMG_VOID
-MMU_MapShadow (MMU_HEAP * pMMU,
+MMU_MapShadow (MMU_HEAP * pMMUHeap,
IMG_DEV_VIRTADDR MapBaseDevVAddr,
- IMG_SIZE_T uSize,
+ IMG_SIZE_T uByteSize,
IMG_CPU_VIRTADDR CpuVAddr,
IMG_HANDLE hOSMemHandle,
IMG_DEV_VIRTADDR * pDevVAddr,
IMG_HANDLE hUniqueTag);
IMG_VOID
-MMU_UnmapPages (MMU_HEAP *pMMU,
- IMG_DEV_VIRTADDR dev_vaddr,
+MMU_UnmapPages (MMU_HEAP *psMMUHeap,
+ IMG_DEV_VIRTADDR sDevVAddr,
IMG_UINT32 ui32PageCount,
IMG_HANDLE hUniqueTag);
IMG_VOID
-MMU_MapScatter (MMU_HEAP *pMMU,
+MMU_MapScatter (MMU_HEAP *pMMUHeap,
IMG_DEV_VIRTADDR DevVAddr,
IMG_SYS_PHYADDR *psSysAddr,
IMG_SIZE_T uSize,
IMG_VOID MMU_BIFResetPDFree(PVRSRV_SGXDEV_INFO *psDevInfo);
#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
-PVRSRV_ERROR WorkaroundBRN22997Alloc(PVRSRV_SGXDEV_INFO *psDevInfo);
+PVRSRV_ERROR WorkaroundBRN22997Alloc(PVRSRV_DEVICE_NODE *psDeviceNode);
IMG_VOID WorkaroundBRN22997ReadHostPort(PVRSRV_SGXDEV_INFO *psDevInfo);
-IMG_VOID WorkaroundBRN22997Free(PVRSRV_SGXDEV_INFO *psDevInfo);
+IMG_VOID WorkaroundBRN22997Free(PVRSRV_DEVICE_NODE *psDeviceNode);
#endif
#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
PVRSRV_ERROR MMU_UnmapExtSystemCacheRegs(PVRSRV_DEVICE_NODE *psDeviceNode);
#endif
+IMG_BOOL MMU_IsHeapShared(MMU_HEAP* pMMU_Heap);
+
+#if defined(PDUMP)
+IMG_UINT32 MMU_GetPDumpContextID(IMG_HANDLE hDevMemContext);
+#endif
+
#endif
#include <stddef.h>
#include "services_headers.h"
+#include "sgx_bridge_km.h"
#include "sgxapi_km.h"
#include "sgxinfo.h"
#include "sgxinfokm.h"
{
IMG_UINT32 i;
PRESMAN_ITEM psResItem;
-
+
if(psStubPBDesc->ui32TotalPBSize != ui32TotalPBSize)
{
PVR_DPF((PVR_DBG_WARNING,
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ExitNotFound;
}
-
+
psResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_PB_DESC,
psStubPBDesc,
PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: ResManRegisterRes failed"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto ExitNotFound;
}
{
PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: ResManRegisterRes failed"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto ExitNotFound;
}
PVR_ASSERT(psPerProcCreateSharedPB == IMG_NULL);
psDeviceNode = (PVRSRV_DEVICE_NODE*)psStubPBDescIn->hDevCookie;
-
+
psStubPBDescIn->ui32RefCount--;
if (psStubPBDescIn->ui32RefCount == 0)
psStubPBDescIn->ppsSubKernelMemInfos = IMG_NULL;
PVRSRVFreeSharedSysMemoryKM(psStubPBDescIn->psBlockKernelMemInfo);
-
+
PVRSRVFreeDeviceMemKM(psStubPBDescIn->hDevCookie, psStubPBDescIn->psHWBlockKernelMemInfo);
PVRSRVFreeDeviceMemKM(psStubPBDescIn->hDevCookie, psStubPBDescIn->psHWPBDescKernelMemInfo);
static PVRSRV_ERROR SGXCleanupSharedPBDescCreateLockCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
{
-#ifdef DEBUG_PVR
+#ifdef DEBUG
PVRSRV_PER_PROCESS_DATA *psPerProc = (PVRSRV_PER_PROCESS_DATA *)pvParam;
PVR_ASSERT(psPerProc == psPerProcCreateSharedPB);
#else
IMG_UINT32 ui32SharedPBDescSubKernelMemInfosCount)
{
PVRSRV_STUB_PBDESC *psStubPBDesc=IMG_NULL;
- PVRSRV_ERROR eRet = PVRSRV_ERROR_GENERIC;
+ PVRSRV_ERROR eRet = PVRSRV_ERROR_INVALID_PERPROC;
IMG_UINT32 i;
PVRSRV_SGXDEV_INFO *psSGXDevInfo;
PRESMAN_ITEM psResItem;
PVR_DPF((PVR_DBG_WARNING,
"SGXAddSharedPBDescKM: Shared PB requested with different size (0x%x) from existing shared PB (0x%x) - requested size ignored",
ui32TotalPBSize, psStubPBDesc->ui32TotalPBSize));
-
+
}
{
goto NoAdd;
}
-
+
if(PVRSRVDissociateMemFromResmanKM(psHWBlockKernelMemInfo)
!= PVRSRV_OK)
{
goto NoAdd;
}
-
+
psStubPBDesc->ui32RefCount = 1;
psStubPBDesc->ui32TotalPBSize = ui32TotalPBSize;
psStubPBDesc->psSharedPBDescKernelMemInfo = psSharedPBDescKernelMemInfo;
PVRSRV_DEVICE_NODE *psDeviceNode,
IMG_HANDLE hDevMemContext);
-#if defined(SUPPORT_SGX_HWPERF)
-IMG_IMPORT
-PVRSRV_ERROR SGXReadDiffCountersKM(IMG_HANDLE hDevHandle,
- IMG_UINT32 ui32Reg,
- IMG_UINT32 *pui32Old,
- IMG_BOOL bNew,
- IMG_UINT32 ui32New,
- IMG_UINT32 ui32NewReset,
- IMG_UINT32 ui32CountersReg,
- IMG_UINT32 ui32Reg2,
- IMG_BOOL *pbActive,
- PVRSRV_SGXDEV_DIFF_INFO *psDiffs);
IMG_IMPORT
PVRSRV_ERROR SGXReadHWPerfCBKM(IMG_HANDLE hDevHandle,
IMG_UINT32 ui32ArraySize,
IMG_UINT32 *pui32DataCount,
IMG_UINT32 *pui32ClockSpeed,
IMG_UINT32 *pui32HostTimeStamp);
-#endif
IMG_IMPORT
PVRSRV_ERROR SGX2DQueryBlitsCompleteKM(PVRSRV_SGXDEV_INFO *psDevInfo,
#endif
#define SGX_GENERAL_HEAP_BASE 0x10000000
- #define SGX_GENERAL_HEAP_SIZE (0xC8000000-0x00001000)
+ #define SGX_GENERAL_HEAP_SIZE (0xC2000000-0x00001000)
- #define SGX_3DPARAMETERS_HEAP_BASE 0xD8000000
+ #define SGX_3DPARAMETERS_HEAP_BASE 0xD2000000
#define SGX_3DPARAMETERS_HEAP_SIZE (0x10000000-0x00001000)
- #define SGX_TADATA_HEAP_BASE 0xE8000000
+ #define SGX_TADATA_HEAP_BASE 0xE2000000
#define SGX_TADATA_HEAP_SIZE (0x0D000000-0x00001000)
- #define SGX_SYNCINFO_HEAP_BASE 0xF5000000
+ #define SGX_SYNCINFO_HEAP_BASE 0xEF000000
#define SGX_SYNCINFO_HEAP_SIZE (0x01000000-0x00001000)
- #define SGX_PDSPIXEL_CODEDATA_HEAP_BASE 0xF6000000
+ #define SGX_PDSPIXEL_CODEDATA_HEAP_BASE 0xF0000000
#define SGX_PDSPIXEL_CODEDATA_HEAP_SIZE (0x02000000-0x00001000)
- #define SGX_KERNEL_CODE_HEAP_BASE 0xF8000000
+ #define SGX_KERNEL_CODE_HEAP_BASE 0xF2000000
#define SGX_KERNEL_CODE_HEAP_SIZE (0x00080000-0x00001000)
- #define SGX_PDSVERTEX_CODEDATA_HEAP_BASE 0xF8400000
+ #define SGX_PDSVERTEX_CODEDATA_HEAP_BASE 0xF2400000
#define SGX_PDSVERTEX_CODEDATA_HEAP_SIZE (0x01C00000-0x00001000)
- #define SGX_KERNEL_DATA_HEAP_BASE 0xFA000000
+ #define SGX_KERNEL_DATA_HEAP_BASE 0xF4000000
#define SGX_KERNEL_DATA_HEAP_SIZE (0x05000000-0x00001000)
- #define SGX_PIXELSHADER_HEAP_BASE 0xFF000000
- #define SGX_PIXELSHADER_HEAP_SIZE (0x00500000-0x00001000)
- #define SGX_VERTEXSHADER_HEAP_BASE 0xFF800000
- #define SGX_VERTEXSHADER_HEAP_SIZE (0x00200000-0x00001000)
+ #define SGX_PIXELSHADER_HEAP_BASE 0xF9000000
+ #define SGX_PIXELSHADER_HEAP_SIZE (0x05000000-0x00001000)
+
+ #define SGX_VERTEXSHADER_HEAP_BASE 0xFE000000
+ #define SGX_VERTEXSHADER_HEAP_SIZE (0x02000000-0x00001000)
#define SGX_CORE_IDENTIFIED
#if !defined(SGX_CORE_IDENTIFIED)
#error "sgxconfig.h: ERROR: unspecified SGX Core version"
+#endif
+
+#if !defined (SGX_FEATURE_EDM_VERTEX_PDSADDR_FULL_RANGE)
+ #if ((SGX_KERNEL_CODE_HEAP_BASE + SGX_KERNEL_CODE_HEAP_SIZE - SGX_PDSPIXEL_CODEDATA_HEAP_BASE) > 0x4000000)
+ #error "sgxconfig.h: ERROR: SGX_KERNEL_CODE_HEAP_BASE out of range of SGX_PDSPIXEL_CODEDATA_HEAP_BASE"
+ #endif
+
+ #if ((SGX_PDSVERTEX_CODEDATA_HEAP_BASE + SGX_PDSVERTEX_CODEDATA_HEAP_SIZE - SGX_PDSPIXEL_CODEDATA_HEAP_BASE) > 0x4000000)
+ #error "sgxconfig.h: ERROR: SGX_PDSVERTEX_CODEDATA_HEAP_BASE out of range of SGX_PDSPIXEL_CODEDATA_HEAP_BASE"
+ #endif
#endif
+#if defined(SGX_FEATURE_2D_HARDWARE) && defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+ #if ((SGX_GENERAL_MAPPING_HEAP_BASE + SGX_GENERAL_MAPPING_HEAP_SIZE - SGX_2D_HEAP_BASE) >= EUR_CR_BIF_TWOD_REQ_BASE_ADDR_MASK)
+ #error "sgxconfig.h: ERROR: SGX_GENERAL_MAPPING_HEAP inaccessable by 2D requestor"
+ #endif
+#endif
+
+#if defined (EURASIA_USE_CODE_PAGE_SIZE)
+ #if ((SGX_KERNEL_CODE_HEAP_BASE & (EURASIA_USE_CODE_PAGE_SIZE - 1)) != 0)
+ #error "sgxconfig.h: ERROR: Kernel code heap base misalignment"
+ #endif
+#endif
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+ #if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+ #if ((SGX_2D_HEAP_BASE + SGX_2D_HEAP_SIZE) >= SGX_GENERAL_MAPPING_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_2D_HEAP overlaps SGX_GENERAL_MAPPING_HEAP"
+ #endif
+ #else
+ #if ((SGX_2D_HEAP_BASE + SGX_2D_HEAP_SIZE) >= SGX_GENERAL_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_2D_HEAP overlaps SGX_GENERAL_HEAP_BASE"
+ #endif
+ #endif
+#else
+ #if defined(FIX_HW_BRN_26915)
+ #if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+ #if ((SGX_CGBUFFER_HEAP_BASE + SGX_CGBUFFER_HEAP_SIZE) >= SGX_GENERAL_MAPPING_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_CGBUFFER_HEAP overlaps SGX_GENERAL_MAPPING_HEAP"
+ #endif
+ #else
+ #if ((SGX_CGBUFFER_HEAP_BASE + SGX_CGBUFFER_HEAP_SIZE) >= SGX_GENERAL_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_CGBUFFER_HEAP overlaps SGX_GENERAL_HEAP_BASE"
+ #endif
+ #endif
+ #endif
+#endif
+
+#if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+ #if ((SGX_GENERAL_MAPPING_HEAP_BASE + SGX_GENERAL_MAPPING_HEAP_SIZE) >= SGX_GENERAL_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_GENERAL_MAPPING_HEAP overlaps SGX_GENERAL_HEAP"
+ #endif
+#endif
+
+#if ((SGX_GENERAL_HEAP_BASE + SGX_GENERAL_HEAP_SIZE) >= SGX_3DPARAMETERS_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_GENERAL_HEAP overlaps SGX_3DPARAMETERS_HEAP"
+#endif
+
+#if ((SGX_3DPARAMETERS_HEAP_BASE + SGX_3DPARAMETERS_HEAP_SIZE) >= SGX_TADATA_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_3DPARAMETERS_HEAP overlaps SGX_TADATA_HEAP"
+#endif
+
+#if ((SGX_TADATA_HEAP_BASE + SGX_TADATA_HEAP_SIZE) >= SGX_SYNCINFO_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_TADATA_HEAP overlaps SGX_SYNCINFO_HEAP"
+#endif
+
+#if ((SGX_SYNCINFO_HEAP_BASE + SGX_SYNCINFO_HEAP_SIZE) >= SGX_PDSPIXEL_CODEDATA_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_SYNCINFO_HEAP overlaps SGX_PDSPIXEL_CODEDATA_HEAP"
+#endif
+
+#if ((SGX_PDSPIXEL_CODEDATA_HEAP_BASE + SGX_PDSPIXEL_CODEDATA_HEAP_SIZE) >= SGX_KERNEL_CODE_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_PDSPIXEL_CODEDATA_HEAP overlaps SGX_KERNEL_CODE_HEAP"
+#endif
+
+#if ((SGX_KERNEL_CODE_HEAP_BASE + SGX_KERNEL_CODE_HEAP_SIZE) >= SGX_PDSVERTEX_CODEDATA_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_KERNEL_CODE_HEAP overlaps SGX_PDSVERTEX_CODEDATA_HEAP"
+#endif
+
+#if ((SGX_PDSVERTEX_CODEDATA_HEAP_BASE + SGX_PDSVERTEX_CODEDATA_HEAP_SIZE) >= SGX_KERNEL_DATA_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_PDSVERTEX_CODEDATA_HEAP overlaps SGX_KERNEL_DATA_HEAP"
+#endif
+
+#if ((SGX_KERNEL_DATA_HEAP_BASE + SGX_KERNEL_DATA_HEAP_SIZE) >= SGX_PIXELSHADER_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_KERNEL_DATA_HEAP overlaps SGX_PIXELSHADER_HEAP"
+#endif
+
+#if ((SGX_PIXELSHADER_HEAP_BASE + SGX_PIXELSHADER_HEAP_SIZE) >= SGX_VERTEXSHADER_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_PIXELSHADER_HEAP overlaps SGX_VERTEXSHADER_HEAP"
+#endif
+
+#if ((SGX_VERTEXSHADER_HEAP_BASE + SGX_VERTEXSHADER_HEAP_SIZE) < SGX_VERTEXSHADER_HEAP_BASE)
+ #error "sgxconfig.h: ERROR: SGX_VERTEXSHADER_HEAP_BASE size cause wraparound"
+#endif
+
#endif
#define SGX_HOSTPORT_PRESENT 0x00000001UL
+#define SGX_PDUMPREG_NAME "SGXREG"
+
typedef struct _PVRSRV_STUB_PBDESC_ PVRSRV_STUB_PBDESC;
#if defined(SGX_SUPPORT_HWPROFILING)
PPVRSRV_KERNEL_MEM_INFO psKernelHWProfilingMemInfo;
#endif
- IMG_UINT32 ui32KickTACounter;
- IMG_UINT32 ui32KickTARenderCounter;
-#if defined(SUPPORT_SGX_HWPERF)
- PPVRSRV_KERNEL_MEM_INFO psKernelHWPerfCBMemInfo;
- IMG_UINT32 ui32HWGroupRequested;
- IMG_UINT32 ui32HWReset;
+ PPVRSRV_KERNEL_MEM_INFO psKernelHWPerfCBMemInfo;
+ PPVRSRV_KERNEL_MEM_INFO psKernelTASigBufferMemInfo;
+ PPVRSRV_KERNEL_MEM_INFO psKernel3DSigBufferMemInfo;
+#if defined(FIX_HW_BRN_29702)
+ PPVRSRV_KERNEL_MEM_INFO psKernelCFIMemInfo;
+#endif
+#if defined(FIX_HW_BRN_29823)
+ PPVRSRV_KERNEL_MEM_INFO psKernelDummyTermStreamMemInfo;
#endif
-#ifdef PVRSRV_USSE_EDM_STATUS_DEBUG
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
PPVRSRV_KERNEL_MEM_INFO psKernelEDMStatusBufferMemInfo;
-#endif
+#endif
#if defined(SGX_FEATURE_OVERLAPPED_SPM)
PPVRSRV_KERNEL_MEM_INFO psKernelTmpRgnHeaderMemInfo;
-#endif
+#endif
#if defined(SGX_FEATURE_SPM_MODE_0)
PPVRSRV_KERNEL_MEM_INFO psKernelTmpDPMStateMemInfo;
-#endif
+#endif
IMG_UINT32 ui32ClientRefCount;
#if defined(SGX_FEATURE_MP)
IMG_UINT32 ui32MasterClkGateStatusReg;
IMG_UINT32 ui32MasterClkGateStatusMask;
+ IMG_UINT32 ui32MasterClkGateStatus2Reg;
+ IMG_UINT32 ui32MasterClkGateStatus2Mask;
#endif
SGX_INIT_SCRIPTS sScripts;
IMG_UINT32 ui32Flags;
+
+ IMG_UINT32 ui32MemTilingUsage;
+
#if defined(PDUMP)
PVRSRV_SGX_PDUMP_CONTEXT sPDContext;
#endif
IMG_DEV_PHYADDR sDummyDataDevPAddr;
IMG_HANDLE hDummyDataPageOSMemHandle;
#endif
-
+#if defined(PDUMP)
+ PDUMP_MMU_ATTRIB sMMUAttrib;
+#endif
IMG_UINT32 asSGXDevData[SGX_MAX_DEV_DATA];
} PVRSRV_SGXDEV_INFO;
SGX_TIMING_INFORMATION sTimingInfo;
#endif
+#if defined(PDUMP)
+
+ IMG_CHAR *pszPDumpDevName;
+#endif
} SGX_DEVICE_MAP;
IMG_VOID SGXOSTimer(IMG_VOID *pvData);
IMG_VOID SGXReset(PVRSRV_SGXDEV_INFO *psDevInfo,
- IMG_UINT32 ui32PDUMPFlags);
+ IMG_BOOL bHardwareRecovery,
+ IMG_UINT32 ui32PDUMPFlags);
-PVRSRV_ERROR SGXInitialise(PVRSRV_SGXDEV_INFO *psDevInfo);
+PVRSRV_ERROR SGXInitialise(PVRSRV_SGXDEV_INFO *psDevInfo,
+ IMG_BOOL bHardwareRecovery);
PVRSRV_ERROR SGXDeinitialise(IMG_HANDLE hDevCookie);
PVRSRV_ERROR SGXPrePowerState(IMG_HANDLE hDevHandle,
IMG_BOOL bIdleDevice,
PVRSRV_DEV_POWER_STATE eCurrentPowerState);
-IMG_VOID SGXPanic(PVRSRV_DEVICE_NODE *psDeviceNode);
+IMG_VOID SGXPanic(PVRSRV_SGXDEV_INFO *psDevInfo);
PVRSRV_ERROR SGXDevInitCompatCheck(PVRSRV_DEVICE_NODE *psDeviceNode);
-/**********************************************************************
+/**********************************************************************DPLLJ
*
* Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
*
******************************************************************************/
#include <stddef.h>
-
+#include <linux/delay.h>
+#include <linux/io.h>
#include "sgxdefs.h"
#include "sgxmmu.h"
#include "services_headers.h"
#include "lists.h"
#include "srvkm.h"
-DECLARE_LIST_ANY_VA(PVRSRV_POWER_DEV);
-#if defined(SUPPORT_SGX_HWPERF)
-IMG_VOID* MatchPowerDeviceIndex_AnyVaCb(PVRSRV_POWER_DEV *psPowerDev, va_list va);
+#define WR_MEM_32(addr, data) *(unsigned int*)(addr) = data
+#define RD_MEM_32(addr) *(unsigned int*)(addr)
+#define UWORD32 unsigned int
+
+#ifdef PLAT_TI81xx
+#define SGX_TI81xx_CLK_DVDR_ADDR 0x481803b0
+#define CLKCTRL 0x4
+#define TENABLE 0x8
+#define TENABLEDIV 0xC
+#define M2NDIV 0x10
+#define MN2DIV 0x14
+#define STATUS 0x24
+#define PLL_BASE_ADDRESS 0x481C5000
+#define SGX_PLL_BASE (PLL_BASE_ADDRESS+0x0B0)
+#define OSC_0 20
+#define SGX_DIVIDER_ADDR 0x481803B0
+// ADPLLJ_CLKCRTL_Register Value Configurations
+// ADPLLJ_CLKCRTL_Register SPEC bug bit 19,bit29 -- CLKLDOEN,CLKDCOEN
+#define ADPLLJ_CLKCRTL_HS2 0x00000801 //HS2 Mode,TINTZ =1 --used by all PLL's except HDMI
#endif
+
#define VAR(x) #x
+
#define CHECK_SIZE(NAME) \
{ \
if (psSGXStructSizes->ui32Sizeof_##NAME != psDevInfo->sSGXStructSizes.ui32Sizeof_##NAME) \
IMG_BOOL SGX_ISRHandler(IMG_VOID *pvData);
#endif
-IMG_UINT32 gui32EventStatusServicesByISR = 0;
-
static
PVRSRV_ERROR SGXGetMiscInfoUkernel(PVRSRV_SGXDEV_INFO *psDevInfo,
PVRSRV_DEVICE_NODE *psDeviceNode);
-
+#if defined(PDUMP)
+static
+PVRSRV_ERROR SGXResetPDump(PVRSRV_DEVICE_NODE *psDeviceNode);
+#endif
static IMG_VOID SGXCommandComplete(PVRSRV_DEVICE_NODE *psDeviceNode)
{
#if defined(SUPPORT_SGX_HWPERF)
psDevInfo->psKernelHWPerfCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelHWPerfCBMemInfo;
#endif
-#ifdef PVRSRV_USSE_EDM_STATUS_DEBUG
+ psDevInfo->psKernelTASigBufferMemInfo = psInitInfo->hKernelTASigBufferMemInfo;
+ psDevInfo->psKernel3DSigBufferMemInfo = psInitInfo->hKernel3DSigBufferMemInfo;
+#if defined(FIX_HW_BRN_29702)
+ psDevInfo->psKernelCFIMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelCFIMemInfo;
+#endif
+#if defined(FIX_HW_BRN_29823)
+ psDevInfo->psKernelDummyTermStreamMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelDummyTermStreamMemInfo;
+#endif
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
psDevInfo->psKernelEDMStatusBufferMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelEDMStatusBufferMemInfo;
-#endif
+#endif
#if defined(SGX_FEATURE_OVERLAPPED_SPM)
psDevInfo->psKernelTmpRgnHeaderMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelTmpRgnHeaderMemInfo;
#endif
#if defined(SGX_FEATURE_MP)
psDevInfo->ui32MasterClkGateStatusReg = psInitInfo->ui32MasterClkGateStatusReg;
psDevInfo->ui32MasterClkGateStatusMask = psInitInfo->ui32MasterClkGateStatusMask;
+ psDevInfo->ui32MasterClkGateStatus2Reg = psInitInfo->ui32MasterClkGateStatus2Reg;
+ psDevInfo->ui32MasterClkGateStatus2Mask = psInitInfo->ui32MasterClkGateStatus2Mask;
#endif
- OSMemCopy(&psDevInfo->asSGXDevData, &psInitInfo->asInitDevData, sizeof(psDevInfo->asSGXDevData));
+ OSMemCopy(&psDevInfo->asSGXDevData, &psInitInfo->asInitDevData, sizeof(psDevInfo->asSGXDevData));
return PVRSRV_OK;
case SGX_INIT_OP_WRITE_HW_REG:
{
OSWriteHWReg(psDevInfo->pvRegsBaseKM, psComm->sWriteHWReg.ui32Offset, psComm->sWriteHWReg.ui32Value);
- PDUMPREG(psComm->sWriteHWReg.ui32Offset, psComm->sWriteHWReg.ui32Value);
+ PDUMPCOMMENT("SGXRunScript: Write HW reg operation");
+ PDUMPREG(SGX_PDUMPREG_NAME, psComm->sWriteHWReg.ui32Offset, psComm->sWriteHWReg.ui32Value);
break;
}
#if defined(PDUMP)
case SGX_INIT_OP_PDUMP_HW_REG:
{
- PDUMPREG(psComm->sPDumpHWReg.ui32Offset, psComm->sPDumpHWReg.ui32Value);
+ PDUMPCOMMENT("SGXRunScript: Dump HW reg operation");
+ PDUMPREG(SGX_PDUMPREG_NAME, psComm->sPDumpHWReg.ui32Offset, psComm->sPDumpHWReg.ui32Value);
break;
}
#endif
default:
{
PVR_DPF((PVR_DBG_ERROR,"SGXRunScript: PC %d: Illegal command: %d", ui32PC, psComm->eOp));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION;
}
}
}
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION;
+}
+
+#ifdef PLAT_TI81xx
+//Function to configure PLL clocks. Only required for TI814x. For other devices its taken care in u-boot.
+void PLL_Clocks_Config(UWORD32 Base_Address,UWORD32 OSC_FREQ,UWORD32 N,UWORD32 M,UWORD32 M2,UWORD32 CLKCTRL_VAL)
+{
+ UWORD32 m2nval,mn2val,read_clkctrl,clk_out,ref_clk,clkout_dco = 0;
+ m2nval = (M2<<16) | N;
+ mn2val = M;
+ WR_MEM_32((Base_Address+M2NDIV ),m2nval);
+ msleep(100);
+ WR_MEM_32((Base_Address+MN2DIV ),mn2val);
+ msleep(100);
+ WR_MEM_32((Base_Address+TENABLEDIV),0x1);
+ msleep(100);
+ WR_MEM_32((Base_Address+TENABLEDIV),0x0);
+ msleep(100);
+ WR_MEM_32((Base_Address+TENABLE ),0x1);
+ msleep(100);
+ WR_MEM_32((Base_Address+TENABLE ),0x0);
+ msleep(100);
+ read_clkctrl = RD_MEM_32(Base_Address+CLKCTRL);
+ //configure the TINITZ(bit0) and CLKDCO BITS IF REQUIRED
+ WR_MEM_32(Base_Address+CLKCTRL,(read_clkctrl & 0xff7fe3ff) | CLKCTRL_VAL);
+ msleep(100);
+ read_clkctrl = RD_MEM_32(Base_Address+CLKCTRL);
+
+ // poll for the freq,phase lock to occur
+ while (( (RD_MEM_32(Base_Address+STATUS)) & 0x00000600) != 0x00000600);
+ //wait fot the clocks to get stabized
+ msleep(10);
}
+#endif
-PVRSRV_ERROR SGXInitialise(PVRSRV_SGXDEV_INFO *psDevInfo)
+
+
+PVRSRV_ERROR SGXInitialise(PVRSRV_SGXDEV_INFO *psDevInfo,
+ IMG_BOOL bHardwareRecovery)
{
PVRSRV_ERROR eError;
PVRSRV_KERNEL_MEM_INFO *psSGXHostCtlMemInfo = psDevInfo->psKernelSGXHostCtlMemInfo;
SGXMKIF_HOST_CTL *psSGXHostCtl = psSGXHostCtlMemInfo->pvLinAddrKM;
-#if defined(PDUMP)
static IMG_BOOL bFirstTime = IMG_TRUE;
+ void __iomem *pll_base;
+ void __iomem *div_base;
+#if defined(PDUMP)
+ IMG_BOOL bPDumpIsSuspended = PDumpIsSuspended();
#endif
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXInitialise: SGXRunScript (part 1) failed (%d)", eError));
- return (PVRSRV_ERROR_GENERIC);
+ return eError;
}
PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "End of SGX initialisation script part 1\n");
- SGXReset(psDevInfo, PDUMP_FLAGS_CONTINUOUS);
+ SGXReset(psDevInfo, bFirstTime || bHardwareRecovery, PDUMP_FLAGS_CONTINUOUS);
#if defined(EUR_CR_POWER)
#if defined(SGX531)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_POWER, 1);
- PDUMPREG(EUR_CR_POWER, 1);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_POWER, 1);
#else
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_POWER, 0);
- PDUMPREG(EUR_CR_POWER, 0);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_POWER, 0);
#endif
#endif
*psDevInfo->pui32KernelCCBEventKicker = 0;
#if defined(PDUMP)
- if (bFirstTime)
+ if (!bPDumpIsSuspended)
{
psDevInfo->ui32KernelCCBEventKickerDumpVal = 0;
PDUMPMEM(&psDevInfo->ui32KernelCCBEventKickerDumpVal,
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXInitialise: SGXRunScript (part 2) failed (%d)", eError));
- return (PVRSRV_ERROR_GENERIC);
+ return eError;
}
PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "End of SGX initialisation script part 2\n");
- if(cpu_is_omap3630())
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, 0xFF08, 0x80000000);
+#ifdef PLAT_TI81xx
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, 0xFF08, 0x80000000);//OCP Bypass mode
+ if(cpu_is_ti816x()) {
+ div_base = ioremap(SGX_TI81xx_CLK_DVDR_ADDR,0x100);
+ WR_MEM_32((div_base),0x2);
+ msleep(100);
+ iounmap (div_base);
+ } else {
+ div_base = ioremap(SGX_TI81xx_CLK_DVDR_ADDR,0x100);
+ WR_MEM_32((div_base),0x0);
+ pll_base = ioremap(SGX_PLL_BASE,0x100);
+ PLL_Clocks_Config(pll_base,OSC_0,19,800,4,ADPLLJ_CLKCRTL_HS2);
+ iounmap (div_base);
+ iounmap (pll_base);
+ }
+
+#else
+ if(cpu_is_omap3630())
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, 0xFF08, 0x80000000);//OCP Bypass mode
+#endif
+
+
+
+ psSGXHostCtl->ui32HostClock = OSClockus();
psSGXHostCtl->ui32InitStatus = 0;
#if defined(PDUMP)
offsetof(SGXMKIF_HOST_CTL, ui32InitStatus),
sizeof(IMG_UINT32), PDUMP_FLAGS_CONTINUOUS,
MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+ PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
+ "Initialise the microkernel\n");
#endif
+#if defined(SGX_FEATURE_MULTI_EVENT_KICK)
+ OSWriteMemoryBarrier();
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM,
+ SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0),
+ EUR_CR_EVENT_KICK2_NOW_MASK);
+#else
*psDevInfo->pui32KernelCCBEventKicker = (*psDevInfo->pui32KernelCCBEventKicker + 1) & 0xFF;
+ OSWriteMemoryBarrier();
OSWriteHWReg(psDevInfo->pvRegsBaseKM,
SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0),
EUR_CR_EVENT_KICK_NOW_MASK);
+#endif
+
+ OSMemoryBarrier();
#if defined(PDUMP)
-
-
-
-
- if (bFirstTime)
+ if (!bPDumpIsSuspended)
{
+#if defined(SGX_FEATURE_MULTI_EVENT_KICK)
+ PDUMPREG(SGX_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0), EUR_CR_EVENT_KICK2_NOW_MASK);
+#else
psDevInfo->ui32KernelCCBEventKickerDumpVal = 1;
PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
"First increment of the SGX event kicker value\n");
sizeof(IMG_UINT32),
PDUMP_FLAGS_CONTINUOUS,
MAKEUNIQUETAG(psDevInfo->psKernelCCBEventKickerMemInfo));
- PDUMPREG(SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0), EUR_CR_EVENT_KICK_NOW_MASK);
- bFirstTime = IMG_FALSE;
+ PDUMPREG(SGX_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0), EUR_CR_EVENT_KICK_NOW_MASK);
+#endif
}
#endif
WAIT_TRY_COUNT) != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXInitialise: Wait for uKernel initialisation failed"));
+ #if !defined(FIX_HW_BRN_23281)
PVR_DBG_BREAK;
+ #endif
return PVRSRV_ERROR_RETRY;
}
#endif
PVR_ASSERT(psDevInfo->psKernelCCBCtl->ui32ReadOffset == psDevInfo->psKernelCCBCtl->ui32WriteOffset);
+ bFirstTime = IMG_FALSE;
+
return PVRSRV_OK;
}
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXDeinitialise: SGXRunScript failed (%d)", eError));
- return (PVRSRV_ERROR_GENERIC);
+ return eError;
}
return PVRSRV_OK;
static PVRSRV_ERROR DevInitSGXPart1 (IMG_VOID *pvDeviceNode)
{
+ IMG_HANDLE hDevMemHeap = IMG_NULL;
PVRSRV_SGXDEV_INFO *psDevInfo;
IMG_HANDLE hKernelDevMemContext;
IMG_DEV_PHYADDR sPDDevPAddr;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap = psDeviceNode->sDevMemoryInfo.psDeviceMemoryHeap;
PVRSRV_ERROR eError;
- PDUMPCOMMENT("SGX Initialisation Part 1");
-
PDUMPCOMMENT("SGX Core Version Information: %s", SGX_CORE_FRIENDLY_NAME);
-#ifdef SGX_CORE_REV
- PDUMPCOMMENT("SGX Core Revision Information: %d", SGX_CORE_REV);
+
+ #if defined(SGX_FEATURE_MP)
+ PDUMPCOMMENT("SGX Multi-processor: %d cores", SGX_FEATURE_MP_CORE_COUNT);
+ #endif
+
+#if (SGX_CORE_REV == 0)
+ PDUMPCOMMENT("SGX Core Revision Information: head RTL");
#else
- PDUMPCOMMENT("SGX Core Revision Information: head rtl");
+ PDUMPCOMMENT("SGX Core Revision Information: %d", SGX_CORE_REV);
#endif
#if defined(SGX_FEATURE_SYSTEM_CACHE)
#endif
#endif
+ PDUMPCOMMENT("SGX Initialisation Part 1");
+
if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_SGXDEV_INFO),
for(i=0; i<psDeviceNode->sDevMemoryInfo.ui32HeapCount; i++)
{
- IMG_HANDLE hDevMemHeap;
-
switch(psDeviceMemoryHeap[i].DevMemHeapType)
{
case DEVICE_MEMORY_HEAP_KERNEL:
}
}
}
-
+#if defined(PDUMP)
+ if(hDevMemHeap)
+ {
+
+ psDevInfo->sMMUAttrib = *((BM_HEAP*)hDevMemHeap)->psMMUAttrib;
+ }
+#endif
eError = MMU_BIFResetPDAlloc(psDevInfo);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"DevInitSGX : Failed to alloc memory for BIF reset"));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
return PVRSRV_OK;
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXGetInfoForSrvinit: PVRSRVGetDeviceMemHeapsKM failed (%d)", eError));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
return eError;
eDefaultPowerState = PVRSRV_DEV_POWER_STATE_OFF;
eError = PVRSRVRegisterPowerDevice (psDeviceNode->sDevId.ui32DeviceIndex,
- SGXPrePowerState, SGXPostPowerState,
- SGXPreClockSpeedChange, SGXPostClockSpeedChange,
+ &SGXPrePowerState, &SGXPostPowerState,
+ &SGXPreClockSpeedChange, &SGXPostClockSpeedChange,
(IMG_HANDLE)psDeviceNode,
PVRSRV_DEV_POWER_STATE_OFF,
eDefaultPowerState);
}
#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
- eError = WorkaroundBRN22997Alloc(psDevInfo);
+ eError = WorkaroundBRN22997Alloc(psDeviceNode);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXInitialise : Failed to alloc memory for BRN22997 workaround"));
#endif
#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
- WorkaroundBRN22997Free(psDevInfo);
+ WorkaroundBRN22997Free(psDeviceNode);
#endif
MMU_BIFResetPDFree(psDevInfo);
-
DeinitDevInfo(psDevInfo);
if (psDeviceMemoryHeap != IMG_NULL)
{
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(DEVICE_MEMORY_HEAP_INFO) * SGX_MAX_HEAP_ID,
psDeviceMemoryHeap,
0);
}
-IMG_VOID SGXDumpDebugInfo (PVRSRV_DEVICE_NODE *psDeviceNode,
- IMG_BOOL bDumpSGXRegs)
+static IMG_VOID SGXDumpDebugReg (PVRSRV_SGXDEV_INFO *psDevInfo,
+ IMG_UINT32 ui32CoreNum,
+ IMG_CHAR *pszName,
+ IMG_UINT32 ui32RegAddr)
{
- IMG_UINT ui32RegVal;
- PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
+ IMG_UINT32 ui32RegVal;
+ ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, SGX_MP_CORE_SELECT(ui32RegAddr, ui32CoreNum));
+ PVR_LOG(("(P%u) %s%08X", ui32CoreNum, pszName, ui32RegVal));
+}
+
+static IMG_VOID SGXDumpDebugInfo (PVRSRV_SGXDEV_INFO *psDevInfo,
+ IMG_BOOL bDumpSGXRegs)
+{
+ IMG_UINT32 ui32CoreNum;
+
+ PVR_LOG(("SGX debug (%s)", PVRVERSION_STRING));
if (bDumpSGXRegs)
{
- PVR_DPF((PVR_DBG_ERROR,"SGX Register Base Address (Linear): 0x%08X", psDevInfo->pvRegsBaseKM));
- PVR_DPF((PVR_DBG_ERROR,"SGX Register Base Address (Physical): 0x%08X", psDevInfo->sRegsPhysBase));
+ PVR_DPF((PVR_DBG_ERROR,"SGX Register Base Address (Linear): 0x%08X", (IMG_UINTPTR_T)psDevInfo->pvRegsBaseKM));
+ PVR_DPF((PVR_DBG_ERROR,"SGX Register Base Address (Physical): 0x%08X", psDevInfo->sRegsPhysBase.uiAddr));
-
-
-
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS);
- if (ui32RegVal & (EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_MASK | EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_MASK))
+ for (ui32CoreNum = 0; ui32CoreNum < SGX_FEATURE_MP_CORE_COUNT; ui32CoreNum++)
{
- PVR_LOG(("DPM out of memory!!"));
+
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_EVENT_STATUS: ", EUR_CR_EVENT_STATUS);
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_EVENT_STATUS2: ", EUR_CR_EVENT_STATUS2);
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_BIF_CTRL: ", EUR_CR_BIF_CTRL);
+ #if defined(EUR_CR_BIF_BANK0)
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_BIF_BANK0: ", EUR_CR_BIF_BANK0);
+ #endif
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_BIF_INT_STAT: ", EUR_CR_BIF_INT_STAT);
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_BIF_FAULT: ", EUR_CR_BIF_FAULT);
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_BIF_MEM_REQ_STAT: ", EUR_CR_BIF_MEM_REQ_STAT);
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_CLKGATECTL: ", EUR_CR_CLKGATECTL);
+ #if defined(EUR_CR_PDS_PC_BASE)
+ SGXDumpDebugReg(psDevInfo, ui32CoreNum, "EUR_CR_PDS_PC_BASE: ", EUR_CR_PDS_PC_BASE);
+ #endif
}
- PVR_LOG(("EUR_CR_EVENT_STATUS: %x", ui32RegVal));
+ }
+
+
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS2);
- PVR_LOG(("EUR_CR_EVENT_STATUS2: %x", ui32RegVal));
+ QueueDumpDebugInfo();
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL);
- PVR_LOG(("EUR_CR_BIF_CTRL: %x", ui32RegVal));
+ {
+
- #if defined(EUR_CR_BIF_BANK0)
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK0);
- PVR_LOG(("EUR_CR_BIF_BANK0: %x", ui32RegVal));
- #endif
+ IMG_UINT32 *pui32HostCtlBuffer = (IMG_UINT32 *)psDevInfo->psSGXHostCtl;
+ IMG_UINT32 ui32LoopCounter;
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_INT_STAT);
- PVR_LOG(("EUR_CR_BIF_INT_STAT: %x", ui32RegVal));
+ PVR_LOG(("SGX Host control:"));
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_FAULT);
- PVR_LOG(("EUR_CR_BIF_FAULT: %x", ui32RegVal));
+ for (ui32LoopCounter = 0;
+ ui32LoopCounter < sizeof(*psDevInfo->psSGXHostCtl) / sizeof(*pui32HostCtlBuffer);
+ ui32LoopCounter += 4)
+ {
+ PVR_LOG(("\t(HC-%X) 0x%08X 0x%08X 0x%08X 0x%08X", ui32LoopCounter * sizeof(*pui32HostCtlBuffer),
+ pui32HostCtlBuffer[ui32LoopCounter + 0], pui32HostCtlBuffer[ui32LoopCounter + 1],
+ pui32HostCtlBuffer[ui32LoopCounter + 2], pui32HostCtlBuffer[ui32LoopCounter + 3]));
+ }
+ }
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_MEM_REQ_STAT);
- PVR_LOG(("EUR_CR_BIF_MEM_REQ_STAT: %x", ui32RegVal));
+ {
+
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_CLKGATECTL);
- PVR_LOG(("EUR_CR_CLKGATECTL: %x", ui32RegVal));
+ IMG_UINT32 *pui32TA3DCtlBuffer = psDevInfo->psKernelSGXTA3DCtlMemInfo->pvLinAddrKM;
+ IMG_UINT32 ui32LoopCounter;
- #if defined(EUR_CR_PDS_PC_BASE)
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_PDS_PC_BASE);
- PVR_LOG(("EUR_CR_PDS_PC_BASE: %x", ui32RegVal));
- #endif
+ PVR_LOG(("SGX TA/3D control:"));
-
+ for (ui32LoopCounter = 0;
+ ui32LoopCounter < psDevInfo->psKernelSGXTA3DCtlMemInfo->ui32AllocSize / sizeof(*pui32TA3DCtlBuffer);
+ ui32LoopCounter += 4)
+ {
+ PVR_LOG(("\t(T3C-%X) 0x%08X 0x%08X 0x%08X 0x%08X", ui32LoopCounter * sizeof(*pui32TA3DCtlBuffer),
+ pui32TA3DCtlBuffer[ui32LoopCounter + 0], pui32TA3DCtlBuffer[ui32LoopCounter + 1],
+ pui32TA3DCtlBuffer[ui32LoopCounter + 2], pui32TA3DCtlBuffer[ui32LoopCounter + 3]));
+ }
}
-
+
#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
{
IMG_UINT32 *pui32MKTraceBuffer = psDevInfo->psKernelEDMStatusBufferMemInfo->pvLinAddrKM;
ui32WriteOffset = *pui32MKTraceBuffer;
pui32MKTraceBuffer++;
- PVR_LOG(("Last SGX microkernel status code: 0x%x", ui32LastStatusCode));
-
+ PVR_LOG(("Last SGX microkernel status code: %08X", ui32LastStatusCode));
+
#if defined(PVRSRV_DUMP_MK_TRACE)
{
IMG_UINT32 ui32LoopCounter;
-
+
for (ui32LoopCounter = 0;
ui32LoopCounter < SGXMK_TRACE_BUFFER_SIZE;
ui32LoopCounter++)
IMG_UINT32 *pui32BufPtr;
pui32BufPtr = pui32MKTraceBuffer +
(((ui32WriteOffset + ui32LoopCounter) % SGXMK_TRACE_BUFFER_SIZE) * 4);
- PVR_LOG(("(MKT%u) %08X %08X %08X %08X", ui32LoopCounter,
+ PVR_LOG(("\t(MKT-%X) %08X %08X %08X %08X", ui32LoopCounter,
pui32BufPtr[2], pui32BufPtr[3], pui32BufPtr[1], pui32BufPtr[0]));
}
}
{
- IMG_UINT32 *pui32HostCtlBuffer = (IMG_UINT32 *)psDevInfo->psSGXHostCtl;
- IMG_UINT32 ui32LoopCounter;
-
- PVR_LOG(("SGX Host control:"));
+ PVR_LOG(("SGX Kernel CCB WO:0x%X RO:0x%X",
+ psDevInfo->psKernelCCBCtl->ui32WriteOffset,
+ psDevInfo->psKernelCCBCtl->ui32ReadOffset));
- for (ui32LoopCounter = 0;
- ui32LoopCounter < sizeof(*psDevInfo->psSGXHostCtl) / sizeof(*pui32HostCtlBuffer);
- ui32LoopCounter += 4)
+ #if defined(PVRSRV_DUMP_KERNEL_CCB)
{
- PVR_LOG(("\t0x%X: 0x%08X 0x%08X 0x%08X 0x%08X", ui32LoopCounter * sizeof(*pui32HostCtlBuffer),
- pui32HostCtlBuffer[ui32LoopCounter + 0], pui32HostCtlBuffer[ui32LoopCounter + 1],
- pui32HostCtlBuffer[ui32LoopCounter + 2], pui32HostCtlBuffer[ui32LoopCounter + 3]));
- }
- }
-
- {
-
-
- IMG_UINT32 *pui32TA3DCtlBuffer = psDevInfo->psKernelSGXTA3DCtlMemInfo->pvLinAddrKM;
- IMG_UINT32 ui32LoopCounter;
+ IMG_UINT32 ui32LoopCounter;
- PVR_LOG(("SGX TA/3D control:"));
+ for (ui32LoopCounter = 0;
+ ui32LoopCounter < sizeof(psDevInfo->psKernelCCB->asCommands) /
+ sizeof(psDevInfo->psKernelCCB->asCommands[0]);
+ ui32LoopCounter++)
+ {
+ SGXMKIF_COMMAND *psCommand = &psDevInfo->psKernelCCB->asCommands[ui32LoopCounter];
- for (ui32LoopCounter = 0;
- ui32LoopCounter < psDevInfo->psKernelSGXTA3DCtlMemInfo->ui32AllocSize / sizeof(*pui32TA3DCtlBuffer);
- ui32LoopCounter += 4)
- {
- PVR_LOG(("\t0x%X: 0x%08X 0x%08X 0x%08X 0x%08X", ui32LoopCounter * sizeof(*pui32TA3DCtlBuffer),
- pui32TA3DCtlBuffer[ui32LoopCounter + 0], pui32TA3DCtlBuffer[ui32LoopCounter + 1],
- pui32TA3DCtlBuffer[ui32LoopCounter + 2], pui32TA3DCtlBuffer[ui32LoopCounter + 3]));
+ PVR_LOG(("\t(KCCB-%X) %08X %08X - %08X %08X %08X %08X", ui32LoopCounter,
+ psCommand->ui32ServiceAddress, psCommand->ui32CacheControl,
+ psCommand->ui32Data[0], psCommand->ui32Data[1],
+ psCommand->ui32Data[2], psCommand->ui32Data[3]));
+ }
}
+ #endif
}
-
- QueueDumpDebugInfo();
}
PVR_LOG(("HWRecoveryResetSGX: SGX Hardware Recovery triggered"));
- SGXDumpDebugInfo(psDeviceNode, IMG_TRUE);
+ SGXDumpDebugInfo(psDeviceNode->pvDevice, IMG_TRUE);
PDUMPSUSPEND();
- eError = SGXInitialise(psDevInfo);
+#if defined(FIX_HW_BRN_23281)
+
+ for (eError = PVRSRV_ERROR_RETRY; eError == PVRSRV_ERROR_RETRY;)
+#endif
+ {
+ eError = SGXInitialise(psDevInfo, IMG_TRUE);
+ }
+
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"HWRecoveryResetSGX: SGXInitialise failed (%d)", eError));
static IMG_UINT32 ui32EDMTasks = 0;
static IMG_UINT32 ui32LockupCounter = 0;
static IMG_UINT32 ui32NumResets = 0;
+#if defined(FIX_HW_BRN_31093)
+ static IMG_BOOL bBRN31093Inval = IMG_FALSE;
+#endif
IMG_UINT32 ui32CurrentEDMTasks;
IMG_BOOL bLockup = IMG_FALSE;
IMG_BOOL bPoweredDown;
#if defined(NO_HARDWARE)
bPoweredDown = IMG_TRUE;
#else
- bPoweredDown = SGXIsDevicePowered(psDeviceNode) ? IMG_FALSE : IMG_TRUE;
+ bPoweredDown = (SGXIsDevicePowered(psDeviceNode)) ? IMG_FALSE : IMG_TRUE;
#endif
if (bPoweredDown)
{
ui32LockupCounter = 0;
+ #if defined(FIX_HW_BRN_31093)
+ bBRN31093Inval = IMG_FALSE;
+ #endif
}
else
{
if (ui32LockupCounter == 3)
{
ui32LockupCounter = 0;
- PVR_DPF((PVR_DBG_ERROR, "SGXOSTimer() detected SGX lockup (0x%x tasks)", ui32EDMTasks));
+
+ #if defined(FIX_HW_BRN_31093)
+ if (bBRN31093Inval == IMG_FALSE)
+ {
+
+ #if defined(FIX_HW_BRN_29997)
+ IMG_UINT32 ui32BIFCtrl;
+
+ ui32BIFCtrl = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_PAUSE_MASK);
+
+ OSWaitus(200 * 1000000 / psDevInfo->ui32CoreClockSpeed);
+ #endif
+
+ bBRN31093Inval = IMG_TRUE;
+
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL_INVAL, EUR_CR_BIF_CTRL_INVAL_PTE_MASK);
+
+ OSWaitus(200 * 1000000 / psDevInfo->ui32CoreClockSpeed);
+
+ #if defined(FIX_HW_BRN_29997)
+
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl);
+ #endif
+ }
+ else
+ #endif
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SGXOSTimer() detected SGX lockup (0x%x tasks)", ui32EDMTasks));
- bLockup = IMG_TRUE;
+ bLockup = IMG_TRUE;
+ }
}
}
else
{
+ #if defined(FIX_HW_BRN_31093)
+ bBRN31093Inval = IMG_FALSE;
+ #endif
ui32LockupCounter = 0;
ui32EDMTasks = ui32CurrentEDMTasks;
ui32NumResets = psDevInfo->ui32NumResets;
{
IMG_UINT32 ui32EventStatus, ui32EventEnable;
IMG_UINT32 ui32EventClear = 0;
+#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
+ IMG_UINT32 ui32EventStatus2, ui32EventEnable2;
+#endif
+ IMG_UINT32 ui32EventClear2 = 0;
PVRSRV_DEVICE_NODE *psDeviceNode;
PVRSRV_SGXDEV_INFO *psDevInfo;
ui32EventEnable = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_ENABLE);
+ ui32EventStatus &= ui32EventEnable;
- gui32EventStatusServicesByISR = ui32EventStatus;
+#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
+ ui32EventStatus2 = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS2);
+ ui32EventEnable2 = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_ENABLE2);
+
+
+ ui32EventStatus2 &= ui32EventEnable2;
+#endif
- ui32EventStatus &= ui32EventEnable;
if (ui32EventStatus & EUR_CR_EVENT_STATUS_SW_EVENT_MASK)
{
ui32EventClear |= EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK;
}
- if (ui32EventClear)
+#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
+ if (ui32EventStatus2 & EUR_CR_EVENT_STATUS2_DATA_BREAKPOINT_UNTRAPPED_MASK)
+ {
+ ui32EventClear2 |= EUR_CR_EVENT_HOST_CLEAR2_DATA_BREAKPOINT_UNTRAPPED_MASK;
+ }
+
+ if (ui32EventStatus2 & EUR_CR_EVENT_STATUS2_DATA_BREAKPOINT_TRAPPED_MASK)
+ {
+ ui32EventClear2 |= EUR_CR_EVENT_HOST_CLEAR2_DATA_BREAKPOINT_TRAPPED_MASK;
+ }
+#endif
+
+ if (ui32EventClear || ui32EventClear2)
{
bInterruptProcessed = IMG_TRUE;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR, ui32EventClear);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR2, ui32EventClear2);
}
}
}
-IMG_VOID SGX_MISRHandler (IMG_VOID *pvData)
+static IMG_VOID SGX_MISRHandler (IMG_VOID *pvData)
{
PVRSRV_DEVICE_NODE *psDeviceNode = (PVRSRV_DEVICE_NODE *)pvData;
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
#endif
+
+#if defined(SUPPORT_MEMORY_TILING)
+PVRSRV_ERROR SGX_AllocMemTilingRange(PVRSRV_DEVICE_NODE *psDeviceNode,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32TilingStride,
+ IMG_UINT32 *pui32RangeIndex)
+{
+#if defined(SGX_FEATURE_BIF_WIDE_TILING_AND_4K_ADDRESS)
+ PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
+ IMG_UINT32 i;
+ IMG_UINT32 ui32Start;
+ IMG_UINT32 ui32End;
+ IMG_UINT32 ui32Offset;
+ IMG_UINT32 ui32Val;
+
+
+ for(i=0; i<10; i++)
+ {
+ if((psDevInfo->ui32MemTilingUsage & (1U << i)) == 0)
+ {
+
+ psDevInfo->ui32MemTilingUsage |= 1U << i;
+
+ *pui32RangeIndex = i;
+ goto RangeAllocated;
+ }
+ }
+
+ PVR_DPF((PVR_DBG_ERROR,"SGX_AllocMemTilingRange: all tiling ranges in use"));
+ return PVRSRV_ERROR_EXCEEDED_HW_LIMITS;
+
+RangeAllocated:
+ ui32Offset = EUR_CR_BIF_TILE0 + (i<<2);
+
+ ui32Start = psMemInfo->sDevVAddr.uiAddr;
+ ui32End = ui32Start + psMemInfo->ui32AllocSize + SGX_MMU_PAGE_SIZE - 1;
+
+ ui32Val = ((ui32TilingStride << EUR_CR_BIF_TILE0_CFG_SHIFT) & EUR_CR_BIF_TILE0_CFG_MASK)
+ | (((ui32End>>20) << EUR_CR_BIF_TILE0_MAX_ADDRESS_SHIFT) & EUR_CR_BIF_TILE0_MAX_ADDRESS_MASK)
+ | (((ui32Start>>20) << EUR_CR_BIF_TILE0_MIN_ADDRESS_SHIFT) & EUR_CR_BIF_TILE0_MIN_ADDRESS_MASK)
+ | (0x8 << EUR_CR_BIF_TILE0_CFG_SHIFT);
+
+
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32Offset, ui32Val);
+ PDUMPREG(SGX_PDUMPREG_NAME, ui32Offset, ui32Val);
+
+ ui32Offset = EUR_CR_BIF_TILE0_ADDR_EXT + (i<<2);
+
+ ui32Val = (((ui32End>>12) << EUR_CR_BIF_TILE0_ADDR_EXT_MAX_SHIFT) & EUR_CR_BIF_TILE0_ADDR_EXT_MAX_MASK)
+ | (((ui32Start>>12) << EUR_CR_BIF_TILE0_ADDR_EXT_MIN_SHIFT) & EUR_CR_BIF_TILE0_ADDR_EXT_MIN_MASK);
+
+
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32Offset, ui32Val);
+ PDUMPREG(SGX_PDUMPREG_NAME, ui32Offset, ui32Val);
+
+ return PVRSRV_OK;
+#else
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+ PVR_UNREFERENCED_PARAMETER(psMemInfo);
+ PVR_UNREFERENCED_PARAMETER(ui32TilingStride);
+ PVR_UNREFERENCED_PARAMETER(pui32RangeIndex);
+
+ PVR_DPF((PVR_DBG_ERROR,"SGX_AllocMemTilingRange: device does not support memory tiling"));
+ return PVRSRV_ERROR_NOT_SUPPORTED;
+#endif
+}
+
+PVRSRV_ERROR SGX_FreeMemTilingRange(PVRSRV_DEVICE_NODE *psDeviceNode,
+ IMG_UINT32 ui32RangeIndex)
+{
+#if defined(SGX_FEATURE_BIF_WIDE_TILING_AND_4K_ADDRESS)
+ PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
+ IMG_UINT32 ui32Offset;
+ IMG_UINT32 ui32Val;
+
+ if(ui32RangeIndex >= 10)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SGX_FreeMemTilingRange: invalid Range index "));
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+
+ psDevInfo->ui32MemTilingUsage &= ~(1<<ui32RangeIndex);
+
+
+ ui32Offset = EUR_CR_BIF_TILE0 + (ui32RangeIndex<<2);
+ ui32Val = 0;
+
+
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32Offset, ui32Val);
+ PDUMPREG(SGX_PDUMPREG_NAME, ui32Offset, ui32Val);
+
+ return PVRSRV_OK;
+#else
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+ PVR_UNREFERENCED_PARAMETER(ui32RangeIndex);
+
+ PVR_DPF((PVR_DBG_ERROR,"SGX_FreeMemTilingRange: device does not support memory tiling"));
+ return PVRSRV_ERROR_NOT_SUPPORTED;
+#endif
+}
+#endif
+
+
PVRSRV_ERROR SGXRegisterDevice (PVRSRV_DEVICE_NODE *psDeviceNode)
{
DEVICE_MEMORY_INFO *psDevMemoryInfo;
DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
- psDeviceNode->sDevId.eDeviceType = DEV_DEVICE_TYPE;
- psDeviceNode->sDevId.eDeviceClass = DEV_DEVICE_CLASS;
+ psDeviceNode->sDevId.eDeviceType = DEV_DEVICE_TYPE;
+ psDeviceNode->sDevId.eDeviceClass = DEV_DEVICE_CLASS;
+#if defined(PDUMP)
+ {
+
+ SGX_DEVICE_MAP *psSGXDeviceMemMap;
+ SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE_SGX,
+ (IMG_VOID**)&psSGXDeviceMemMap);
- psDeviceNode->pfnInitDevice = DevInitSGXPart1;
- psDeviceNode->pfnDeInitDevice = DevDeInitSGX;
+ psDeviceNode->sDevId.pszPDumpDevName = psSGXDeviceMemMap->pszPDumpDevName;
+ PVR_ASSERT(psDeviceNode->sDevId.pszPDumpDevName != IMG_NULL);
+ }
+
+ psDeviceNode->sDevId.pszPDumpRegName = SGX_PDUMPREG_NAME;
+#endif
- psDeviceNode->pfnInitDeviceCompatCheck = SGXDevInitCompatCheck;
+ psDeviceNode->pfnInitDevice = &DevInitSGXPart1;
+ psDeviceNode->pfnDeInitDevice = &DevDeInitSGX;
+ psDeviceNode->pfnInitDeviceCompatCheck = &SGXDevInitCompatCheck;
+#if defined(PDUMP)
+ psDeviceNode->pfnPDumpInitDevice = &SGXResetPDump;
+ psDeviceNode->pfnMMUGetContextID = &MMU_GetPDumpContextID;
+#endif
- psDeviceNode->pfnMMUInitialise = MMU_Initialise;
- psDeviceNode->pfnMMUFinalise = MMU_Finalise;
- psDeviceNode->pfnMMUInsertHeap = MMU_InsertHeap;
- psDeviceNode->pfnMMUCreate = MMU_Create;
- psDeviceNode->pfnMMUDelete = MMU_Delete;
- psDeviceNode->pfnMMUAlloc = MMU_Alloc;
- psDeviceNode->pfnMMUFree = MMU_Free;
- psDeviceNode->pfnMMUMapPages = MMU_MapPages;
- psDeviceNode->pfnMMUMapShadow = MMU_MapShadow;
- psDeviceNode->pfnMMUUnmapPages = MMU_UnmapPages;
- psDeviceNode->pfnMMUMapScatter = MMU_MapScatter;
- psDeviceNode->pfnMMUGetPhysPageAddr = MMU_GetPhysPageAddr;
- psDeviceNode->pfnMMUGetPDDevPAddr = MMU_GetPDDevPAddr;
+ psDeviceNode->pfnMMUInitialise = &MMU_Initialise;
+ psDeviceNode->pfnMMUFinalise = &MMU_Finalise;
+ psDeviceNode->pfnMMUInsertHeap = &MMU_InsertHeap;
+ psDeviceNode->pfnMMUCreate = &MMU_Create;
+ psDeviceNode->pfnMMUDelete = &MMU_Delete;
+ psDeviceNode->pfnMMUAlloc = &MMU_Alloc;
+ psDeviceNode->pfnMMUFree = &MMU_Free;
+ psDeviceNode->pfnMMUMapPages = &MMU_MapPages;
+ psDeviceNode->pfnMMUMapShadow = &MMU_MapShadow;
+ psDeviceNode->pfnMMUUnmapPages = &MMU_UnmapPages;
+ psDeviceNode->pfnMMUMapScatter = &MMU_MapScatter;
+ psDeviceNode->pfnMMUGetPhysPageAddr = &MMU_GetPhysPageAddr;
+ psDeviceNode->pfnMMUGetPDDevPAddr = &MMU_GetPDDevPAddr;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ psDeviceNode->pfnMMUIsHeapShared = &MMU_IsHeapShared;
+#endif
#if defined (SYS_USING_INTERRUPTS)
psDeviceNode->pfnDeviceMISR = SGX_MISRHandler;
#endif
+#if defined(SUPPORT_MEMORY_TILING)
+ psDeviceNode->pfnAllocMemTilingRange = SGX_AllocMemTilingRange;
+ psDeviceNode->pfnFreeMemTilingRange = SGX_FreeMemTilingRange;
+#endif
+
- psDeviceNode->pfnDeviceCommandComplete = SGXCommandComplete;
+ psDeviceNode->pfnDeviceCommandComplete = &SGXCommandComplete;
psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_PIXELSHADER_HEAP_ID);
psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_PIXELSHADER_HEAP_BASE;
- psDeviceMemoryHeap->ui32HeapSize = SGX_PIXELSHADER_HEAP_SIZE;
+
+
+
+
+
+
+ psDeviceMemoryHeap->ui32HeapSize = ((10 << SGX_USE_CODE_SEGMENT_RANGE_BITS) - 0x00001000);
+ PVR_ASSERT(psDeviceMemoryHeap->ui32HeapSize <= SGX_PIXELSHADER_HEAP_SIZE);
psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
| PVRSRV_MEM_RAM_BACKED_ALLOCATION
| PVRSRV_HAP_SINGLE_PROCESS;
psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_VERTEXSHADER_HEAP_ID);
psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_VERTEXSHADER_HEAP_BASE;
- psDeviceMemoryHeap->ui32HeapSize = SGX_VERTEXSHADER_HEAP_SIZE;
+
+ psDeviceMemoryHeap->ui32HeapSize = ((4 << SGX_USE_CODE_SEGMENT_RANGE_BITS) - 0x00001000);
+ PVR_ASSERT(psDeviceMemoryHeap->ui32HeapSize <= SGX_VERTEXSHADER_HEAP_SIZE);
psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
| PVRSRV_MEM_RAM_BACKED_ALLOCATION
| PVRSRV_HAP_SINGLE_PROCESS;
psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
-#else
+ #else
psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
-#endif
+ #endif
+
psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
return PVRSRV_OK;
}
+#if defined(PDUMP)
+static
+PVRSRV_ERROR SGXResetPDump(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)(psDeviceNode->pvDevice);
+ psDevInfo->psKernelCCBInfo->ui32CCBDumpWOff = 0;
+ PVR_DPF((PVR_DBG_MESSAGE, "Reset pdump CCB write offset."));
+
+ return PVRSRV_OK;
+}
+#endif
+
+
IMG_EXPORT
PVRSRV_ERROR SGXGetClientInfoKM(IMG_HANDLE hDevCookie,
SGX_CLIENT_INFO* psClientInfo)
psDevInfo->ui32ClientRefCount++;
-#if defined(PDUMP)
-
- psDevInfo->psKernelCCBInfo->ui32CCBDumpWOff = 0;
-#endif
psClientInfo->ui32ProcessID = OSGetCurrentProcessIDKM();
}
-IMG_VOID SGXPanic(PVRSRV_DEVICE_NODE *psDeviceNode)
+IMG_VOID SGXPanic(PVRSRV_SGXDEV_INFO *psDevInfo)
{
PVR_LOG(("SGX panic"));
- SGXDumpDebugInfo(psDeviceNode, IMG_FALSE);
+ SGXDumpDebugInfo(psDevInfo, IMG_FALSE);
OSPanic();
}
IMG_BOOL bCheckCoreRev;
- const IMG_UINT32 aui32CoreRevExceptions[] =
- {
- 0x10100, 0x10101
- };
+ const IMG_UINT32 aui32CoreRevExceptions[] =
+ {
+ 0x10100, 0x10101
+ };
const IMG_UINT32 ui32NumCoreExceptions = sizeof(aui32CoreRevExceptions) / (2*sizeof(IMG_UINT32));
IMG_UINT i;
#endif
if ( (psDevInfo->ui32ClientBuildOptions & ui32BuildOptionsMismatch) != 0)
{
PVR_LOG(("(FAIL) SGXInit: Mismatch in client-side and KM driver build options; "
- "extra options present in client-side driver: (0x%lx). Please check sgx_options.h",
+ "extra options present in client-side driver: (0x%x). Please check sgx_options.h",
psDevInfo->ui32ClientBuildOptions & ui32BuildOptionsMismatch ));
}
if ( (ui32BuildOptions & ui32BuildOptionsMismatch) != 0)
{
PVR_LOG(("(FAIL) SGXInit: Mismatch in client-side and KM driver build options; "
- "extra options present in KM: (0x%lx). Please check sgx_options.h",
+ "extra options present in KM: (0x%x). Please check sgx_options.h",
ui32BuildOptions & ui32BuildOptionsMismatch ));
}
eError = PVRSRV_ERROR_BUILD_MISMATCH;
PVRVERSION_BRANCH) ) ||
(psSGXFeatures->ui32DDKBuild != PVRVERSION_BUILD) )
{
- PVR_LOG(("(FAIL) SGXInit: Incompatible driver DDK revision (%ld)/device DDK revision (%ld).",
+ PVR_LOG(("(FAIL) SGXInit: Incompatible driver DDK revision (%d)/device DDK revision (%d).",
PVRVERSION_BUILD, psSGXFeatures->ui32DDKBuild));
eError = PVRSRV_ERROR_DDK_VERSION_MISMATCH;
PVR_DBG_BREAK;
}
else
{
- PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: driver DDK (%ld) and device DDK (%ld) match. [ OK ]",
+ PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: driver DDK (%d) and device DDK (%d) match. [ OK ]",
PVRVERSION_BUILD, psSGXFeatures->ui32DDKBuild));
}
{
- PVR_LOG(("SGXInit: HW core rev (%lx) check skipped.",
+ PVR_LOG(("SGXInit: HW core rev (%x) check skipped.",
psSGXFeatures->ui32CoreRev));
}
else
if( (psSGXFeatures->ui32CoreRev==aui32CoreRevExceptions[i]) &&
(psSGXFeatures->ui32CoreRevSW==aui32CoreRevExceptions[i+1]) )
{
- PVR_LOG(("SGXInit: HW core rev (%lx), SW core rev (%lx) check skipped.",
+ PVR_LOG(("SGXInit: HW core rev (%x), SW core rev (%x) check skipped.",
psSGXFeatures->ui32CoreRev,
psSGXFeatures->ui32CoreRevSW));
bCheckCoreRev = IMG_FALSE;
{
if (psSGXFeatures->ui32CoreRev != psSGXFeatures->ui32CoreRevSW)
{
- PVR_LOG(("(FAIL) SGXInit: Incompatible HW core rev (%lx) and SW core rev (%lx).",
+ PVR_LOG(("(FAIL) SGXInit: Incompatible HW core rev (%x) and SW core rev (%x).",
psSGXFeatures->ui32CoreRev, psSGXFeatures->ui32CoreRevSW));
eError = PVRSRV_ERROR_BUILD_MISMATCH;
goto chk_exit;
}
else
{
- PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: HW core rev (%lx) and SW core rev (%lx) match. [ OK ]",
+ PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: HW core rev (%x) and SW core rev (%x) match. [ OK ]",
psSGXFeatures->ui32CoreRev, psSGXFeatures->ui32CoreRevSW));
}
}
if ( ((SGX_BUILD_OPTIONS) & ui32BuildOptionsMismatch) != 0)
{
PVR_LOG(("(FAIL) SGXInit: Mismatch in driver and microkernel build options; "
- "extra options present in driver: (0x%lx). Please check sgx_options.h",
+ "extra options present in driver: (0x%x). Please check sgx_options.h",
(SGX_BUILD_OPTIONS) & ui32BuildOptionsMismatch ));
}
if ( (ui32BuildOptions & ui32BuildOptionsMismatch) != 0)
{
PVR_LOG(("(FAIL) SGXInit: Mismatch in driver and microkernel build options; "
- "extra options present in microkernel: (0x%lx). Please check sgx_options.h",
+ "extra options present in microkernel: (0x%x). Please check sgx_options.h",
ui32BuildOptions & ui32BuildOptionsMismatch ));
}
eError = PVRSRV_ERROR_BUILD_MISMATCH;
sCommandData.ui32Data[1] = psMemInfo->sDevVAddr.uiAddr;
+ PDUMPCOMMENT("Microkernel kick for SGXGetMiscInfo");
eError = SGXScheduleCCBCommandKM(psDeviceNode,
SGXMKIF_CMD_GETMISCINFO,
&sCommandData,
PVRSRV_DEVICE_NODE *psDeviceNode,
IMG_HANDLE hDevMemContext)
{
+ PVRSRV_ERROR eError;
PPVRSRV_KERNEL_MEM_INFO psMemInfo = psDevInfo->psKernelSGXMiscMemInfo;
IMG_UINT32 *pui32MiscInfoFlags = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->ui32MiscInfoFlags;
switch(psMiscInfo->eRequest)
{
-#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
+#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
case SGX_MISC_INFO_REQUEST_SET_BREAKPOINT:
{
- IMG_UINT32 ui32RegOffset;
- IMG_UINT32 ui32RegVal;
- IMG_UINT32 ui32BaseRegOffset;
- IMG_UINT32 ui32BaseRegVal;
- IMG_UINT32 ui32MaskRegOffset;
- IMG_UINT32 ui32MaskRegVal;
-
- switch(psMiscInfo->uData.sSGXBreakpointInfo.ui32BPIndex)
- {
- case 0:
- ui32RegOffset = EUR_CR_BREAKPOINT0;
- ui32BaseRegOffset = EUR_CR_BREAKPOINT0_BASE;
- ui32MaskRegOffset = EUR_CR_BREAKPOINT0_MASK;
- break;
- case 1:
- ui32RegOffset = EUR_CR_BREAKPOINT1;
- ui32BaseRegOffset = EUR_CR_BREAKPOINT1_BASE;
- ui32MaskRegOffset = EUR_CR_BREAKPOINT1_MASK;
- break;
- case 2:
- ui32RegOffset = EUR_CR_BREAKPOINT2;
- ui32BaseRegOffset = EUR_CR_BREAKPOINT2_BASE;
- ui32MaskRegOffset = EUR_CR_BREAKPOINT2_MASK;
- break;
- case 3:
- ui32RegOffset = EUR_CR_BREAKPOINT3;
- ui32BaseRegOffset = EUR_CR_BREAKPOINT3_BASE;
- ui32MaskRegOffset = EUR_CR_BREAKPOINT3_MASK;
- break;
- default:
- PVR_DPF((PVR_DBG_ERROR,"SGXGetMiscInfoKM: SGX_MISC_INFO_REQUEST_SET_BREAKPOINT invalid BP idx %d", psMiscInfo->uData.sSGXBreakpointInfo.ui32BPIndex));
- return PVRSRV_ERROR_INVALID_PARAMS;
- }
+ IMG_UINT32 ui32MaskDM;
+ IMG_UINT32 ui32CtrlWEnable;
+ IMG_UINT32 ui32CtrlREnable;
+ IMG_UINT32 ui32CtrlTrapEnable;
+ IMG_UINT32 ui32RegVal;
+ IMG_UINT32 ui32StartRegVal;
+ IMG_UINT32 ui32EndRegVal;
+ SGXMKIF_COMMAND sCommandData;
if(psMiscInfo->uData.sSGXBreakpointInfo.bBPEnable)
{
IMG_DEV_VIRTADDR sBPDevVAddr = psMiscInfo->uData.sSGXBreakpointInfo.sBPDevVAddr;
+ IMG_DEV_VIRTADDR sBPDevVAddrEnd = psMiscInfo->uData.sSGXBreakpointInfo.sBPDevVAddrEnd;
- ui32MaskRegVal = EUR_CR_BREAKPOINT0_MASK_REGION_MASK | EUR_CR_BREAKPOINT0_MASK_DM_MASK;
+ ui32StartRegVal = sBPDevVAddr.uiAddr & EUR_CR_BREAKPOINT0_START_ADDRESS_MASK;
+ ui32EndRegVal = sBPDevVAddrEnd.uiAddr & EUR_CR_BREAKPOINT0_END_ADDRESS_MASK;
-
- ui32BaseRegVal = sBPDevVAddr.uiAddr & EUR_CR_BREAKPOINT0_BASE_ADDRESS_MASK;
+ ui32MaskDM = psMiscInfo->uData.sSGXBreakpointInfo.ui32DataMasterMask;
+ ui32CtrlWEnable = psMiscInfo->uData.sSGXBreakpointInfo.bWrite;
+ ui32CtrlREnable = psMiscInfo->uData.sSGXBreakpointInfo.bRead;
+ ui32CtrlTrapEnable = psMiscInfo->uData.sSGXBreakpointInfo.bTrapped;
- ui32RegVal = EUR_CR_BREAKPOINT0_CTRL_WENABLE_MASK
- | EUR_CR_BREAKPOINT0_CTRL_WENABLE_MASK
- | EUR_CR_BREAKPOINT0_CTRL_TRAPENABLE_MASK;
+ ui32RegVal = ((ui32MaskDM<<EUR_CR_BREAKPOINT0_MASK_DM_SHIFT) & EUR_CR_BREAKPOINT0_MASK_DM_MASK) |
+ ((ui32CtrlWEnable<<EUR_CR_BREAKPOINT0_CTRL_WENABLE_SHIFT) & EUR_CR_BREAKPOINT0_CTRL_WENABLE_MASK) |
+ ((ui32CtrlREnable<<EUR_CR_BREAKPOINT0_CTRL_RENABLE_SHIFT) & EUR_CR_BREAKPOINT0_CTRL_RENABLE_MASK) |
+ ((ui32CtrlTrapEnable<<EUR_CR_BREAKPOINT0_CTRL_TRAPENABLE_SHIFT) & EUR_CR_BREAKPOINT0_CTRL_TRAPENABLE_MASK);
}
else
{
- ui32RegVal = ui32BaseRegVal = ui32MaskRegVal = 0;
+ ui32RegVal = ui32StartRegVal = ui32EndRegVal = 0;
}
+ sCommandData.ui32Data[0] = psMiscInfo->uData.sSGXBreakpointInfo.ui32BPIndex;
+ sCommandData.ui32Data[1] = ui32StartRegVal;
+ sCommandData.ui32Data[2] = ui32EndRegVal;
+ sCommandData.ui32Data[3] = ui32RegVal;
+
+ psDevInfo->psSGXHostCtl->ui32BPSetClearSignal = 0;
+
+ PDUMPCOMMENT("Microkernel kick for setting a data breakpoint");
+ eError = SGXScheduleCCBCommandKM(psDeviceNode,
+ SGXMKIF_CMD_DATABREAKPOINT,
+ &sCommandData,
+ KERNEL_ID,
+ 0);
+
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SGXGetMiscInfoKM: SGXScheduleCCBCommandKM failed."));
+ return eError;
+ }
+
+#if defined(NO_HARDWARE)
+ psDevInfo->psSGXHostCtl->ui32BPSetClearSignal = 0;
+#else
+ {
+ IMG_BOOL bExit;
+
+ bExit = IMG_FALSE;
+ LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+ {
+ if (psDevInfo->psSGXHostCtl->ui32BPSetClearSignal != 0)
+ {
+ bExit = IMG_TRUE;
+
+ psDevInfo->psSGXHostCtl->ui32BPSetClearSignal = 0;
+ break;
+ }
+ } END_LOOP_UNTIL_TIMEOUT();
+
+
+ if (!bExit)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SGXGetMiscInfoKM: Timeout occurred waiting BP set/clear"));
+ return PVRSRV_ERROR_TIMEOUT;
+ }
+ }
+#endif
+
+ return PVRSRV_OK;
+ }
+
+ case SGX_MISC_INFO_REQUEST_WAIT_FOR_BREAKPOINT:
+ {
+ PDUMPCOMMENT("Wait for data breakpoint hit");
+
+#if defined(NO_HARDWARE) && defined(PDUMP)
+ {
+ PDUMPREGPOL(SGX_PDUMPREG_NAME,
+ EUR_CR_EVENT_STATUS2,
+ EUR_CR_EVENT_STATUS2_DATA_BREAKPOINT_TRAPPED_MASK,
+ EUR_CR_EVENT_STATUS2_DATA_BREAKPOINT_TRAPPED_MASK);
+
+ PDUMPREG(SGX_PDUMPREG_NAME,
+ EUR_CR_EVENT_HOST_CLEAR2,
+ EUR_CR_EVENT_HOST_CLEAR2_DATA_BREAKPOINT_TRAPPED_MASK);
+
+ PDUMPCOMMENT("Breakpoint detected. Wait a bit to show that pipeline stops in simulation");
+ PDUMPIDL(2000);
+
+ PDUMPCOMMENT("Now we can resume");
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BREAKPOINT_TRAP, EUR_CR_BREAKPOINT_TRAP_WRNOTIFY_MASK | EUR_CR_BREAKPOINT_TRAP_CONTINUE_MASK);
+ }
+#else
+ {
+
+ }
+#endif
+ return PVRSRV_OK;
+ }
+
+ case SGX_MISC_INFO_REQUEST_POLL_BREAKPOINT:
+ {
+
+
+
+
+
+
+
+#if !defined(NO_HARDWARE)
+ IMG_BOOL bTrappedBPMaster;
+ IMG_BOOL abTrappedBPPerCore[SGX_FEATURE_MP_CORE_COUNT];
+ IMG_UINT32 ui32CoreNum, ui32TrappedBPCoreNum;
+ IMG_BOOL bTrappedBPAny;
+
+ ui32TrappedBPCoreNum = 0;
+ bTrappedBPMaster = !!(EUR_CR_MASTER_BREAKPOINT_TRAPPED_MASK & OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BREAKPOINT));
+ bTrappedBPAny = bTrappedBPMaster;
+ for (ui32CoreNum = 0; ui32CoreNum < SGX_FEATURE_MP_CORE_COUNT; ui32CoreNum++)
+ {
+ abTrappedBPPerCore[ui32CoreNum] = !!(EUR_CR_BREAKPOINT_TRAPPED_MASK & OSReadHWReg(psDevInfo->pvRegsBaseKM, SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT, ui32CoreNum)));
+ if (abTrappedBPPerCore[ui32CoreNum])
+ {
+ bTrappedBPAny = IMG_TRUE;
+ ui32TrappedBPCoreNum = ui32CoreNum;
+ }
+ }
+
+ psMiscInfo->uData.sSGXBreakpointInfo.bTrappedBP = bTrappedBPAny;
+
+ if (psMiscInfo->uData.sSGXBreakpointInfo.bTrappedBP)
+ {
+ IMG_UINT32 ui32Info0, ui32Info1;
+
+ ui32Info0 = OSReadHWReg(psDevInfo->pvRegsBaseKM, bTrappedBPMaster?EUR_CR_MASTER_BREAKPOINT_TRAP_INFO0:SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT_TRAP_INFO0, ui32TrappedBPCoreNum));
+ ui32Info1 = OSReadHWReg(psDevInfo->pvRegsBaseKM, bTrappedBPMaster?EUR_CR_MASTER_BREAKPOINT_TRAP_INFO1:SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT_TRAP_INFO1, ui32TrappedBPCoreNum));
+
+ psMiscInfo->uData.sSGXBreakpointInfo.ui32BPIndex = (ui32Info1 & EUR_CR_BREAKPOINT_TRAP_INFO1_NUMBER_MASK) >> EUR_CR_BREAKPOINT_TRAP_INFO1_NUMBER_SHIFT;
+ psMiscInfo->uData.sSGXBreakpointInfo.sTrappedBPDevVAddr.uiAddr = ui32Info0 & EUR_CR_BREAKPOINT_TRAP_INFO0_ADDRESS_MASK;
+ psMiscInfo->uData.sSGXBreakpointInfo.ui32TrappedBPBurstLength = (ui32Info1 & EUR_CR_BREAKPOINT_TRAP_INFO1_SIZE_MASK) >> EUR_CR_BREAKPOINT_TRAP_INFO1_SIZE_SHIFT;
+ psMiscInfo->uData.sSGXBreakpointInfo.bTrappedBPRead = !!(ui32Info1 & EUR_CR_BREAKPOINT_TRAP_INFO1_RNW_MASK);
+ psMiscInfo->uData.sSGXBreakpointInfo.ui32TrappedBPDataMaster = (ui32Info1 & EUR_CR_BREAKPOINT_TRAP_INFO1_DATA_MASTER_MASK) >> EUR_CR_BREAKPOINT_TRAP_INFO1_DATA_MASTER_SHIFT;
+ psMiscInfo->uData.sSGXBreakpointInfo.ui32TrappedBPTag = (ui32Info1 & EUR_CR_BREAKPOINT_TRAP_INFO1_TAG_MASK) >> EUR_CR_BREAKPOINT_TRAP_INFO1_TAG_SHIFT;
+ psMiscInfo->uData.sSGXBreakpointInfo.ui32CoreNum = bTrappedBPMaster?65535:ui32TrappedBPCoreNum;
+ }
+#endif
+ return PVRSRV_OK;
+ }
+
+ case SGX_MISC_INFO_REQUEST_RESUME_BREAKPOINT:
+ {
+#if !defined(NO_HARDWARE)
+ IMG_UINT32 ui32CoreNum;
+ IMG_BOOL bMaster;
+ IMG_UINT32 ui32OldSeqNum, ui32NewSeqNum;
+ ui32CoreNum = psMiscInfo->uData.sSGXBreakpointInfo.ui32CoreNum;
+ bMaster = ui32CoreNum > SGX_FEATURE_MP_CORE_COUNT;
+ if (bMaster)
+ {
+
+
+ ui32OldSeqNum = 0x1c & OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BREAKPOINT);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BREAKPOINT_TRAP, EUR_CR_MASTER_BREAKPOINT_TRAP_WRNOTIFY_MASK | EUR_CR_MASTER_BREAKPOINT_TRAP_CONTINUE_MASK);
+ do
+ {
+ ui32NewSeqNum = 0x1c & OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BREAKPOINT);
+ }
+ while (ui32OldSeqNum == ui32NewSeqNum);
+ }
+ else
+ {
+
+ ui32OldSeqNum = 0x1c & OSReadHWReg(psDevInfo->pvRegsBaseKM, SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT, ui32CoreNum));
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT_TRAP, ui32CoreNum), EUR_CR_BREAKPOINT_TRAP_WRNOTIFY_MASK | EUR_CR_BREAKPOINT_TRAP_CONTINUE_MASK);
+ do
+ {
+ ui32NewSeqNum = 0x1c & OSReadHWReg(psDevInfo->pvRegsBaseKM, SGX_MP_CORE_SELECT(EUR_CR_BREAKPOINT, ui32CoreNum));
+ }
+ while (ui32OldSeqNum == ui32NewSeqNum);
+ }
+#endif
return PVRSRV_OK;
}
#endif
return PVRSRV_OK;
}
+ case SGX_MISC_INFO_REQUEST_ACTIVEPOWER:
+ {
+ psMiscInfo->uData.sActivePower.ui32NumActivePowerEvents = psDevInfo->psSGXHostCtl->ui32NumActivePowerEvents;
+ return PVRSRV_OK;
+ }
+
+ case SGX_MISC_INFO_REQUEST_LOCKUPS:
+ {
+#if defined(SUPPORT_HW_RECOVERY)
+ psMiscInfo->uData.sLockups.ui32uKernelDetectedLockups = psDevInfo->psSGXHostCtl->ui32uKernelDetectedLockups;
+ psMiscInfo->uData.sLockups.ui32HostDetectedLockups = psDevInfo->psSGXHostCtl->ui32HostDetectedLockups;
+#else
+ psMiscInfo->uData.sLockups.ui32uKernelDetectedLockups = 0;
+ psMiscInfo->uData.sLockups.ui32HostDetectedLockups = 0;
+#endif
+ return PVRSRV_OK;
+ }
+
+ case SGX_MISC_INFO_REQUEST_SPM:
+ {
+
+ return PVRSRV_OK;
+ }
+
case SGX_MISC_INFO_REQUEST_SGXREV:
{
- PVRSRV_ERROR eError;
PVRSRV_SGX_MISCINFO_FEATURES *psSGXFeatures;
-
eError = SGXGetMiscInfoUkernel(psDevInfo, psDeviceNode);
if(eError != PVRSRV_OK)
{
psMiscInfo->uData.sSGXFeatures = *psSGXFeatures;
- PVR_DPF((PVR_DBG_MESSAGE, "SGXGetMiscInfoKM: Core 0x%lx, sw ID 0x%lx, sw Rev 0x%lx\n",
+ PVR_DPF((PVR_DBG_MESSAGE, "SGXGetMiscInfoKM: Core 0x%x, sw ID 0x%x, sw Rev 0x%x\n",
psSGXFeatures->ui32CoreRev,
psSGXFeatures->ui32CoreIdSW,
psSGXFeatures->ui32CoreRevSW));
- PVR_DPF((PVR_DBG_MESSAGE, "SGXGetMiscInfoKM: DDK version 0x%lx, DDK build 0x%lx\n",
+ PVR_DPF((PVR_DBG_MESSAGE, "SGXGetMiscInfoKM: DDK version 0x%x, DDK build 0x%x\n",
psSGXFeatures->ui32DDKVersion,
psSGXFeatures->ui32DDKBuild));
psSGXFeatures->ui32BuildOptions = (SGX_BUILD_OPTIONS);
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
+
+ psSGXFeatures->sDevVAEDMStatusBuffer = psDevInfo->psKernelEDMStatusBufferMemInfo->sDevVAddr;
+ psSGXFeatures->pvEDMStatusBuffer = psDevInfo->psKernelEDMStatusBufferMemInfo->pvLinAddrKM;
+#endif
+
psMiscInfo->uData.sSGXFeatures = *psSGXFeatures;
return PVRSRV_OK;
#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
case SGX_MISC_INFO_REQUEST_MEMREAD:
+ case SGX_MISC_INFO_REQUEST_MEMCOPY:
{
PVRSRV_ERROR eError;
- PPVRSRV_KERNEL_MEM_INFO psMemInfo = psDevInfo->psKernelSGXMiscMemInfo;
PVRSRV_SGX_MISCINFO_FEATURES *psSGXFeatures;
- PVRSRV_SGX_MISCINFO_MEMREAD *psSGXMemReadData;
+ PVRSRV_SGX_MISCINFO_MEMACCESS *psSGXMemSrc;
+ PVRSRV_SGX_MISCINFO_MEMACCESS *psSGXMemDest;
- psSGXMemReadData = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXMemReadData;
-
-
- *pui32MiscInfoFlags |= PVRSRV_USSE_MISCINFO_MEMREAD;
+ {
+
+ *pui32MiscInfoFlags |= PVRSRV_USSE_MISCINFO_MEMREAD;
+ psSGXMemSrc = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXMemAccessSrc;
-
- if(psMiscInfo->hDevMemContext != IMG_NULL)
- {
- SGXGetMMUPDAddrKM( (IMG_HANDLE)psDeviceNode, hDevMemContext, &psSGXMemReadData->sPDDevPAddr);
+ if(psMiscInfo->sDevVAddrSrc.uiAddr != 0)
+ {
+ psSGXMemSrc->sDevVAddr = psMiscInfo->sDevVAddrSrc;
+ }
+ else
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
}
- else
- {
- return PVRSRV_ERROR_INVALID_PARAMS;
+
+ if( psMiscInfo->eRequest == SGX_MISC_INFO_REQUEST_MEMCOPY)
+ {
+
+ *pui32MiscInfoFlags |= PVRSRV_USSE_MISCINFO_MEMWRITE;
+ psSGXMemDest = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXMemAccessDest;
+
+ if(psMiscInfo->sDevVAddrDest.uiAddr != 0)
+ {
+ psSGXMemDest->sDevVAddr = psMiscInfo->sDevVAddrDest;
+ }
+ else
+ {
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
}
- if(psMiscInfo->sDevVAddr.uiAddr != 0)
+ if(psMiscInfo->hDevMemContext != IMG_NULL)
{
- psSGXMemReadData->sDevVAddr = psMiscInfo->sDevVAddr;
+ SGXGetMMUPDAddrKM( (IMG_HANDLE)psDeviceNode, hDevMemContext, &psSGXMemSrc->sPDDevPAddr);
+
+
+ psSGXMemDest->sPDDevPAddr = psSGXMemSrc->sPDDevPAddr;
}
else
{
}
psSGXFeatures = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXFeatures;
-#if !defined SGX_FEATURE_MULTIPLE_MEM_CONTEXTS
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
if(*pui32MiscInfoFlags & PVRSRV_USSE_MISCINFO_MEMREAD_FAIL)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_MISCINFO;
}
#endif
}
#endif
-#ifdef SUPPORT_SGX_HWPERF
+#if defined(SUPPORT_SGX_HWPERF)
case SGX_MISC_INFO_REQUEST_SET_HWPERF_STATUS:
{
- SGXMKIF_HWPERF_CB *psHWPerfCB = psDevInfo->psKernelHWPerfCBMemInfo->pvLinAddrKM;
- IMG_UINT ui32MatchingFlags;
+ PVRSRV_SGX_MISCINFO_SET_HWPERF_STATUS *psSetHWPerfStatus = &psMiscInfo->uData.sSetHWPerfStatus;
+ const IMG_UINT32 ui32ValidFlags = PVRSRV_SGX_HWPERF_STATUS_RESET_COUNTERS |
+ PVRSRV_SGX_HWPERF_STATUS_GRAPHICS_ON |
+ PVRSRV_SGX_HWPERF_STATUS_PERIODIC_ON |
+ PVRSRV_SGX_HWPERF_STATUS_MK_EXECUTION_ON;
+ SGXMKIF_COMMAND sCommandData = {0};
- if ((psMiscInfo->uData.ui32NewHWPerfStatus & ~(PVRSRV_SGX_HWPERF_GRAPHICS_ON | PVRSRV_SGX_HWPERF_MK_EXECUTION_ON)) != 0)
+ if ((psSetHWPerfStatus->ui32NewHWPerfStatus & ~ui32ValidFlags) != 0)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
-
- ui32MatchingFlags = psMiscInfo->uData.ui32NewHWPerfStatus & psDevInfo->psSGXHostCtl->ui32HWPerfFlags;
- if((ui32MatchingFlags & PVRSRV_SGX_HWPERF_GRAPHICS_ON) == 0UL)
- {
- psHWPerfCB->ui32OrdinalGRAPHICS = 0xffffffff;
- }
- if((ui32MatchingFlags & PVRSRV_SGX_HWPERF_MK_EXECUTION_ON) == 0UL)
- {
- psHWPerfCB->ui32OrdinalMK_EXECUTION = 0xffffffffUL;
- }
+ #if defined(PDUMP)
+ PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
+ "SGX ukernel HWPerf status %u\n",
+ psSetHWPerfStatus->ui32NewHWPerfStatus);
+ #endif
- psDevInfo->psSGXHostCtl->ui32HWPerfFlags = psMiscInfo->uData.ui32NewHWPerfStatus;
+ #if defined(SGX_FEATURE_EXTENDED_PERF_COUNTERS)
+ OSMemCopy(&psDevInfo->psSGXHostCtl->aui32PerfGroup[0],
+ &psSetHWPerfStatus->aui32PerfGroup[0],
+ sizeof(psDevInfo->psSGXHostCtl->aui32PerfGroup));
+ OSMemCopy(&psDevInfo->psSGXHostCtl->aui32PerfBit[0],
+ &psSetHWPerfStatus->aui32PerfBit[0],
+ sizeof(psDevInfo->psSGXHostCtl->aui32PerfBit));
+ #if defined(PDUMP)
+ PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+ offsetof(SGXMKIF_HOST_CTL, aui32PerfGroup),
+ sizeof(psDevInfo->psSGXHostCtl->aui32PerfGroup),
+ PDUMP_FLAGS_CONTINUOUS,
+ MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+ PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+ offsetof(SGXMKIF_HOST_CTL, aui32PerfBit),
+ sizeof(psDevInfo->psSGXHostCtl->aui32PerfBit),
+ PDUMP_FLAGS_CONTINUOUS,
+ MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+ #endif
+ #else
+ psDevInfo->psSGXHostCtl->ui32PerfGroup = psSetHWPerfStatus->ui32PerfGroup;
#if defined(PDUMP)
- PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "SGX ukernel HWPerf status %lu\n",
- psDevInfo->psSGXHostCtl->ui32HWPerfFlags);
PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
- offsetof(SGXMKIF_HOST_CTL, ui32HWPerfFlags),
- sizeof(psDevInfo->psSGXHostCtl->ui32HWPerfFlags), PDUMP_FLAGS_CONTINUOUS,
+ offsetof(SGXMKIF_HOST_CTL, ui32PerfGroup),
+ sizeof(psDevInfo->psSGXHostCtl->ui32PerfGroup),
+ PDUMP_FLAGS_CONTINUOUS,
MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
#endif
+ #endif
- return PVRSRV_OK;
- }
- case SGX_MISC_INFO_REQUEST_HWPERF_CB_ON:
- {
-
- SGXMKIF_HWPERF_CB *psHWPerfCB = psDevInfo->psKernelHWPerfCBMemInfo->pvLinAddrKM;
- psHWPerfCB->ui32OrdinalGRAPHICS = 0xffffffffUL;
-
- psDevInfo->psSGXHostCtl->ui32HWPerfFlags |= PVRSRV_SGX_HWPERF_GRAPHICS_ON;
- return PVRSRV_OK;
- }
- case SGX_MISC_INFO_REQUEST_HWPERF_CB_OFF:
- {
-
- psDevInfo->psSGXHostCtl->ui32HWPerfFlags = 0;
- return PVRSRV_OK;
- }
- case SGX_MISC_INFO_REQUEST_HWPERF_RETRIEVE_CB:
- {
- SGX_MISC_INFO_HWPERF_RETRIEVE_CB *psRetrieve = &psMiscInfo->uData.sRetrieveCB;
- SGXMKIF_HWPERF_CB *psHWPerfCB = psDevInfo->psKernelHWPerfCBMemInfo->pvLinAddrKM;
- IMG_UINT i;
-
- for (i = 0; psHWPerfCB->ui32Woff != psHWPerfCB->ui32Roff && i < psRetrieve->ui32ArraySize; i++)
- {
- SGXMKIF_HWPERF_CB_ENTRY *psData = &psHWPerfCB->psHWPerfCBData[psHWPerfCB->ui32Roff];
-
-
-
- psRetrieve->psHWPerfData[i].ui32FrameNo = psData->ui32FrameNo;
- psRetrieve->psHWPerfData[i].ui32Type = (psData->ui32Type & PVRSRV_SGX_HWPERF_TYPE_OP_MASK);
- psRetrieve->psHWPerfData[i].ui32StartTime = psData->ui32Time;
- psRetrieve->psHWPerfData[i].ui32StartTimeWraps = psData->ui32TimeWraps;
- psRetrieve->psHWPerfData[i].ui32EndTime = psData->ui32Time;
- psRetrieve->psHWPerfData[i].ui32EndTimeWraps = psData->ui32TimeWraps;
- psRetrieve->psHWPerfData[i].ui32ClockSpeed = psDevInfo->ui32CoreClockSpeed;
- psRetrieve->psHWPerfData[i].ui32TimeMax = psDevInfo->ui32uKernelTimerClock;
- psHWPerfCB->ui32Roff = (psHWPerfCB->ui32Roff + 1) & (SGXMKIF_HWPERF_CB_SIZE - 1);
- }
- psRetrieve->ui32DataCount = i;
- psRetrieve->ui32Time = OSClockus();
- return PVRSRV_OK;
+ sCommandData.ui32Data[0] = psSetHWPerfStatus->ui32NewHWPerfStatus;
+ eError = SGXScheduleCCBCommandKM(psDeviceNode,
+ SGXMKIF_CMD_SETHWPERFSTATUS,
+ &sCommandData,
+ KERNEL_ID,
+ 0);
+ return eError;
}
#endif
+
case SGX_MISC_INFO_DUMP_DEBUG_INFO:
{
PVR_LOG(("User requested SGX debug info"));
+
-
- SGXDumpDebugInfo(psDeviceNode, IMG_FALSE);
+ SGXDumpDebugInfo(psDeviceNode->pvDevice, IMG_FALSE);
return PVRSRV_OK;
}
{
PVR_LOG(("User requested SGX panic"));
- SGXPanic(psDeviceNode);
+ SGXPanic(psDeviceNode->pvDevice);
return PVRSRV_OK;
}
}
}
-#if defined(SUPPORT_SGX_HWPERF)
-IMG_EXPORT
-PVRSRV_ERROR SGXReadDiffCountersKM(IMG_HANDLE hDevHandle,
- IMG_UINT32 ui32Reg,
- IMG_UINT32 *pui32Old,
- IMG_BOOL bNew,
- IMG_UINT32 ui32New,
- IMG_UINT32 ui32NewReset,
- IMG_UINT32 ui32CountersReg,
- IMG_UINT32 ui32Reg2,
- IMG_BOOL *pbActive,
- PVRSRV_SGXDEV_DIFF_INFO *psDiffs)
-{
- PVRSRV_ERROR eError;
- SYS_DATA *psSysData;
- PVRSRV_POWER_DEV *psPowerDevice;
- IMG_BOOL bPowered = IMG_FALSE;
- PVRSRV_DEVICE_NODE *psDeviceNode = hDevHandle;
- PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
-
-
- if(bNew)
- {
- psDevInfo->ui32HWGroupRequested = ui32New;
- }
- psDevInfo->ui32HWReset |= ui32NewReset;
-
-
- eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
- if (eError != PVRSRV_OK)
- {
- return eError;
- }
-
- SysAcquireData(&psSysData);
-
-
- psPowerDevice = (PVRSRV_POWER_DEV*)
- List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
- MatchPowerDeviceIndex_AnyVaCb,
- psDeviceNode->sDevId.ui32DeviceIndex);
-
- if (psPowerDevice)
- {
- bPowered = (IMG_BOOL)(psPowerDevice->eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON);
- }
-
-
-
- *pbActive = bPowered;
-
-
-
- {
- IMG_UINT32 ui32rval = 0;
-
-
- if(bPowered)
- {
- IMG_UINT32 i;
-
-
- *pui32Old = OSReadHWReg(psDevInfo->pvRegsBaseKM, ui32Reg);
-
- for (i = 0; i < PVRSRV_SGX_DIFF_NUM_COUNTERS; ++i)
- {
- psDiffs->aui32Counters[i] = OSReadHWReg(psDevInfo->pvRegsBaseKM, ui32CountersReg + (i * 4));
- }
-
- if(ui32Reg2)
- {
- ui32rval = OSReadHWReg(psDevInfo->pvRegsBaseKM, ui32Reg2);
- }
-
-
-
- if (psDevInfo->ui32HWGroupRequested != *pui32Old)
- {
-
- if(psDevInfo->ui32HWReset != 0)
- {
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32Reg, psDevInfo->ui32HWGroupRequested | psDevInfo->ui32HWReset);
- psDevInfo->ui32HWReset = 0;
- }
-
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32Reg, psDevInfo->ui32HWGroupRequested);
- }
- }
-
- psDiffs->ui32Time[0] = OSClockus();
- psDiffs->ui32Time[1] = psDevInfo->psSGXHostCtl->ui32TimeWraps;
- psDiffs->ui32Time[2] = ui32rval;
-
- psDiffs->ui32Marker[0] = psDevInfo->ui32KickTACounter;
- psDiffs->ui32Marker[1] = psDevInfo->ui32KickTARenderCounter;
- }
-
-
- PVRSRVPowerUnlock(KERNEL_ID);
-
- SGXTestActivePowerEvent(psDeviceNode, KERNEL_ID);
-
- return eError;
-}
-
IMG_EXPORT
PVRSRV_ERROR SGXReadHWPerfCBKM(IMG_HANDLE hDevHandle,
psClientHWPerfEntry[i].ui32FrameNo = psMKPerfEntry->ui32FrameNo;
psClientHWPerfEntry[i].ui32Type = psMKPerfEntry->ui32Type;
psClientHWPerfEntry[i].ui32Ordinal = psMKPerfEntry->ui32Ordinal;
+ psClientHWPerfEntry[i].ui32Info = psMKPerfEntry->ui32Info;
psClientHWPerfEntry[i].ui32Clocksx16 = SGXConvertTimeStamp(psDevInfo,
psMKPerfEntry->ui32TimeWraps,
psMKPerfEntry->ui32Time);
- OSMemCopy(&psClientHWPerfEntry[i].ui32Counters[0],
- &psMKPerfEntry->ui32Counters[0],
+ OSMemCopy(&psClientHWPerfEntry[i].ui32Counters[0][0],
+ &psMKPerfEntry->ui32Counters[0][0],
sizeof(psMKPerfEntry->ui32Counters));
psHWPerfCB->ui32Roff = (psHWPerfCB->ui32Roff + 1) & (SGXMKIF_HWPERF_CB_SIZE - 1);
return eError;
}
-#else
-#endif
PVRSRV_KERNEL_MEM_INFO *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *) psCCBKick->hCCBKernelMemInfo;
SGXMKIF_CMDTA_SHARED *psTACmd;
IMG_UINT32 i;
-#if defined(SUPPORT_SGX_HWPERF)
- PVRSRV_DEVICE_NODE *psDeviceNode;
- PVRSRV_SGXDEV_INFO *psDevInfo;
-
- psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevHandle;
- psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
-#endif
-
-#if defined(SUPPORT_SGX_HWPERF)
- if (psCCBKick->bKickRender)
- {
- ++psDevInfo->ui32KickTARenderCounter;
- }
- ++psDevInfo->ui32KickTACounter;
-#endif
if (!CCB_OFFSET_IS_VALID(SGXMKIF_CMDTA_SHARED, psCCBMemInfo, psCCBKick, ui32CCBOffset))
{
(psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
{
- PDUMPCOMMENT("Init RT ROpsComplete\r\n", i);
+ PDUMPCOMMENT("Init RT ROpsComplete\r\n");
PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
psSyncInfo->psSyncDataMemInfoKM,
offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
(psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
{
- PDUMPCOMMENT("Init RT ROpsComplete\r\n", i);
+ PDUMPCOMMENT("Init RT ROpsComplete\r\n");
PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
psSyncInfo->psSyncDataMemInfoKM,
offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
{
-#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
- PDUMPCOMMENT("Modify TA status value in TA cmd\r\n");
- PDUMPMEM(&psCCBKick->asTAStatusUpdate[i].ui32LastStatusUpdateDumpVal,
- psCCBMemInfo,
- psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, sCtlTAStatusInfo[i].ui32StatusValue),
- sizeof(IMG_UINT32),
- 0,
- MAKEUNIQUETAG(psCCBMemInfo));
-#else
+#if !defined(SUPPORT_SGX_NEW_STATUS_VALS)
psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
PDUMPCOMMENT("Modify TA status value in TA cmd\r\n");
PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
psCCBMemInfo,
- psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, sCtlTAStatusInfo[i].ui32StatusValue),
+ psCCBKick->ui32CCBDumpWOff + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtlTAStatusInfo[i].ui32StatusValue),
sizeof(IMG_UINT32),
0,
MAKEUNIQUETAG(psCCBMemInfo));
for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
{
-#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
- PDUMPCOMMENT("Modify 3D status value in TA cmd\r\n");
- PDUMPMEM(&psCCBKick->as3DStatusUpdate[i].ui32LastStatusUpdateDumpVal,
- psCCBMemInfo,
- psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, sCtl3DStatusInfo[i].ui32StatusValue),
- sizeof(IMG_UINT32),
- 0,
- MAKEUNIQUETAG(psCCBMemInfo));
-#else
+#if !defined(SUPPORT_SGX_NEW_STATUS_VALS)
psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
PDUMPCOMMENT("Modify 3D status value in TA cmd\r\n");
PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
psCCBMemInfo,
- psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, sCtl3DStatusInfo[i].ui32StatusValue),
+ psCCBKick->ui32CCBDumpWOff + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtl3DStatusInfo[i].ui32StatusValue),
sizeof(IMG_UINT32),
0,
MAKEUNIQUETAG(psCCBMemInfo));
#endif
IMG_UINT32 ui32ActivePowManSampleRate;
SGX_TIMING_INFORMATION *psSGXTimingInfo;
-
+
#if defined(SGX_DYNAMIC_TIMING_INFO)
psSGXTimingInfo = &sSGXTimingInfo;
{
PVRSRV_ERROR eError;
IMG_UINT32 ui32OlduKernelFreq;
-
+
if (psDevInfo->hTimer != IMG_NULL)
{
ui32OlduKernelFreq = psDevInfo->ui32CoreClockSpeed / psDevInfo->ui32uKernelTimerClock;
psSGXTimingInfo->ui32uKernelFreq / psSGXTimingInfo->ui32HWRecoveryFreq;
}
#endif
-
+
psDevInfo->ui32CoreClockSpeed = psSGXTimingInfo->ui32CoreClockSpeed;
psDevInfo->ui32uKernelTimerClock = psSGXTimingInfo->ui32CoreClockSpeed / psSGXTimingInfo->ui32uKernelFreq;
-
ui32ActivePowManSampleRate += 1;
}
else
{
- ui32ActivePowManSampleRate = 0;
+ ui32ActivePowManSampleRate = 0;
}
-
+
psDevInfo->psSGXHostCtl->ui32ActivePowManSampleRate = ui32ActivePowManSampleRate;
#if defined(PDUMP)
PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
{
#if defined(SUPPORT_HW_RECOVERY)
PVRSRV_ERROR eError;
-
+
eError = OSEnableTimer(psDevInfo->hTimer);
if (eError != PVRSRV_OK)
{
}
-static IMG_VOID SGXPollForClockGating (PVRSRV_SGXDEV_INFO *psDevInfo,
+static IMG_VOID SGXPollForClockGating (PVRSRV_SGXDEV_INFO *psDevInfo,
IMG_UINT32 ui32Register,
IMG_UINT32 ui32RegisterValue,
IMG_CHAR *pszComment)
#if !defined(NO_HARDWARE)
PVR_ASSERT(psDevInfo != IMG_NULL);
-
+
if (PollForValueKM((IMG_UINT32 *)psDevInfo->pvRegsBaseKM + (ui32Register >> 2),
0,
MAX_HW_TIME_US/WAIT_TRY_COUNT,
WAIT_TRY_COUNT) != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: %s failed.", pszComment));
+ PVR_DPF((PVR_DBG_ERROR,"SGXPollForClockGating: %s failed.", pszComment));
+ PVR_DBG_BREAK;
}
#endif
-
- PDUMPCOMMENT(pszComment);
- PDUMPREGPOL(ui32Register, 0, ui32RegisterValue);
+
+ PDUMPCOMMENT("%s", pszComment);
+ PDUMPREGPOL(SGX_PDUMPREG_NAME, ui32Register, 0, ui32RegisterValue);
}
-PVRSRV_ERROR SGXPrePowerState (IMG_HANDLE hDevHandle,
- PVRSRV_DEV_POWER_STATE eNewPowerState,
+PVRSRV_ERROR SGXPrePowerState (IMG_HANDLE hDevHandle,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
PVRSRV_DEV_POWER_STATE eCurrentPowerState)
{
if ((eNewPowerState != eCurrentPowerState) &&
IMG_UINT32 ui32PowerCmd, ui32CompleteStatus;
SGXMKIF_COMMAND sCommand = {0};
IMG_UINT32 ui32Core;
-
+
#if defined(SUPPORT_HW_RECOVERY)
eError = OSDisableTimer(psDevInfo->hTimer);
{
ui32PowerCmd = PVRSRV_POWERCMD_IDLE;
- ui32CompleteStatus = PVRSRV_USSE_EDM_POWMAN_IDLE_COMPLETE;
+ ui32CompleteStatus = PVRSRV_USSE_EDM_POWMAN_IDLE_COMPLETE;
PDUMPCOMMENT("SGX idle request");
}
sCommand.ui32Data[1] = ui32PowerCmd;
-
+
eError = SGXScheduleCCBCommand(psDevInfo, SGXMKIF_CMD_POWER, &sCommand, KERNEL_ID, 0);
if (eError != PVRSRV_OK)
{
psDevInfo->ui32ClkGateStatusMask,
"Wait for SGX clock gating");
}
-
+
#if defined(SGX_FEATURE_MP)
SGXPollForClockGating(psDevInfo,
psDevInfo->ui32MasterClkGateStatusReg,
psDevInfo->ui32MasterClkGateStatusMask,
"Wait for SGX master clock gating");
+
+ SGXPollForClockGating(psDevInfo,
+ psDevInfo->ui32MasterClkGateStatus2Reg,
+ psDevInfo->ui32MasterClkGateStatus2Mask,
+ "Wait for SGX master clock gating (2)");
#endif
-
+
if (eNewPowerState == PVRSRV_DEV_POWER_STATE_OFF)
{
eError = SGXDeinitialise(psDevInfo);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: SGXDeinitialise failed: %lu", eError));
- return eError;
+ PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: SGXDeinitialise failed: %u", eError));
+ return eError;
}
}
}
}
-PVRSRV_ERROR SGXPostPowerState (IMG_HANDLE hDevHandle,
- PVRSRV_DEV_POWER_STATE eNewPowerState,
+PVRSRV_ERROR SGXPostPowerState (IMG_HANDLE hDevHandle,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
PVRSRV_DEV_POWER_STATE eCurrentPowerState)
{
if ((eNewPowerState != eCurrentPowerState) &&
psSGXHostCtl->ui32PowerStatus = 0;
#if defined(PDUMP)
- PDUMPCOMMENT("TA/3D CCB Control - Reset power status");
+ PDUMPCOMMENT("Host Control - Reset power status");
PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
offsetof(SGXMKIF_HOST_CTL, ui32PowerStatus),
sizeof(IMG_UINT32), PDUMP_FLAGS_CONTINUOUS,
-
eError = SGXUpdateTimingInfo(psDeviceNode);
if (eError != PVRSRV_OK)
- eError = SGXInitialise(psDevInfo);
+ eError = SGXInitialise(psDevInfo, IMG_FALSE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState: SGXInitialise failed"));
eError = SGXScheduleCCBCommand(psDevInfo, SGXMKIF_CMD_POWER, &sCommand, ISR_ID, 0);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState failed to schedule CCB command: %lu", eError));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState failed to schedule CCB command: %u", eError));
+ return eError;
}
}
-
+
SGXStartTimer(psDevInfo);
}
{
PDUMPSUSPEND();
-
+
eError = SGXPrePowerState(hDevHandle, PVRSRV_DEV_POWER_STATE_IDLE,
PVRSRV_DEV_POWER_STATE_ON);
}
}
}
-
- PVR_DPF((PVR_DBG_MESSAGE,"SGXPreClockSpeedChange: SGX clock speed was %luHz",
+
+ PVR_DPF((PVR_DBG_MESSAGE,"SGXPreClockSpeedChange: SGX clock speed was %uHz",
psDevInfo->ui32CoreClockSpeed));
return PVRSRV_OK;
PVRSRV_DEV_POWER_STATE_IDLE);
PDUMPRESUME();
-
+
if (eError != PVRSRV_OK)
{
return eError;
{
SGXStartTimer(psDevInfo);
}
-
}
- PVR_DPF((PVR_DBG_MESSAGE,"SGXPostClockSpeedChange: SGX clock speed changed from %luHz to %luHz",
+ PVR_DPF((PVR_DBG_MESSAGE,"SGXPostClockSpeedChange: SGX clock speed changed from %uHz to %uHz",
ui32OldClockSpeed, psDevInfo->ui32CoreClockSpeed));
return PVRSRV_OK;
#if defined(SGX_FEATURE_MP)
ui32SoftResetRegVal =
- EUR_CR_MASTER_SOFT_RESET_IPF_RESET_MASK |
+ EUR_CR_MASTER_SOFT_RESET_IPF_RESET_MASK |
EUR_CR_MASTER_SOFT_RESET_DPM_RESET_MASK |
EUR_CR_MASTER_SOFT_RESET_VDM_RESET_MASK;
+#if defined(SGX_FEATURE_PTLA)
+ ui32SoftResetRegVal |= EUR_CR_MASTER_SOFT_RESET_PTLA_RESET_MASK;
+#endif
#if defined(SGX_FEATURE_SYSTEM_CACHE)
ui32SoftResetRegVal |= EUR_CR_MASTER_SOFT_RESET_SLC_RESET_MASK;
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SOFT_RESET, ui32SoftResetRegVal);
if (bPDump)
{
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
}
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_SOFT_RESET, ui32SoftResetRegVal);
if (bPDump)
{
- PDUMPREGWITHFLAGS(EUR_CR_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
}
}
#endif
- OSWaitus(1000 * 1000000 / psDevInfo->ui32CoreClockSpeed);
+ OSWaitus(100 * 1000000 / psDevInfo->ui32CoreClockSpeed);
if (bPDump)
{
PDUMPIDLWITHFLAGS(30, ui32PDUMPFlags);
#if defined(PDUMP)
- PDumpRegRead(EUR_CR_SOFT_RESET, ui32PDUMPFlags);
+ PDumpRegRead(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32PDUMPFlags);
#endif
}
-
-
}
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL_INVAL, ui32RegVal);
if (bPDump)
{
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL_INVAL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL_INVAL, ui32RegVal, ui32PDUMPFlags);
}
#else
ui32RegVal = EUR_CR_BIF_CTRL_INVALDC_MASK;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
if (bPDump)
{
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
}
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, bPDump);
ui32RegVal = 0;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
if (bPDump)
{
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
}
#endif
SGXResetSleep(psDevInfo, ui32PDUMPFlags, bPDump);
if (bPDump)
{
- PDUMPREGPOLWITHFLAGS(EUR_CR_BIF_MEM_REQ_STAT, 0, EUR_CR_BIF_MEM_REQ_STAT_READS_MASK, ui32PDUMPFlags);
+ PDUMPREGPOLWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_MEM_REQ_STAT, 0, EUR_CR_BIF_MEM_REQ_STAT_READS_MASK, ui32PDUMPFlags);
}
}
#endif
IMG_VOID SGXReset(PVRSRV_SGXDEV_INFO *psDevInfo,
- IMG_UINT32 ui32PDUMPFlags)
+ IMG_BOOL bHardwareRecovery,
+ IMG_UINT32 ui32PDUMPFlags)
{
IMG_UINT32 ui32RegVal;
#if defined(EUR_CR_BIF_INT_STAT_FAULT_REQ_MASK)
ui32RegVal = EUR_CR_BIF_CTRL_PAUSE_MASK;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
ui32RegVal = EUR_CR_BIF_CTRL_PAUSE_MASK | EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
ui32RegVal = EUR_CR_BIF_CTRL_PAUSE_MASK;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
}
#if defined(SGX_FEATURE_36BIT_MMU)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_36BIT_ADDRESSING, EUR_CR_BIF_36BIT_ADDRESSING_ENABLE_MASK);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_36BIT_ADDRESSING, EUR_CR_BIF_36BIT_ADDRESSING_ENABLE_MASK, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_36BIT_ADDRESSING, EUR_CR_BIF_36BIT_ADDRESSING_ENABLE_MASK, ui32PDUMPFlags);
#endif
ui32RegVal = 0;
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
#if defined(SGX_FEATURE_MP)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BIF_CTRL, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
#endif
#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK_SET, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_BANK_SET, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK_SET, ui32RegVal, ui32PDUMPFlags);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK0, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal, ui32PDUMPFlags);
#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
{
{
ui32DirListReg = EUR_CR_BIF_DIR_LIST_BASE1 + 4 * (ui32DirList - 1);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32DirListReg, ui32RegVal);
- PDUMPREGWITHFLAGS(ui32DirListReg, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, ui32DirListReg, ui32RegVal, ui32PDUMPFlags);
}
}
#endif
(7UL << EUR_CR_BIF_MEM_ARB_CONFIG_BEST_CNT_SHIFT) |
(12UL << EUR_CR_BIF_MEM_ARB_CONFIG_TTE_THRESH_SHIFT);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_MEM_ARB_CONFIG, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_MEM_ARB_CONFIG, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_MEM_ARB_CONFIG, ui32RegVal, ui32PDUMPFlags);
#endif
#if defined(SGX_FEATURE_SYSTEM_CACHE)
#error SGX_BYPASS_SYSTEM_CACHE not supported
#else
ui32RegVal = EUR_CR_MASTER_SLC_CTRL_USSE_INVAL_REQ0_MASK |
+ #if defined(FIX_HW_BRN_30954)
+ EUR_CR_MASTER_SLC_CTRL_DISABLE_REORDERING_MASK |
+ #endif
(0xC << EUR_CR_MASTER_SLC_CTRL_ARB_PAGE_SIZE_SHIFT);
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SLC_CTRL, ui32RegVal);
- PDUMPREG(EUR_CR_MASTER_SLC_CTRL, ui32RegVal);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SLC_CTRL, ui32RegVal);
ui32RegVal = EUR_CR_MASTER_SLC_CTRL_BYPASS_BYP_CC_MASK;
+ #if defined(FIX_HW_BRN_31195)
+ ui32RegVal |= EUR_CR_MASTER_SLC_CTRL_BYPASS_REQ_USE0_MASK |
+ EUR_CR_MASTER_SLC_CTRL_BYPASS_REQ_USE1_MASK |
+ EUR_CR_MASTER_SLC_CTRL_BYPASS_REQ_USE2_MASK |
+ EUR_CR_MASTER_SLC_CTRL_BYPASS_REQ_USE3_MASK |
+ EUR_CR_MASTER_SLC_CTRL_BYPASS_REQ_TA_MASK;
+ #endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SLC_CTRL_BYPASS, ui32RegVal);
- PDUMPREG(EUR_CR_MASTER_SLC_CTRL_BYPASS, ui32RegVal);
+ PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SLC_CTRL_BYPASS, ui32RegVal);
#endif
#else
#if defined(SGX_BYPASS_SYSTEM_CACHE)
- ui32RegVal = EUR_CR_MNE_CR_CTRL_BYPASS_ALL_MASK;
+ ui32RegVal = MNE_CR_CTRL_BYPASS_ALL_MASK;
#else
#if defined(FIX_HW_BRN_26620)
ui32RegVal = 0;
#else
- ui32RegVal = EUR_CR_MNE_CR_CTRL_BYP_CC_MASK;
+ ui32RegVal = MNE_CR_CTRL_BYP_CC_MASK;
#endif
#endif
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MNE_CR_CTRL, ui32RegVal);
- PDUMPREG(EUR_CR_MNE_CR_CTRL, ui32RegVal);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, MNE_CR_CTRL, ui32RegVal);
+ PDUMPREG(SGX_PDUMPREG_NAME, MNE_CR_CTRL, ui32RegVal);
#endif
#endif
-
+ if (bHardwareRecovery)
+ {
+
- ui32RegVal = psDevInfo->sBIFResetPDDevPAddr.uiAddr;
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal);
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
-
- SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_TRUE);
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+ ui32RegVal = (IMG_UINT32)psDevInfo->sBIFResetPDDevPAddr.uiAddr;
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal);
- SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+ SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
-
+
+ SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_TRUE);
+ SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
- for (;;)
- {
- IMG_UINT32 ui32BifIntStat = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_INT_STAT);
- IMG_DEV_VIRTADDR sBifFault;
- IMG_UINT32 ui32PDIndex, ui32PTIndex;
+ SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
- if ((ui32BifIntStat & ui32BifFaultMask) == 0)
+
+
+ for (;;)
{
- break;
- }
+ IMG_UINT32 ui32BifIntStat = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_INT_STAT);
+ IMG_DEV_VIRTADDR sBifFault;
+ IMG_UINT32 ui32PDIndex, ui32PTIndex;
-
+ if ((ui32BifIntStat & ui32BifFaultMask) == 0)
+ {
+ break;
+ }
+
+
- sBifFault.uiAddr = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_FAULT);
- PVR_DPF((PVR_DBG_WARNING, "SGXReset: Page fault 0x%x/0x%x", ui32BifIntStat, sBifFault.uiAddr));
- ui32PDIndex = sBifFault.uiAddr >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
- ui32PTIndex = (sBifFault.uiAddr & SGX_MMU_PT_MASK) >> SGX_MMU_PAGE_SHIFT;
+ sBifFault.uiAddr = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_FAULT);
+ PVR_DPF((PVR_DBG_WARNING, "SGXReset: Page fault 0x%x/0x%x", ui32BifIntStat, sBifFault.uiAddr));
+ ui32PDIndex = sBifFault.uiAddr >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
+ ui32PTIndex = (sBifFault.uiAddr & SGX_MMU_PT_MASK) >> SGX_MMU_PAGE_SHIFT;
-
- SGXResetSoftReset(psDevInfo, IMG_TRUE, ui32PDUMPFlags, IMG_FALSE);
+
+ SGXResetSoftReset(psDevInfo, IMG_TRUE, ui32PDUMPFlags, IMG_FALSE);
-
- psDevInfo->pui32BIFResetPD[ui32PDIndex] = (psDevInfo->sBIFResetPTDevPAddr.uiAddr
- >>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
- | SGX_MMU_PDE_PAGE_SIZE_4K
- | SGX_MMU_PDE_VALID;
- psDevInfo->pui32BIFResetPT[ui32PTIndex] = (psDevInfo->sBIFResetPageDevPAddr.uiAddr
- >>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
- | SGX_MMU_PTE_VALID;
+
+ psDevInfo->pui32BIFResetPD[ui32PDIndex] = (psDevInfo->sBIFResetPTDevPAddr.uiAddr
+ >>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+ | SGX_MMU_PDE_PAGE_SIZE_4K
+ | SGX_MMU_PDE_VALID;
+ psDevInfo->pui32BIFResetPT[ui32PTIndex] = (psDevInfo->sBIFResetPageDevPAddr.uiAddr
+ >>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+ | SGX_MMU_PTE_VALID;
-
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS);
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR, ui32RegVal);
- ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS2);
- OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR2, ui32RegVal);
+
+ ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR, ui32RegVal);
+ ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS2);
+ OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR2, ui32RegVal);
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+ SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
-
- SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_FALSE);
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+
+ SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_FALSE);
+ SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
-
- SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+
+ SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
-
- psDevInfo->pui32BIFResetPD[ui32PDIndex] = 0;
- psDevInfo->pui32BIFResetPT[ui32PTIndex] = 0;
+
+ psDevInfo->pui32BIFResetPD[ui32PDIndex] = 0;
+ psDevInfo->pui32BIFResetPT[ui32PTIndex] = 0;
+ }
}
-
+ else
+ {
+
+ SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_TRUE);
+ SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+ }
ui32RegVal = (SGX_BIF_DIR_LIST_INDEX_EDM << EUR_CR_BIF_BANK0_INDEX_EDM_SHIFT);
- #if defined(SGX_FEATURE_2D_HARDWARE)
+ #if defined(SGX_FEATURE_2D_HARDWARE) && !defined(SGX_FEATURE_PTLA)
ui32RegVal |= (SGX_BIF_DIR_LIST_INDEX_EDM << EUR_CR_BIF_BANK0_INDEX_2D_SHIFT);
#endif
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK0, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
#endif
{
#if defined(FIX_HW_BRN_28011)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT);
- PDUMPPDREGWITHFLAGS(EUR_CR_BIF_DIR_LIST_BASE0, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT, ui32PDUMPFlags, PDUMP_PD_UNIQUETAG);
+ PDUMPPDREGWITHFLAGS(&psDevInfo->sMMUAttrib, EUR_CR_BIF_DIR_LIST_BASE0, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT, ui32PDUMPFlags, PDUMP_PD_UNIQUETAG);
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32EDMDirListReg, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT);
- PDUMPPDREGWITHFLAGS(ui32EDMDirListReg, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT, ui32PDUMPFlags, PDUMP_PD_UNIQUETAG);
+ PDUMPPDREGWITHFLAGS(&psDevInfo->sMMUAttrib, ui32EDMDirListReg, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT, ui32PDUMPFlags, PDUMP_PD_UNIQUETAG);
}
-#ifdef SGX_FEATURE_2D_HARDWARE
+#if defined(SGX_FEATURE_2D_HARDWARE) && !defined(SGX_FEATURE_PTLA)
#if ((SGX_2D_HEAP_BASE & ~EUR_CR_BIF_TWOD_REQ_BASE_ADDR_MASK) != 0)
#error "SGXReset: SGX_2D_HEAP_BASE doesn't match EUR_CR_BIF_TWOD_REQ_BASE_ADDR_MASK alignment"
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_TWOD_REQ_BASE, SGX_2D_HEAP_BASE);
- PDUMPREGWITHFLAGS(EUR_CR_BIF_TWOD_REQ_BASE, SGX_2D_HEAP_BASE, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_TWOD_REQ_BASE, SGX_2D_HEAP_BASE, ui32PDUMPFlags);
#endif
SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
PVR_DPF((PVR_DBG_MESSAGE,"Soft Reset of SGX"));
- SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
ui32RegVal = 0;
#if defined(SGX_FEATURE_MP)
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SOFT_RESET, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_MASTER_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
#endif
OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_SOFT_RESET, ui32RegVal);
- PDUMPREGWITHFLAGS(EUR_CR_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
SGXMKIF_TRANSFERCMD_SHARED *psSharedTransferCmd;
PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
PVRSRV_ERROR eError;
-
+ IMG_UINT32 loop;
+#if defined(PDUMP)
+ IMG_BOOL bPersistentProcess = IMG_FALSE;
+
+ {
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc != IMG_NULL)
+ {
+ bPersistentProcess = psPerProc->bPDumpPersistent;
+ }
+ }
+#endif
if (!CCB_OFFSET_IS_VALID(SGXMKIF_TRANSFERCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset))
{
psSharedTransferCmd->s3DSyncReadOpsCompleteDevVAddr.uiAddr = 0;
}
+ psSharedTransferCmd->ui32NumSrcSyncs = psKick->ui32NumSrcSync;
+ psSharedTransferCmd->ui32NumDstSyncs = psKick->ui32NumDstSync;
if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
{
- if (psKick->ui32NumSrcSync > 0)
+ for (loop=0; loop<psKick->ui32NumSrcSync; loop++)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[loop];
- psSharedTransferCmd->ui32SrcWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
- psSharedTransferCmd->ui32SrcReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+ psSharedTransferCmd->asSrcSyncs[loop].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+ psSharedTransferCmd->asSrcSyncs[loop].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
- psSharedTransferCmd->sSrcWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
- psSharedTransferCmd->sSrcReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+ psSharedTransferCmd->asSrcSyncs[loop].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+ psSharedTransferCmd->asSrcSyncs[loop].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
}
-
- if (psKick->ui32NumDstSync > 0)
+ for (loop=0; loop<psKick->ui32NumDstSync; loop++)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[loop];
- psSharedTransferCmd->ui32DstWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
- psSharedTransferCmd->ui32DstReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+ psSharedTransferCmd->asDstSyncs[loop].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+ psSharedTransferCmd->asDstSyncs[loop].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
- psSharedTransferCmd->sDstWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
- psSharedTransferCmd->sDstReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+ psSharedTransferCmd->asDstSyncs[loop].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+ psSharedTransferCmd->asDstSyncs[loop].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
}
- if (psKick->ui32NumSrcSync > 0)
+ for (loop=0; loop<psKick->ui32NumSrcSync; loop++)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[loop];
psSyncInfo->psSyncData->ui32ReadOpsPending++;
}
- if (psKick->ui32NumDstSync > 0)
+ for (loop=0; loop<psKick->ui32NumDstSync; loop++)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[loop];
psSyncInfo->psSyncData->ui32WriteOpsPending++;
}
}
-
- if (psKick->ui32NumDstSync > 1 || psKick->ui32NumSrcSync > 1)
- {
- PVR_DPF((PVR_DBG_ERROR,
- "Transfer command doesn't support more than 1 sync object per src/dst\ndst: %d, src: %d",
- psKick->ui32NumDstSync, psKick->ui32NumSrcSync));
- }
-
#if defined(PDUMP)
- if (PDumpIsCaptureFrameKM()
- || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+ if ((PDumpIsCaptureFrameKM()
+ || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+ && (bPersistentProcess == IMG_FALSE) )
{
PDUMPCOMMENT("Shared part of transfer command\r\n");
PDUMPMEM(psSharedTransferCmd,
psKick->ui32PDumpFlags,
MAKEUNIQUETAG(psCCBMemInfo));
- if((psKick->ui32NumSrcSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
+ if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
{
- psSyncInfo = psKick->ahSrcSyncInfo[0];
-
- PDUMPCOMMENT("Hack src surface write op in transfer cmd\r\n");
- PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
- psCCBMemInfo,
- psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32SrcWriteOpPendingVal),
+ for (loop=0; loop<psKick->ui32NumSrcSync ; loop++)
+ {
+ psSyncInfo = psKick->ahSrcSyncInfo[loop];
+
+ PDUMPCOMMENT("Hack src surface write op in transfer cmd\r\n");
+ PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+ psCCBMemInfo,
+ psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, asSrcSyncs) + loop * sizeof(PVRSRV_DEVICE_SYNC_OBJECT) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
- psKick->ui32PDumpFlags,
- MAKEUNIQUETAG(psCCBMemInfo));
-
- PDUMPCOMMENT("Hack src surface read op in transfer cmd\r\n");
- PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
- psCCBMemInfo,
- psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32SrcReadOpPendingVal),
- sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
- psKick->ui32PDumpFlags,
- MAKEUNIQUETAG(psCCBMemInfo));
-
+ psKick->ui32PDumpFlags,
+ MAKEUNIQUETAG(psCCBMemInfo));
+
+ PDUMPCOMMENT("Hack src surface read op in transfer cmd\r\n");
+ PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+ psCCBMemInfo,
+ psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, asSrcSyncs) + loop * sizeof(PVRSRV_DEVICE_SYNC_OBJECT) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+ sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
+ psKick->ui32PDumpFlags,
+ MAKEUNIQUETAG(psCCBMemInfo));
+
+ }
}
- if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
+ if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
{
- psSyncInfo = psKick->ahDstSyncInfo[0];
+ for (loop=0; loop< psKick->ui32NumDstSync; loop++)
+ {
+ psSyncInfo = psKick->ahDstSyncInfo[loop];
+
+ PDUMPCOMMENT("Hack dest surface write op in transfer cmd\r\n");
+ PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+ psCCBMemInfo,
+ psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, asDstSyncs) + loop * sizeof(PVRSRV_DEVICE_SYNC_OBJECT) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal) ,
+ sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
+ psKick->ui32PDumpFlags,
+ MAKEUNIQUETAG(psCCBMemInfo));
- PDUMPCOMMENT("Hack dest surface write op in transfer cmd\r\n");
- PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
- psCCBMemInfo,
- psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32DstWriteOpPendingVal),
- sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
- psKick->ui32PDumpFlags,
- MAKEUNIQUETAG(psCCBMemInfo));
-
- PDUMPCOMMENT("Hack dest surface read op in transfer cmd\r\n");
- PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
- psCCBMemInfo,
- psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32DstReadOpPendingVal),
- sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
- psKick->ui32PDumpFlags,
- MAKEUNIQUETAG(psCCBMemInfo));
-
+ PDUMPCOMMENT("Hack dest surface read op in transfer cmd\r\n");
+ PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+ psCCBMemInfo,
+ psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, asDstSyncs) + loop * sizeof(PVRSRV_DEVICE_SYNC_OBJECT) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+ sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
+ psKick->ui32PDumpFlags,
+ MAKEUNIQUETAG(psCCBMemInfo));
+
+ }
}
- if((psKick->ui32NumSrcSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING)== 0UL))
+ if((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING)== 0UL)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
- psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+ for (loop=0; loop<(psKick->ui32NumSrcSync); loop++)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[loop];
+ psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+ }
}
- if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
+ if((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
{
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
- psSyncInfo->psSyncData->ui32LastOpDumpVal++;
+ for (loop=0; loop<(psKick->ui32NumDstSync); loop++)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+ psSyncInfo->psSyncData->ui32LastOpDumpVal++;
+ }
}
}
#endif
psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
psSyncInfo->psSyncData->ui32WriteOpsPending--;
}
+#if defined(PDUMP)
+ if (PDumpIsCaptureFrameKM()
+ || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+ {
+ if (psKick->ui32NumSrcSync > 0)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+ psSyncInfo->psSyncData->ui32LastReadOpDumpVal--;
+ }
+ if (psKick->ui32NumDstSync > 0)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+ psSyncInfo->psSyncData->ui32LastOpDumpVal--;
+ }
+ }
+#endif
+ }
+
+
+ if (psKick->hTASyncInfo != IMG_NULL)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+ psSyncInfo->psSyncData->ui32WriteOpsPending--;
+ }
+
+
+ if (psKick->h3DSyncInfo != IMG_NULL)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+ psSyncInfo->psSyncData->ui32WriteOpsPending--;
}
}
+
else if (PVRSRV_OK != eError)
{
PVR_DPF((PVR_DBG_ERROR, "SGXSubmitTransferKM: SGXScheduleCCBCommandKM failed."));
PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
PVRSRV_ERROR eError;
IMG_UINT32 i;
+#if defined(PDUMP)
+ IMG_BOOL bPersistentProcess = IMG_FALSE;
+
+ {
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc != IMG_NULL)
+ {
+ bPersistentProcess = psPerProc->bPDumpPersistent;
+ }
+ }
+#endif
if (!CCB_OFFSET_IS_VALID(SGXMKIF_2DCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset))
{
}
#if defined(PDUMP)
- if (PDumpIsCaptureFrameKM()
+ if ((PDumpIsCaptureFrameKM()
|| ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+ && (bPersistentProcess == IMG_FALSE) )
{
PDUMPCOMMENT("Shared part of 2D command\r\n");
eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_2D, &sCommand, KERNEL_ID, psKick->ui32PDumpFlags);
+ if (eError == PVRSRV_ERROR_RETRY)
+ {
+
+
+#if defined(PDUMP)
+ if (PDumpIsCaptureFrameKM())
+ {
+ for (i = 0; i < psKick->ui32NumSrcSync; i++)
+ {
+ psSyncInfo = psKick->ahSrcSyncInfo[i];
+ psSyncInfo->psSyncData->ui32LastReadOpDumpVal--;
+ }
+
+ if (psKick->hDstSyncInfo != IMG_NULL)
+ {
+ psSyncInfo = psKick->hDstSyncInfo;
+ psSyncInfo->psSyncData->ui32LastOpDumpVal--;
+ }
+ }
+#endif
+
+ for (i = 0; i < psKick->ui32NumSrcSync; i++)
+ {
+ psSyncInfo = psKick->ahSrcSyncInfo[i];
+ psSyncInfo->psSyncData->ui32ReadOpsPending--;
+ }
+
+ if (psKick->hDstSyncInfo != IMG_NULL)
+ {
+ psSyncInfo = psKick->hDstSyncInfo;
+ psSyncInfo->psSyncData->ui32WriteOpsPending--;
+ }
+
+
+ if (psKick->hTASyncInfo != IMG_NULL)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+
+ psSyncInfo->psSyncData->ui32WriteOpsPending--;
+ }
+
+
+ if (psKick->h3DSyncInfo != IMG_NULL)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+
+ psSyncInfo->psSyncData->ui32WriteOpsPending--;
+ }
+ }
+
+
+
#if defined(NO_HARDWARE)
psSyncInfo->psSyncData->ui32ReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
}
- psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hDstSyncInfo;
- psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+ if (psKick->hDstSyncInfo != IMG_NULL)
+ {
+ psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hDstSyncInfo;
+
+ psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+ }
if (psKick->hTASyncInfo != IMG_NULL)
{
#include "sgxdefs.h"
#include "services_headers.h"
#include "buffer_manager.h"
+#include "sgx_bridge_km.h"
#include "sgxapi_km.h"
#include "sgxinfo.h"
#include "sgx_mkif_km.h"
#include "sgxutils.h"
#ifdef __linux__
-#include <linux/tty.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
#else
#include <stdio.h>
#endif
-IMG_VOID SGXPostActivePowerEvent(PVRSRV_DEVICE_NODE * psDeviceNode,
- IMG_UINT32 ui32CallerID)
+static IMG_VOID SGXPostActivePowerEvent(PVRSRV_DEVICE_NODE * psDeviceNode,
+ IMG_UINT32 ui32CallerID)
{
PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
SGXMKIF_HOST_CTL *psSGXHostCtl = psDevInfo->psSGXHostCtl;
-
+
psSGXHostCtl->ui32NumActivePowerEvents++;
-
+
if ((psSGXHostCtl->ui32PowerStatus & PVRSRV_USSE_EDM_POWMAN_POWEROFF_RESTART_IMMEDIATE) != 0)
{
{
SGXScheduleProcessQueuesKM(psDeviceNode);
}
- }
+ }
}
{
psSGXHostCtl->ui32InterruptClearFlags |= PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER;
-
+
PDUMPSUSPEND();
ui32CallerID, IMG_FALSE);
if (eError == PVRSRV_OK)
{
- SGXPostActivePowerEvent(psDeviceNode, ui32CallerID);
+ SGXPostActivePowerEvent(psDeviceNode, ui32CallerID);
}
#endif
if (eError == PVRSRV_ERROR_RETRY)
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "SGXTestActivePowerEvent error:%lu", eError));
+ PVR_DPF((PVR_DBG_ERROR, "SGXTestActivePowerEvent error:%u", eError));
}
}
PVRSRV_SGX_CCB_INFO *psKernelCCB;
PVRSRV_ERROR eError = PVRSRV_OK;
SGXMKIF_COMMAND *psSGXCommand;
+ SYS_DATA *psSysData;
#if defined(PDUMP)
IMG_VOID *pvDumpCommand;
IMG_BOOL bPDumpIsSuspended = PDumpIsSuspended();
+ IMG_BOOL bPersistentProcess = IMG_FALSE;
#else
PVR_UNREFERENCED_PARAMETER(ui32CallerID);
PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags);
#endif
+#if defined(FIX_HW_BRN_28889)
+
+
+
+
+ if ( (eCmdType != SGXMKIF_CMD_PROCESS_QUEUES) &&
+ ((psDevInfo->ui32CacheControl & SGXMKIF_CC_INVAL_DATA) != 0) &&
+ ((psDevInfo->ui32CacheControl & (SGXMKIF_CC_INVAL_BIF_PT | SGXMKIF_CC_INVAL_BIF_PD)) != 0))
+ {
+ #if defined(PDUMP)
+ PVRSRV_KERNEL_MEM_INFO *psSGXHostCtlMemInfo = psDevInfo->psKernelSGXHostCtlMemInfo;
+ #endif
+ SGXMKIF_HOST_CTL *psSGXHostCtl = psDevInfo->psSGXHostCtl;
+ SGXMKIF_COMMAND sCacheCommand = {0};
+
+ eError = SGXScheduleCCBCommand(psDevInfo,
+ SGXMKIF_CMD_PROCESS_QUEUES,
+ &sCacheCommand,
+ ui32CallerID,
+ ui32PDumpFlags);
+ if (eError != PVRSRV_OK)
+ {
+ goto Exit;
+ }
+
+
+ #if !defined(NO_HARDWARE)
+ if(PollForValueKM(&psSGXHostCtl->ui32InvalStatus,
+ PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE,
+ PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE,
+ 2 * MAX_HW_TIME_US/WAIT_TRY_COUNT,
+ WAIT_TRY_COUNT) != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SGXScheduleCCBCommand: Wait for uKernel to Invalidate BIF cache failed"));
+ PVR_DBG_BREAK;
+ }
+ #endif
+
+ #if defined(PDUMP)
+
+ PDUMPCOMMENTWITHFLAGS(0, "Host Control - Poll for BIF cache invalidate request to complete");
+ PDUMPMEMPOL(psSGXHostCtlMemInfo,
+ offsetof(SGXMKIF_HOST_CTL, ui32InvalStatus),
+ PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE,
+ PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE,
+ PDUMP_POLL_OPERATOR_EQUAL,
+ 0,
+ MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+ #endif
+
+ psSGXHostCtl->ui32InvalStatus &= ~(PVRSRV_USSE_EDM_BIF_INVAL_COMPLETE);
+ PDUMPMEM(IMG_NULL, psSGXHostCtlMemInfo, offsetof(SGXMKIF_HOST_CTL, ui32CleanupStatus), sizeof(IMG_UINT32), 0, MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+ }
+#endif
+
+#if defined(PDUMP)
+
+ {
+ PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+ if(psPerProc != IMG_NULL)
+ {
+ bPersistentProcess = psPerProc->bPDumpPersistent;
+ }
+ }
+#endif
psKernelCCB = psDevInfo->psKernelCCBInfo;
psSGXCommand = SGXAcquireKernelCCBSlot(psKernelCCB);
if (eCmdType >= SGXMKIF_CMD_MAX)
{
PVR_DPF((PVR_DBG_ERROR,"SGXScheduleCCBCommandKM: Unknown command type: %d", eCmdType)) ;
- eError = PVRSRV_ERROR_GENERIC;
- goto Exit;
+ eError = PVRSRV_ERROR_INVALID_CCB_COMMAND;
+ goto Exit;
}
-#if defined(SUPPORT_CPU_CACHED_BUFFERS)
- {
- SYS_DATA *psSysData;
-
- SysAcquireData(&psSysData);
+
+ SysAcquireData(&psSysData);
- if (psSysData->bFlushAll)
- {
- OSFlushCPUCacheKM();
-
- psSysData->bFlushAll = IMG_FALSE;
- }
+ if(psSysData->ePendingCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_FLUSH)
+ {
+ OSFlushCPUCacheKM();
+ }
+ else if(psSysData->ePendingCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_CLEAN)
+ {
+ OSCleanCPUCacheKM();
}
-#endif
+
+ psSysData->ePendingCacheOpType = PVRSRV_MISC_INFO_CPUCACHEOP_NONE;
+
+ PVR_ASSERT(eCmdType < SGXMKIF_CMD_MAX);
psSGXCommand->ui32ServiceAddress = psDevInfo->aui32HostKickAddr[eCmdType];
#if defined(PDUMP)
- if ((ui32CallerID != ISR_ID) && (bPDumpIsSuspended == IMG_FALSE))
+ if ((ui32CallerID != ISR_ID) && (bPDumpIsSuspended == IMG_FALSE) &&
+ (bPersistentProcess == IMG_FALSE) )
{
PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Poll for space in the Kernel CCB\r\n");
ui32PDumpFlags,
MAKEUNIQUETAG(psKernelCCB->psCCBCtlMemInfo));
- PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Kernel CCB command\r\n");
+ PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Kernel CCB command (type == %d)\r\n", eCmdType);
pvDumpCommand = (IMG_VOID *)((IMG_UINT8 *)psKernelCCB->psCCBMemInfo->pvLinAddrKM + (*psKernelCCB->pui32WriteOffset * sizeof(SGXMKIF_COMMAND)));
PDUMPMEM(pvDumpCommand,
*psKernelCCB->pui32WriteOffset = (*psKernelCCB->pui32WriteOffset + 1) & 255;
#if defined(PDUMP)
- if ((ui32CallerID != ISR_ID) && (bPDumpIsSuspended == IMG_FALSE))
+ if ((ui32CallerID != ISR_ID) && (bPDumpIsSuspended == IMG_FALSE) &&
+ (bPersistentProcess == IMG_FALSE) )
{
#if defined(FIX_HW_BRN_26620) && defined(SGX_FEATURE_SYSTEM_CACHE) && !defined(SGX_BYPASS_SYSTEM_CACHE)
PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Poll for previous Kernel CCB CMD to be read\r\n");
MAKEUNIQUETAG(psDevInfo->psKernelCCBEventKickerMemInfo));
PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Kick the SGX microkernel\r\n");
#if defined(FIX_HW_BRN_26620) && defined(SGX_FEATURE_SYSTEM_CACHE) && !defined(SGX_BYPASS_SYSTEM_CACHE)
- PDUMPREGWITHFLAGS(SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0), EUR_CR_EVENT_KICK2_NOW_MASK, ui32PDumpFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0), EUR_CR_EVENT_KICK2_NOW_MASK, ui32PDumpFlags);
#else
- PDUMPREGWITHFLAGS(SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0), EUR_CR_EVENT_KICK_NOW_MASK, ui32PDumpFlags);
+ PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0), EUR_CR_EVENT_KICK_NOW_MASK, ui32PDumpFlags);
#endif
}
#endif
*psDevInfo->pui32KernelCCBEventKicker = (*psDevInfo->pui32KernelCCBEventKicker + 1) & 0xFF;
+
+ OSWriteMemoryBarrier();
+
#if defined(FIX_HW_BRN_26620) && defined(SGX_FEATURE_SYSTEM_CACHE) && !defined(SGX_BYPASS_SYSTEM_CACHE)
OSWriteHWReg(psDevInfo->pvRegsBaseKM,
SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0),
EUR_CR_EVENT_KICK_NOW_MASK);
#endif
+ OSMemoryBarrier();
+
#if defined(NO_HARDWARE)
*psKernelCCB->pui32ReadOffset = (*psKernelCCB->pui32ReadOffset + 1) & 255;
else
{
PVR_DPF((PVR_DBG_ERROR,"SGXScheduleCCBCommandKM failed to acquire lock - "
- "ui32CallerID:%ld eError:%lu", ui32CallerID, eError));
+ "ui32CallerID:%d eError:%u", ui32CallerID, eError));
}
return eError;
PVRSRVPowerUnlock(ui32CallerID);
+
if (ui32CallerID != ISR_ID)
{
eError = SGXScheduleCCBCommandKM(psDeviceNode, SGXMKIF_CMD_PROCESS_QUEUES, &sCommand, ISR_ID, 0);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"SGXScheduleProcessQueuesKM failed to schedule CCB command: %lu", eError));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR,"SGXScheduleProcessQueuesKM failed to schedule CCB command: %u", eError));
+ return eError;
}
return PVRSRV_OK;
else
{
SGXMKIF_COMMAND sCommand = {0};
-
+
PDUMPCOMMENTWITHFLAGS(0, "Request ukernel resouce clean-up");
sCommand.ui32Data[0] = ui32CleanupType;
sCommand.ui32Data[1] = (psHWDataDevVAddr == IMG_NULL) ? 0 : psHWDataDevVAddr->uiAddr;
-
+
eError = SGXScheduleCCBCommandKM(psDeviceNode, SGXMKIF_CMD_CLEANUP, &sCommand, KERNEL_ID, 0);
if (eError != PVRSRV_OK)
{
if(PollForValueKM(&psSGXHostCtl->ui32CleanupStatus,
PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
- MAX_HW_TIME_US/WAIT_TRY_COUNT,
+ 2 * MAX_HW_TIME_US/WAIT_TRY_COUNT,
WAIT_TRY_COUNT) != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR,"SGXCleanupRequest: Wait for uKernel to clean up failed"));
+ PVR_DPF((PVR_DBG_ERROR,"SGXCleanupRequest: Wait for uKernel to clean up (%u) failed", ui32CleanupType));
PVR_DBG_BREAK;
}
#endif
psSGXHostCtl->ui32CleanupStatus &= ~(PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE);
PDUMPMEM(IMG_NULL, psSGXHostCtlMemInfo, offsetof(SGXMKIF_HOST_CTL, ui32CleanupStatus), sizeof(IMG_UINT32), 0, MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+
+
+ #if defined(SGX_FEATURE_SYSTEM_CACHE)
+ psSGXDevInfo->ui32CacheControl |= (SGXMKIF_CC_INVAL_BIF_SL | SGXMKIF_CC_INVAL_DATA);
+ #else
+ psSGXDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_DATA;
+ #endif
}
}
PVR_DPF((PVR_DBG_ERROR,"SGX2DQueryBlitsCompleteKM: Timed out. Ops pending."));
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
{
PVRSRV_SYNC_DATA *psSyncData = psSyncInfo->psSyncData;
- PVR_TRACE(("SGX2DQueryBlitsCompleteKM: Syncinfo: %p, Syncdata: %p", psSyncInfo, psSyncData));
+ PVR_TRACE(("SGX2DQueryBlitsCompleteKM: Syncinfo: 0x%x, Syncdata: 0x%x",
+ (IMG_UINTPTR_T)psSyncInfo, (IMG_UINTPTR_T)psSyncData));
PVR_TRACE(("SGX2DQueryBlitsCompleteKM: Read ops complete: %d, Read ops pending: %d", psSyncData->ui32ReadOpsComplete, psSyncData->ui32ReadOpsPending));
PVR_TRACE(("SGX2DQueryBlitsCompleteKM: Write ops complete: %d, Write ops pending: %d", psSyncData->ui32WriteOpsComplete, psSyncData->ui32WriteOpsPending));
#include "perproc.h"
#include "sgxinfokm.h"
+
#define CCB_OFFSET_IS_VALID(type, psCCBMemInfo, psCCBKick, offset) \
((sizeof(type) <= (psCCBMemInfo)->ui32AllocSize) && \
((psCCBKick)->offset <= (psCCBMemInfo)->ui32AllocSize - sizeof(type)))
IMG_VOID SGXCleanupRequest(PVRSRV_DEVICE_NODE *psDeviceNode,
IMG_DEV_VIRTADDR *psHWDataDevVAddr,
IMG_UINT32 ui32CleanupType);
-
+
#ifndef __ENV_PERPROC_H__
#define __ENV_PERPROC_H__
-#include "linux/list.h"
-#include "linux/proc_fs.h"
+#include <linux/list.h>
+#include <linux/proc_fs.h>
-#include "img_types.h"
+#include "services.h"
+#include "handle.h"
typedef struct _PVRSRV_ENV_PER_PROCESS_DATA_
{
IMG_HANDLE hBlockAlloc;
struct proc_dir_entry *psProcDir;
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ struct list_head sDRMAuthListHead;
+#endif
} PVRSRV_ENV_PER_PROCESS_DATA;
IMG_VOID RemovePerProcessProcDir(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc);
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <asm/hardirq.h>
+#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/capability.h>
#include <linux/sched.h>
#include "proc.h"
#include "mutex.h"
#include "lock.h"
+#include "event.h"
typedef struct PVRSRV_LINUX_EVENT_OBJECT_LIST_TAG
{
- rwlock_t sLock;
- struct list_head sList;
+ rwlock_t sLock;
+ struct list_head sList;
} PVRSRV_LINUX_EVENT_OBJECT_LIST;
{
atomic_t sTimeStamp;
IMG_UINT32 ui32TimeStampPrevious;
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
IMG_UINT ui32Stats;
#endif
wait_queue_head_t sWait;
struct list_head sList;
- IMG_HANDLE hResItem;
+ IMG_HANDLE hResItem;
PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList;
} PVRSRV_LINUX_EVENT_OBJECT;
PVRSRV_ERROR LinuxEventObjectListCreate(IMG_HANDLE *phEventObjectList)
{
- PVRSRV_LINUX_EVENT_OBJECT_LIST *psEvenObjectList;
+ PVRSRV_LINUX_EVENT_OBJECT_LIST *psEventObjectList;
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST),
- (IMG_VOID **)&psEvenObjectList, IMG_NULL,
+ (IMG_VOID **)&psEventObjectList, IMG_NULL,
"Linux Event Object List") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectCreate: failed to allocate memory for event list"));
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
- INIT_LIST_HEAD(&psEvenObjectList->sList);
+ INIT_LIST_HEAD(&psEventObjectList->sList);
- rwlock_init(&psEvenObjectList->sLock);
+ rwlock_init(&psEventObjectList->sLock);
- *phEventObjectList = (IMG_HANDLE *) psEvenObjectList;
+ *phEventObjectList = (IMG_HANDLE *) psEventObjectList;
return PVRSRV_OK;
}
PVRSRV_ERROR LinuxEventObjectListDestroy(IMG_HANDLE hEventObjectList)
{
- PVRSRV_LINUX_EVENT_OBJECT_LIST *psEvenObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST *) hEventObjectList ;
+ PVRSRV_LINUX_EVENT_OBJECT_LIST *psEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST *) hEventObjectList ;
- if(psEvenObjectList)
+ if(psEventObjectList)
{
- if (!list_empty(&psEvenObjectList->sList))
+ IMG_BOOL bListEmpty;
+
+ read_lock(&psEventObjectList->sLock);
+ bListEmpty = list_empty(&psEventObjectList->sList);
+ read_unlock(&psEventObjectList->sLock);
+
+ if (!bListEmpty)
{
PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectListDestroy: Event List is not empty"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
}
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), psEvenObjectList, IMG_NULL);
+
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), psEventObjectList, IMG_NULL);
}
+
return PVRSRV_OK;
}
if(hOSEventObject)
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)hOSEventObject;
-#if defined(DEBUG_PVR)
- PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectListDelete: Event object waits: %lu", psLinuxEventObject->ui32Stats));
+#if defined(DEBUG)
+ PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectListDelete: Event object waits: %u", psLinuxEventObject->ui32Stats));
#endif
if(ResManFreeResByPtr(psLinuxEventObject->hResItem) != PVRSRV_OK)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
}
return PVRSRV_OK;
}
}
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
}
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = pvParam;
PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = psLinuxEventObject->psLinuxEventObjectList;
+ unsigned long ulLockFlags;
PVR_UNREFERENCED_PARAMETER(ui32Param);
- write_lock_bh(&psLinuxEventObjectList->sLock);
+ write_lock_irqsave(&psLinuxEventObjectList->sLock, ulLockFlags);
list_del(&psLinuxEventObject->sList);
- write_unlock_bh(&psLinuxEventObjectList->sLock);
+ write_unlock_irqrestore(&psLinuxEventObjectList->sLock, ulLockFlags);
-#if defined(DEBUG_PVR)
- PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectDeleteCallback: Event object waits: %lu", psLinuxEventObject->ui32Stats));
+#if defined(DEBUG)
+ PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectDeleteCallback: Event object waits: %u", psLinuxEventObject->ui32Stats));
#endif
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT), psLinuxEventObject, IMG_NULL);
PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST*)hOSEventObjectList;
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
PVRSRV_PER_PROCESS_DATA *psPerProc;
+ unsigned long ulLockFlags;
psPerProc = PVRSRVPerProcessData(ui32PID);
if (psPerProc == IMG_NULL)
atomic_set(&psLinuxEventObject->sTimeStamp, 0);
psLinuxEventObject->ui32TimeStampPrevious = 0;
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
psLinuxEventObject->ui32Stats = 0;
#endif
init_waitqueue_head(&psLinuxEventObject->sWait);
0,
&LinuxEventObjectDeleteCallback);
- write_lock_bh(&psLinuxEventObjectList->sLock);
+ write_lock_irqsave(&psLinuxEventObjectList->sLock, ulLockFlags);
list_add(&psLinuxEventObject->sList, &psLinuxEventObjectList->sList);
- write_unlock_bh(&psLinuxEventObjectList->sLock);
+ write_unlock_irqrestore(&psLinuxEventObjectList->sLock, ulLockFlags);
*phOSEventObject = psLinuxEventObject;
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject;
PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST*)hOSEventObjectList;
- struct list_head *psListEntry, *psListEntryTemp, *psList;
+ struct list_head *psListEntry, *psList;
+
psList = &psLinuxEventObjectList->sList;
- list_for_each_safe(psListEntry, psListEntryTemp, psList)
+
+ read_lock(&psLinuxEventObjectList->sLock);
+ list_for_each(psListEntry, psList)
{
psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)list_entry(psListEntry, PVRSRV_LINUX_EVENT_OBJECT, sList);
atomic_inc(&psLinuxEventObject->sTimeStamp);
wake_up_interruptible(&psLinuxEventObject->sWait);
}
+ read_unlock(&psLinuxEventObjectList->sLock);
return PVRSRV_OK;
do
{
prepare_to_wait(&psLinuxEventObject->sWait, &sWait, TASK_INTERRUPTIBLE);
- ui32TimeStamp = atomic_read(&psLinuxEventObject->sTimeStamp);
+ ui32TimeStamp = (IMG_UINT32)atomic_read(&psLinuxEventObject->sTimeStamp);
if(psLinuxEventObject->ui32TimeStampPrevious != ui32TimeStamp)
{
ui32TimeOutJiffies = (IMG_UINT32)schedule_timeout((IMG_INT32)ui32TimeOutJiffies);
LinuxLockMutex(&gPVRSRVLock);
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
psLinuxEventObject->ui32Stats++;
#endif
#
#
-MODULE ?= pvrsrvkm
+MODULE ?= $(PVRSRV_MODNAME)
MODULE_CFLAGS =
$(KBUILDROOT)/../services4/system/$(PVR_SYSTEM)/sysconfig.c \
$(KBUILDROOT)/../services4/system/$(PVR_SYSTEM)/sysutils.c \
$(KBUILDROOT)/srvkm/common/lists.c \
- $(KBUILDROOT)/srvkm/common/mem_debug.c
+ $(KBUILDROOT)/srvkm/common/mem_debug.c \
+ $(KBUILDROOT)/srvkm/common/osfunc_common.c
INCLUDES += -I$(EURASIAROOT)/services4/srvkm/hwdefs
$(KBUILDROOT)/srvkm/devices/vgx/vgxreset.c \
$(KBUILDROOT)/srvkm/devices/vgx/mmu.c \
$(KBUILDROOT)/srvkm/devices/vgx/pb.c \
- $(KBUILDROOT)/srvkm/env/linux/pdump_vgx.c
+ $(KBUILDROOT)/srvkm/devices/vgx/dma.c \
+ $(KBUILDROOT)/srvkm/devices/vgx/dmacbuff.c \
+ $(KBUILDROOT)/srvkm/devices/vgx/linkedlist.c
endif
endif # SUPPORT_SGX
include $(EURASIAROOT)/tools/intern/debug/dbgdriv/linux/makefile.linux.common
endif
+ifeq ($(SUPPORT_DRI_DRM_NOT_PCI),1)
+ INCLUDES += -I$(EURASIAROOT)/services4/3rdparty/linux_drm
+ KBUILD_EXTRA_SYMBOLS = $(EURASIAROOT)/services4/3rdparty/linux_drm/kbuild/Module.symvers
+endif
+
endif
ifeq ($(PVR_MODULE_TEST),1)
#define __LINKAGE_H__
#if !defined(SUPPORT_DRI_DRM)
-IMG_INT32 PVRSRV_BridgeDispatchKM(struct file *file, IMG_UINT cmd, IMG_UINT32 arg);
+long PVRSRV_BridgeDispatchKM(struct file *file, unsigned int cmd, unsigned long arg);
#endif
IMG_VOID PVRDPFInit(IMG_VOID);
+PVRSRV_ERROR PVROSFuncInit(IMG_VOID);
+IMG_VOID PVROSFuncDeInit(IMG_VOID);
-#ifdef DEBUG_PVR
-IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
-IMG_VOID PVRDebugSetLevel(IMG_UINT32 uDebugLevel);
+#ifdef DEBUG
-#ifdef PVR_PROC_USE_SEQ_FILE
+IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el);
-#else
-IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
-#endif
#ifdef PVR_MANUAL_POWER_CONTROL
IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
-#ifdef PVR_PROC_USE_SEQ_FILE
void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el);
-#else
-IMG_INT PVRProcGetPowerLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data);
-#endif
+#endif
-#endif
#endif
#endif
static IMG_CHAR *DebugMemAllocRecordTypeToString(DEBUG_MEM_ALLOC_TYPE eAllocType);
-#ifdef PVR_PROC_USE_SEQ_FILE
static struct proc_dir_entry *g_SeqFileMemoryRecords =0;
static void* ProcSeqNextMemoryRecords(struct seq_file *sfile,void* el,loff_t off);
static void ProcSeqShowMemoryRecords(struct seq_file *sfile,void* el);
static void* ProcSeqOff2ElementMemoryRecords(struct seq_file * sfile, loff_t off);
-#else
-static off_t printMemoryRecords(IMG_CHAR * buffer, size_t size, off_t off);
-#endif
-
#endif
-#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-static PVRSRV_LINUX_MUTEX g_sDebugMutex;
-#endif
static DEBUG_LINUX_MEM_AREA_REC *g_LinuxMemAreaRecords;
static IMG_UINT32 g_LinuxMemAreaCount;
static IMG_UINT32 g_LinuxMemAreaHighWaterMark;
-#ifdef PVR_PROC_USE_SEQ_FILE
static struct proc_dir_entry *g_SeqFileMemArea=0;
static void* ProcSeqNextMemArea(struct seq_file *sfile,void* el,loff_t off);
static void ProcSeqShowMemArea(struct seq_file *sfile,void* el);
static void* ProcSeqOff2ElementMemArea(struct seq_file *sfile, loff_t off);
-#else
-static off_t printLinuxMemAreaRecords(IMG_CHAR * buffer, size_t size, off_t off);
-#endif
+#endif
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+static PVRSRV_LINUX_MUTEX g_sDebugMutex;
#endif
-#ifdef PVR_PROC_USE_SEQ_FILE
#if (defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS))
static void ProcSeqStartstopDebugMutex(struct seq_file *sfile,IMG_BOOL start);
#endif
-#endif
static LinuxKMemCache *psLinuxMemAreaCache;
#if defined(DEBUG_LINUX_MEM_AREAS)
{
- IMG_INT iStatus;
-#ifdef PVR_PROC_USE_SEQ_FILE
g_SeqFileMemArea = CreateProcReadEntrySeq(
"mem_areas",
NULL,
ProcSeqOff2ElementMemArea,
ProcSeqStartstopDebugMutex
);
- iStatus = !g_SeqFileMemArea ? -1 : 0;
-#else
- iStatus = CreateProcReadEntry("mem_areas", printLinuxMemAreaRecords);
-#endif
- if(iStatus!=0)
+ if(!g_SeqFileMemArea)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
{
- IMG_INT iStatus;
-#ifdef PVR_PROC_USE_SEQ_FILE
g_SeqFileMemoryRecords =CreateProcReadEntrySeq(
"meminfo",
NULL,
ProcSeqOff2ElementMemoryRecords,
ProcSeqStartstopDebugMutex
);
-
- iStatus = !g_SeqFileMemoryRecords ? -1 : 0;
-#else
- iStatus = CreateProcReadEntry("meminfo", printMemoryRecords);
-#endif
- if(iStatus!=0)
+ if(!g_SeqFileMemoryRecords)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
}
#if defined(DEBUG_LINUX_MEM_AREAS)
-IMG_VOID LinuxMMCleanup_MemAreas_ForEachCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord)
+static IMG_VOID LinuxMMCleanup_MemAreas_ForEachCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord)
{
LinuxMemArea *psLinuxMemArea;
psLinuxMemArea = psCurrentRecord->psLinuxMemArea;
- PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up Linux memory area (%p), type=%s, size=%ld bytes",
+ PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up Linux memory area (%p), type=%s, size=%d bytes",
__FUNCTION__,
psCurrentRecord->psLinuxMemArea,
LinuxMemAreaTypeToString(psCurrentRecord->psLinuxMemArea->eAreaType),
#endif
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-IMG_VOID LinuxMMCleanup_MemRecords_ForEachVa(DEBUG_MEM_ALLOC_REC *psCurrentRecord)
+static IMG_VOID LinuxMMCleanup_MemRecords_ForEachVa(DEBUG_MEM_ALLOC_REC *psCurrentRecord)
{
PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: Cleaning up memory: "
"type=%s "
"CpuVAddr=%p "
- "CpuPAddr=0x%08lx, "
+ "CpuPAddr=0x%08x, "
"allocated @ file=%s,line=%d",
__FUNCTION__,
DebugMemAllocRecordTypeToString(psCurrentRecord->eAllocType),
{
if(g_LinuxMemAreaCount)
{
- PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: There are %d LinuxMemArea allocation unfreed (%ld bytes)",
+ PVR_DPF((PVR_DBG_ERROR, "%s: BUG!: There are %d LinuxMemArea allocation unfreed (%d bytes)",
__FUNCTION__, g_LinuxMemAreaCount, g_LinuxMemAreaWaterMark));
}
List_DEBUG_LINUX_MEM_AREA_REC_ForEach(g_LinuxMemAreaRecords,
LinuxMMCleanup_MemAreas_ForEachCb);
-#ifdef PVR_PROC_USE_SEQ_FILE
RemoveProcEntrySeq( g_SeqFileMemArea );
-#else
- RemoveProcEntry("mem_areas");
-#endif
}
#endif
List_DEBUG_MEM_ALLOC_REC_ForEach(g_MemoryRecords,
LinuxMMCleanup_MemRecords_ForEachVa);
-#ifdef PVR_PROC_USE_SEQ_FILE
RemoveProcEntrySeq( g_SeqFileMemoryRecords );
-#else
- RemoveProcEntry("meminfo");
-#endif
-
}
#endif
}
-IMG_BOOL DebugMemAllocRecordRemove_AnyVaCb(DEBUG_MEM_ALLOC_REC *psCurrentRecord, va_list va)
+static IMG_BOOL DebugMemAllocRecordRemove_AnyVaCb(DEBUG_MEM_ALLOC_REC *psCurrentRecord, va_list va)
{
DEBUG_MEM_ALLOC_TYPE eAllocType;
IMG_VOID *pvKey;
break;
default:
PVR_DPF((PVR_DBG_ERROR,
- "VMAllocWrapper: unknown mapping flags=0x%08lx",
+ "VMAllocWrapper: unknown mapping flags=0x%08x",
ui32AllocFlags));
dump_stack();
return NULL;
PVR_UNREFERENCED_PARAMETER(pszFileName);
PVR_UNREFERENCED_PARAMETER(ui32Line);
#endif
-
+
return pvRet;
}
psLinuxMemArea->uData.sVmalloc.pvVmallocAddress = pvCpuVAddr;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEM_AREAS)
DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
#endif
+
+ if(ui32AreaFlags & (PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_UNCACHED))
+ OSInvalidateCPUCacheRangeKM(psLinuxMemArea, pvCpuVAddr, ui32Bytes);
+
return psLinuxMemArea;
failed:
psLinuxMemArea->uData.sIORemap.CPUPhysAddr = BasePAddr;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEM_AREAS)
}
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
static IMG_BOOL
TreatExternalPagesAsContiguous(IMG_SYS_PHYADDR *psSysPhysAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig)
{
return IMG_TRUE;
}
+#endif
LinuxMemArea *NewExternalKVLinuxMemArea(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig, IMG_UINT32 ui32AreaFlags)
{
psLinuxMemArea->eAreaType = LINUX_MEM_AREA_EXTERNAL_KV;
psLinuxMemArea->uData.sExternalKV.pvExternalKV = pvCPUVAddr;
- psLinuxMemArea->uData.sExternalKV.bPhysContig = (IMG_BOOL)(bPhysContig || TreatExternalPagesAsContiguous(pBasePAddr, ui32Bytes, bPhysContig));
-
+ psLinuxMemArea->uData.sExternalKV.bPhysContig =
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+ (bPhysContig || TreatExternalPagesAsContiguous(pBasePAddr, ui32Bytes, bPhysContig))
+ ? IMG_TRUE : IMG_FALSE;
+#else
+ bPhysContig;
+#endif
if (psLinuxMemArea->uData.sExternalKV.bPhysContig)
{
psLinuxMemArea->uData.sExternalKV.uPhysAddr.SysPhysAddr = *pBasePAddr;
}
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEM_AREAS)
psLinuxMemArea->uData.sIO.CPUPhysAddr.uiAddr = BasePAddr.uiAddr;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
psLinuxMemArea->uData.sPageList.hBlockPageList = hBlockPageList;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
+
+ if(ui32AreaFlags & (PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_UNCACHED))
+ {
+ psLinuxMemArea->bNeedsCacheInvalidate = IMG_TRUE;
+ }
+
#if defined(DEBUG_LINUX_MEM_AREAS)
DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
#endif
{
IMG_VOID *pvRet;
- pvRet = kmem_cache_alloc(psCache, Flags);
+ pvRet = kmem_cache_zalloc(psCache, Flags);
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE,
psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset = ui32ByteOffset;
psLinuxMemArea->ui32ByteSize = ui32Bytes;
psLinuxMemArea->ui32AreaFlags = psParentLinuxMemArea->ui32AreaFlags;
- psLinuxMemArea->bMMapRegistered = IMG_FALSE;
+ psLinuxMemArea->bNeedsCacheInvalidate = psParentLinuxMemArea->bNeedsCacheInvalidate;
INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
#if defined(DEBUG_LINUX_MEM_AREAS)
}
-IMG_VOID
+static IMG_VOID
FreeSubLinuxMemArea(LinuxMemArea *psLinuxMemArea)
{
PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC);
if(strstr(pi8FlagsString, "UNKNOWN"))
{
PVR_DPF((PVR_DBG_ERROR,
- "%s: Unexpected flags (0x%08lx) associated with psLinuxMemArea @ 0x%08lx",
+ "%s: Unexpected flags (0x%08x) associated with psLinuxMemArea @ %p",
__FUNCTION__,
ui32Flags,
psLinuxMemArea));
-IMG_VOID* MatchLinuxMemArea_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord,
- va_list va)
+static IMG_VOID* MatchLinuxMemArea_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord,
+ va_list va)
{
LinuxMemArea *psLinuxMemArea;
break;
}
default:
+ {
PVR_DPF((PVR_DBG_ERROR, "%s: Unknown LinuxMemArea type (%d)\n",
__FUNCTION__, psLinuxMemArea->eAreaType));
- break;
+ PVR_ASSERT(CpuPAddr.uiAddr);
+ break;
+ }
}
- PVR_ASSERT(CpuPAddr.uiAddr);
return CpuPAddr;
}
}
-#ifdef PVR_PROC_USE_SEQ_FILE
#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
static void ProcSeqStartstopDebugMutex(struct seq_file *sfile, IMG_BOOL start)
{
}
}
#endif
-#endif
#if defined(DEBUG_LINUX_MEM_AREAS)
-IMG_VOID* DecOffMemAreaRec_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psNode, va_list va)
+static IMG_VOID* DecOffMemAreaRec_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psNode, va_list va)
{
off_t *pOff = va_arg(va, off_t*);
if (--(*pOff))
}
}
-#ifdef PVR_PROC_USE_SEQ_FILE
static void* ProcSeqNextMemArea(struct seq_file *sfile,void* el,loff_t off)
{
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
seq_printf( sfile,
- "Number of Linux Memory Areas: %lu\n"
- "At the current water mark these areas correspond to %lu bytes (excluding SUB areas)\n"
- "At the highest water mark these areas corresponded to %lu bytes (excluding SUB areas)\n"
+ "Number of Linux Memory Areas: %u\n"
+ "At the current water mark these areas correspond to %u bytes (excluding SUB areas)\n"
+ "At the highest water mark these areas corresponded to %u bytes (excluding SUB areas)\n"
"\nDetails for all Linux Memory Areas:\n"
"%s %-24s %s %s %-8s %-5s %s\n",
g_LinuxMemAreaCount,
#else
seq_printf( sfile,
"<mem_areas_header>\n"
- "\t<count>%lu</count>\n"
- "\t<watermark key=\"mar0\" description=\"current\" bytes=\"%lu\"/>\n"
- "\t<watermark key=\"mar1\" description=\"high\" bytes=\"%lu\"/>\n"
+ "\t<count>%u</count>\n"
+ "\t<watermark key=\"mar0\" description=\"current\" bytes=\"%u\"/>\n"
+ "\t<watermark key=\"mar1\" description=\"high\" bytes=\"%u\"/>\n"
"</mem_areas_header>\n",
g_LinuxMemAreaCount,
g_LinuxMemAreaWaterMark,
seq_printf( sfile,
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%8p %-24s %8p %08lx %-8ld %-5u %08lx=(%s)\n",
+ "%8p %-24s %8p %08x %-8d %-5u %08x=(%s)\n",
#else
"<linux_mem_area>\n"
"\t<pointer>%8p</pointer>\n"
"\t<type>%s</type>\n"
"\t<cpu_virtual>%8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
+ "\t<cpu_physical>%08x</cpu_physical>\n"
"\t<bytes>%ld</bytes>\n"
"\t<pid>%u</pid>\n"
"\t<flags>%08lx</flags>\n"
}
-#else
-
-static off_t
-printLinuxMemAreaRecords(IMG_CHAR * buffer, size_t count, off_t off)
-{
- DEBUG_LINUX_MEM_AREA_REC *psRecord;
- off_t Ret;
-
- LinuxLockMutex(&g_sDebugMutex);
-
- if(!off)
- {
- if(count < 500)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- Ret = printAppend(buffer, count, 0,
- "Number of Linux Memory Areas: %lu\n"
- "At the current water mark these areas correspond to %lu bytes (excluding SUB areas)\n"
- "At the highest water mark these areas corresponded to %lu bytes (excluding SUB areas)\n"
- "\nDetails for all Linux Memory Areas:\n"
- "%s %-24s %s %s %-8s %-5s %s\n",
- g_LinuxMemAreaCount,
- g_LinuxMemAreaWaterMark,
- g_LinuxMemAreaHighWaterMark,
- "psLinuxMemArea",
- "LinuxMemType",
- "CpuVAddr",
- "CpuPAddr",
- "Bytes",
- "Pid",
- "Flags"
- );
-#else
- Ret = printAppend(buffer, count, 0,
- "<mem_areas_header>\n"
- "\t<count>%lu</count>\n"
- "\t<watermark key=\"mar0\" description=\"current\" bytes=\"%lu\"/>\n"
- "\t<watermark key=\"mar1\" description=\"high\" bytes=\"%lu\"/>\n"
- "</mem_areas_header>\n",
- g_LinuxMemAreaCount,
- g_LinuxMemAreaWaterMark,
- g_LinuxMemAreaHighWaterMark
- );
-#endif
- goto unlock_and_return;
- }
-
- psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
- List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
- DecOffMemAreaRec_AnyVaCb,
- &off);
-
- if(!psRecord)
- {
- Ret = END_OF_FILE;
- goto unlock_and_return;
- }
-
- if(count < 500)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-
- Ret = printAppend(buffer, count, 0,
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%8p %-24s %8p %08lx %-8ld %-5u %08lx=(%s)\n",
-#else
- "<linux_mem_area>\n"
- "\t<pointer>%8p</pointer>\n"
- "\t<type>%s</type>\n"
- "\t<cpu_virtual>%8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<bytes>%ld</bytes>\n"
- "\t<pid>%u</pid>\n"
- "\t<flags>%08lx</flags>\n"
- "\t<flags_string>%s</flags_string>\n"
- "</linux_mem_area>\n",
-#endif
- psRecord->psLinuxMemArea,
- LinuxMemAreaTypeToString(psRecord->psLinuxMemArea->eAreaType),
- LinuxMemAreaToCpuVAddr(psRecord->psLinuxMemArea),
- LinuxMemAreaToCpuPAddr(psRecord->psLinuxMemArea,0).uiAddr,
- psRecord->psLinuxMemArea->ui32ByteSize,
- psRecord->pid,
- psRecord->ui32Flags,
- HAPFlagsToString(psRecord->ui32Flags)
- );
-
-unlock_and_return:
- LinuxUnLockMutex(&g_sDebugMutex);
- return Ret;
-}
-#endif
-
#endif
#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-IMG_VOID* DecOffMemAllocRec_AnyVaCb(DEBUG_MEM_ALLOC_REC *psNode, va_list va)
+static IMG_VOID* DecOffMemAllocRec_AnyVaCb(DEBUG_MEM_ALLOC_REC *psNode, va_list va)
{
off_t *pOff = va_arg(va, off_t*);
if (--(*pOff))
}
-#ifdef PVR_PROC_USE_SEQ_FILE
static void* ProcSeqNextMemoryRecords(struct seq_file *sfile,void* el,loff_t off)
{
{
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes allocated via kmalloc",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated via kmalloc",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes allocated via vmalloc",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated via vmalloc",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes allocated via alloc_pages",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated via alloc_pages",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes allocated via ioremap",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated via ioremap",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes reserved for \"IO\" memory areas",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated for \"IO\" memory areas",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Current Water Mark of bytes allocated via kmem_cache_alloc",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"Highest Water Mark of bytes allocated via kmem_cache_alloc",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
seq_printf( sfile, "\n");
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"The Current Water Mark for memory allocated from system RAM",
g_SysRAMWaterMark);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"The Highest Water Mark for memory allocated from system RAM",
g_SysRAMHighWaterMark);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"The Current Water Mark for memory allocated from IO memory",
g_IOMemWaterMark);
- seq_printf( sfile, "%-60s: %ld bytes\n",
+ seq_printf( sfile, "%-60s: %d bytes\n",
"The Highest Water Mark for memory allocated from IO memory",
g_IOMemHighWaterMark);
seq_printf( sfile, "<meminfo>\n<meminfo_header>\n");
seq_printf( sfile,
- "<watermark key=\"mr0\" description=\"kmalloc_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr0\" description=\"kmalloc_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
seq_printf( sfile,
- "<watermark key=\"mr1\" description=\"kmalloc_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr1\" description=\"kmalloc_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
seq_printf( sfile,
- "<watermark key=\"mr2\" description=\"vmalloc_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr2\" description=\"vmalloc_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
seq_printf( sfile,
- "<watermark key=\"mr3\" description=\"vmalloc_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr3\" description=\"vmalloc_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
seq_printf( sfile,
- "<watermark key=\"mr4\" description=\"alloc_pages_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr4\" description=\"alloc_pages_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
seq_printf( sfile,
- "<watermark key=\"mr5\" description=\"alloc_pages_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr5\" description=\"alloc_pages_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
seq_printf( sfile,
- "<watermark key=\"mr6\" description=\"ioremap_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr6\" description=\"ioremap_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
seq_printf( sfile,
- "<watermark key=\"mr7\" description=\"ioremap_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr7\" description=\"ioremap_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
seq_printf( sfile,
- "<watermark key=\"mr8\" description=\"io_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr8\" description=\"io_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
seq_printf( sfile,
- "<watermark key=\"mr9\" description=\"io_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr9\" description=\"io_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
seq_printf( sfile,
- "<watermark key=\"mr10\" description=\"kmem_cache_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr10\" description=\"kmem_cache_current\" bytes=\"%d\"/>\n",
g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
seq_printf( sfile,
- "<watermark key=\"mr11\" description=\"kmem_cache_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr11\" description=\"kmem_cache_high\" bytes=\"%d\"/>\n",
g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
seq_printf( sfile,"\n" );
seq_printf( sfile,
- "<watermark key=\"mr14\" description=\"system_ram_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr14\" description=\"system_ram_current\" bytes=\"%d\"/>\n",
g_SysRAMWaterMark);
seq_printf( sfile,
- "<watermark key=\"mr15\" description=\"system_ram_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr15\" description=\"system_ram_high\" bytes=\"%d\"/>\n",
g_SysRAMHighWaterMark);
seq_printf( sfile,
- "<watermark key=\"mr16\" description=\"system_io_current\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr16\" description=\"system_io_current\" bytes=\"%d\"/>\n",
g_IOMemWaterMark);
seq_printf( sfile,
- "<watermark key=\"mr17\" description=\"system_io_high\" bytes=\"%ld\"/>\n",
+ "<watermark key=\"mr17\" description=\"system_io_high\" bytes=\"%d\"/>\n",
g_IOMemHighWaterMark);
seq_printf( sfile, "</meminfo_header>\n");
{
seq_printf( sfile,
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
+ "%-16s %-8p %08x %-10d %-5d %-10s %s:%d\n",
#else
"<allocation>\n"
"\t<type>%s</type>\n"
"\t<cpu_virtual>%-8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<bytes>%ld</bytes>\n"
+ "\t<cpu_physical>%08x</cpu_physical>\n"
+ "\t<bytes>%d</bytes>\n"
"\t<pid>%d</pid>\n"
"\t<private>%s</private>\n"
"\t<filename>%s</filename>\n"
- "\t<line>%ld</line>\n"
+ "\t<line>%d</line>\n"
"</allocation>\n",
#endif
DebugMemAllocRecordTypeToString(psRecord->eAllocType),
{
seq_printf( sfile,
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
+ "%-16s %-8p %08x %-10d %-5d %-10s %s:%d\n",
#else
"<allocation>\n"
"\t<type>%s</type>\n"
"\t<cpu_virtual>%-8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<bytes>%ld</bytes>\n"
+ "\t<cpu_physical>%08x</cpu_physical>\n"
+ "\t<bytes>%d</bytes>\n"
"\t<pid>%d</pid>\n"
"\t<private>%s</private>\n"
"\t<filename>%s</filename>\n"
- "\t<line>%ld</line>\n"
+ "\t<line>%d</line>\n"
"</allocation>\n",
#endif
DebugMemAllocRecordTypeToString(psRecord->eAllocType),
}
}
-
-
-#else
-
-static off_t
-printMemoryRecords(IMG_CHAR * buffer, size_t count, off_t off)
-{
- DEBUG_MEM_ALLOC_REC *psRecord;
- off_t Ret;
-
- LinuxLockMutex(&g_sDebugMutex);
-
- if(!off)
- {
- if(count < 1000)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
-
- Ret = printAppend(buffer, count, 0, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes allocated via kmalloc",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated via kmalloc",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes allocated via vmalloc",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated via vmalloc",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes allocated via alloc_pages",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated via alloc_pages",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes allocated via ioremap",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated via ioremap",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes reserved for \"IO\" memory areas",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated for \"IO\" memory areas",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Current Water Mark of bytes allocated via kmem_cache_alloc",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "Highest Water Mark of bytes allocated via kmem_cache_alloc",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
- Ret = printAppend(buffer, count, Ret, "\n");
-
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "The Current Water Mark for memory allocated from system RAM",
- g_SysRAMWaterMark);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "The Highest Water Mark for memory allocated from system RAM",
- g_SysRAMHighWaterMark);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "The Current Water Mark for memory allocated from IO memory",
- g_IOMemWaterMark);
- Ret = printAppend(buffer, count, Ret, "%-60s: %ld bytes\n",
- "The Highest Water Mark for memory allocated from IO memory",
- g_IOMemHighWaterMark);
-
- Ret = printAppend(buffer, count, Ret, "\n");
-
- Ret = printAppend(buffer, count, Ret, "Details for all known allocations:\n"
- "%-16s %-8s %-8s %-10s %-5s %-10s %s\n",
- "Type",
- "CpuVAddr",
- "CpuPAddr",
- "Bytes",
- "PID",
- "PrivateData",
- "Filename:Line");
-
-#else
-
-
- Ret = printAppend(buffer, count, 0, "<meminfo>\n<meminfo_header>\n");
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr0\" description=\"kmalloc_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr1\" description=\"kmalloc_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr2\" description=\"vmalloc_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr3\" description=\"vmalloc_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr4\" description=\"alloc_pages_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr5\" description=\"alloc_pages_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr6\" description=\"ioremap_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr7\" description=\"ioremap_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr8\" description=\"io_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr9\" description=\"io_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr10\" description=\"kmem_cache_current\" bytes=\"%ld\"/>\n",
- g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr11\" description=\"kmem_cache_high\" bytes=\"%ld\"/>\n",
- g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE]);
- Ret = printAppend(buffer, count, Ret, "\n");
-
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr14\" description=\"system_ram_current\" bytes=\"%ld\"/>\n",
- g_SysRAMWaterMark);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr15\" description=\"system_ram_high\" bytes=\"%ld\"/>\n",
- g_SysRAMHighWaterMark);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr16\" description=\"system_io_current\" bytes=\"%ld\"/>\n",
- g_IOMemWaterMark);
- Ret = printAppend(buffer, count, Ret,
- "<watermark key=\"mr17\" description=\"system_io_high\" bytes=\"%ld\"/>\n",
- g_IOMemHighWaterMark);
-
- Ret = printAppend(buffer, count, Ret, "</meminfo_header>\n");
-
-#endif
-
- goto unlock_and_return;
- }
-
- if(count < 1000)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-
- psRecord = (DEBUG_MEM_ALLOC_REC*)
- List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
- DecOffMemAllocRec_AnyVaCb,
- &off);
- if(!psRecord)
- {
-#if defined(DEBUG_LINUX_XML_PROC_FILES)
- if(off == 0)
- {
- Ret = printAppend(buffer, count, 0, "</meminfo>\n");
- goto unlock_and_return;
- }
-#endif
- Ret = END_OF_FILE;
- goto unlock_and_return;
- }
-
- if(psRecord->eAllocType != DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
- {
- Ret = printAppend(buffer, count, 0,
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
-#else
- "<allocation>\n"
- "\t<type>%s</type>\n"
- "\t<cpu_virtual>%-8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<bytes>%ld</bytes>\n"
- "\t<pid>%d</pid>\n"
- "\t<private>%s</private>\n"
- "\t<filename>%s</filename>\n"
- "\t<line>%ld</line>\n"
- "</allocation>\n",
-#endif
- DebugMemAllocRecordTypeToString(psRecord->eAllocType),
- psRecord->pvCpuVAddr,
- psRecord->ulCpuPAddr,
- psRecord->ui32Bytes,
- psRecord->pid,
- "NULL",
- psRecord->pszFileName,
- psRecord->ui32Line);
- }
- else
- {
- Ret = printAppend(buffer, count, 0,
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-16s %-8p %08lx %-10ld %-5d %-10s %s:%ld\n",
-#else
- "<allocation>\n"
- "\t<type>%s</type>\n"
- "\t<cpu_virtual>%-8p</cpu_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<bytes>%ld</bytes>\n"
- "\t<pid>%d</pid>\n"
- "\t<private>%s</private>\n"
- "\t<filename>%s</filename>\n"
- "\t<line>%ld</line>\n"
- "</allocation>\n",
-#endif
- DebugMemAllocRecordTypeToString(psRecord->eAllocType),
- psRecord->pvCpuVAddr,
- psRecord->ulCpuPAddr,
- psRecord->ui32Bytes,
- psRecord->pid,
- KMemCacheNameWrapper(psRecord->pvPrivateData),
- psRecord->pszFileName,
- psRecord->ui32Line);
- }
-
-unlock_and_return:
- LinuxUnLockMutex(&g_sDebugMutex);
- return Ret;
-}
-#endif
#endif
IMG_BOOL bMMapRegistered;
+ IMG_BOOL bNeedsCacheInvalidate;
+
struct list_head sMMapItem;
const IMG_CHAR *LinuxMemAreaTypeToString(LINUX_MEM_AREA_TYPE eMemAreaType);
-#if defined(DEBUG_PVR) || defined(DEBUG_LINUX_MEM_AREAS)
+#if defined(DEBUG) || defined(DEBUG_LINUX_MEM_AREAS)
const IMG_CHAR *HAPFlagsToString(IMG_UINT32 ui32Flags);
#endif
#endif
-#if defined(PVR_PROC_USE_SEQ_FILE) && defined(DEBUG_LINUX_MMAP_AREAS)
+#if defined(DEBUG_LINUX_MMAP_AREAS)
static struct proc_dir_entry *g_ProcMMap;
#endif
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+#define MMAP2_PGOFF_RESOLUTION (32-PAGE_SHIFT+12)
+#define RESERVED_PGOFF_BITS 1
+#define MAX_MMAP_HANDLE ((1UL<<(MMAP2_PGOFF_RESOLUTION-RESERVED_PGOFF_BITS))-1)
+
#define FIRST_PHYSICAL_PFN 0
-#define LAST_PHYSICAL_PFN 0x7fffffffUL
+#define LAST_PHYSICAL_PFN (FIRST_PHYSICAL_PFN + MAX_MMAP_HANDLE)
#define FIRST_SPECIAL_PFN (LAST_PHYSICAL_PFN + 1)
-#define LAST_SPECIAL_PFN 0xffffffffUL
+#define LAST_SPECIAL_PFN (FIRST_SPECIAL_PFN + MAX_MMAP_HANDLE)
+
+#else
+
+#if PAGE_SHIFT != 12
+#error This build variant has not yet been made non-4KB page-size aware
+#endif
+#if defined(PVR_MMAP_OFFSET_BASE)
+#define FIRST_SPECIAL_PFN PVR_MMAP_OFFSET_BASE
+#else
+#define FIRST_SPECIAL_PFN 0x80000000UL
+#endif
+
+#if defined(PVR_NUM_MMAP_HANDLES)
+#define MAX_MMAP_HANDLE PVR_NUM_MMAP_HANDLES
+#else
#define MAX_MMAP_HANDLE 0x7fffffffUL
+#endif
+
+#endif
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
static inline IMG_BOOL
PFNIsPhysical(IMG_UINT32 pfn)
{
-
- return ((pfn >= FIRST_PHYSICAL_PFN) && (pfn <= LAST_PHYSICAL_PFN)) ? IMG_TRUE : IMG_FALSE;
+
+ return ( (pfn <= LAST_PHYSICAL_PFN)) ? IMG_TRUE : IMG_FALSE;
}
static inline IMG_BOOL
PFNIsSpecial(IMG_UINT32 pfn)
{
-
- return ((pfn >= FIRST_SPECIAL_PFN) && (pfn <= LAST_SPECIAL_PFN)) ? IMG_TRUE : IMG_FALSE;
+
+ return ((pfn >= FIRST_SPECIAL_PFN) ) ? IMG_TRUE : IMG_FALSE;
}
+#endif
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
static inline IMG_HANDLE
MMapOffsetToHandle(IMG_UINT32 pfn)
{
PVR_ASSERT(PFNIsPhysical(pfn));
return IMG_NULL;
}
-
return (IMG_HANDLE)(pfn - FIRST_SPECIAL_PFN);
}
+#endif
static inline IMG_UINT32
HandleToMMapOffset(IMG_HANDLE hHandle)
{
IMG_UINT32 ulHandle = (IMG_UINT32)hHandle;
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
if (PFNIsSpecial(ulHandle))
{
PVR_ASSERT(PFNIsSpecial(ulHandle));
return 0;
}
-
+#endif
return ulHandle + FIRST_SPECIAL_PFN;
}
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
static inline IMG_BOOL
LinuxMemAreaUsesPhysicalMap(LinuxMemArea *psLinuxMemArea)
{
return LinuxMemAreaPhysIsContig(psLinuxMemArea);
}
+#endif
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
static inline IMG_UINT32
GetCurrentThreadID(IMG_VOID)
{
return (IMG_UINT32)current->pid;
}
+#endif
static PKV_OFFSET_STRUCT
CreateOffsetStruct(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Offset, IMG_UINT32 ui32RealByteSize)
#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
- "%s(%s, psLinuxMemArea: 0x%p, ui32AllocFlags: 0x%8lx)",
+ "%s(%s, psLinuxMemArea: 0x%p, ui32AllocFlags: 0x%8x)",
__FUNCTION__, pszName, psLinuxMemArea, psLinuxMemArea->ui32AreaFlags));
#endif
psOffsetStruct->psLinuxMemArea = psLinuxMemArea;
- psOffsetStruct->ui32Mapped = 0;
-
psOffsetStruct->ui32RealByteSize = ui32RealByteSize;
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
psOffsetStruct->ui32TID = GetCurrentThreadID();
-
+#endif
psOffsetStruct->ui32PID = OSGetCurrentProcessIDKM();
- psOffsetStruct->bOnMMapList = IMG_FALSE;
-
- psOffsetStruct->ui32RefCount = 0;
-
- psOffsetStruct->ui32UserVAddr = 0;
-
#if defined(DEBUG_LINUX_MMAP_AREAS)
psOffsetStruct->pszName = pszName;
static IMG_VOID
DestroyOffsetStruct(PKV_OFFSET_STRUCT psOffsetStruct)
{
+#ifdef DEBUG
+ IMG_CPU_PHYADDR CpuPAddr;
+ CpuPAddr = LinuxMemAreaToCpuPAddr(psOffsetStruct->psLinuxMemArea, 0);
+#endif
+
list_del(&psOffsetStruct->sAreaItem);
if (psOffsetStruct->bOnMMapList)
list_del(&psOffsetStruct->sMMapItem);
}
+#ifdef DEBUG
PVR_DPF((PVR_DBG_MESSAGE, "%s: Table entry: "
- "psLinuxMemArea=0x%08lX, CpuPAddr=0x%08lX", __FUNCTION__,
+ "psLinuxMemArea=%p, CpuPAddr=0x%08X", __FUNCTION__,
psOffsetStruct->psLinuxMemArea,
- LinuxMemAreaToCpuPAddr(psOffsetStruct->psLinuxMemArea, 0)));
+ CpuPAddr.uiAddr));
+#endif
KMemCacheFreeWrapper(g_psMemmapCache, psOffsetStruct);
}
eError = PVRSRVLookupOSMemHandle(psPerProc->psHandleBase, &hOSMemHandle, hMHandle);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle 0x%lx failed", __FUNCTION__, hMHandle));
+ PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle %p failed", __FUNCTION__, hMHandle));
goto exit_unlock;
}
*pui32UserVAddr = 0;
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
if (LinuxMemAreaUsesPhysicalMap(psLinuxMemArea))
{
*pui32MMapOffset = LinuxMemAreaToCpuPFN(psLinuxMemArea, 0);
PVR_ASSERT(PFNIsPhysical(*pui32MMapOffset));
}
else
+#endif
{
*pui32MMapOffset = HandleToMMapOffset(hMHandle);
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
PVR_ASSERT(PFNIsSpecial(*pui32MMapOffset));
+#endif
}
psOffsetStruct = CreateOffsetStruct(psLinuxMemArea, *pui32MMapOffset, *pui32RealByteSize);
eError = PVRSRV_OK;
+
+
+
+ *pui32MMapOffset = *pui32MMapOffset << (PAGE_SHIFT - 12);
+
exit_unlock:
LinuxUnLockMutex(&g_sMMapMutex);
eError = PVRSRVLookupOSMemHandle(psPerProc->psHandleBase, &hOSMemHandle, hMHandle);
if (eError != PVRSRV_OK)
{
- PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle 0x%lx failed", __FUNCTION__, hMHandle));
+ PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle %p failed", __FUNCTION__, hMHandle));
goto exit_unlock;
}
{
if (psOffsetStruct->ui32RefCount == 0)
{
- PVR_DPF((PVR_DBG_ERROR, "%s: Attempt to release mmap data with zero reference count for offset struct 0x%p, memory area 0x%p", __FUNCTION__, psOffsetStruct, psLinuxMemArea));
- eError = PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR, "%s: Attempt to release mmap data with zero reference count for offset struct 0x%p, memory area %p", __FUNCTION__, psOffsetStruct, psLinuxMemArea));
+ eError = PVRSRV_ERROR_STILL_MAPPED;
goto exit_unlock;
}
}
- PVR_DPF((PVR_DBG_ERROR, "%s: Mapping data not found for handle 0x%lx (memory area 0x%p)", __FUNCTION__, hMHandle, psLinuxMemArea));
+ PVR_DPF((PVR_DBG_ERROR, "%s: Mapping data not found for handle %p (memory area %p)", __FUNCTION__, hMHandle, psLinuxMemArea));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_MAPPING_NOT_FOUND;
exit_unlock:
LinuxUnLockMutex(&g_sMMapMutex);
FindOffsetStructByOffset(IMG_UINT32 ui32Offset, IMG_UINT32 ui32RealByteSize)
{
PKV_OFFSET_STRUCT psOffsetStruct;
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
IMG_UINT32 ui32TID = GetCurrentThreadID();
+#endif
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
list_for_each_entry(psOffsetStruct, &g_sMMapOffsetStructList, sMMapItem)
{
if (ui32Offset == psOffsetStruct->ui32MMapOffset && ui32RealByteSize == psOffsetStruct->ui32RealByteSize && psOffsetStruct->ui32PID == ui32PID)
{
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
if (!PFNIsPhysical(ui32Offset) || psOffsetStruct->ui32TID == ui32TID)
+#endif
{
return psOffsetStruct;
}
#error "SPARC not supported"
#endif
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
if (PFNIsPhysical(ps_vma->vm_pgoff))
{
IMG_INT result;
PVR_ASSERT(LinuxMemAreaPhysIsContig(psLinuxMemArea));
PVR_ASSERT(LinuxMemAreaToCpuPFN(psLinuxMemArea, ui32ByteOffset) == ps_vma->vm_pgoff);
-
result = IO_REMAP_PFN_RANGE(ps_vma, ps_vma->vm_start, ps_vma->vm_pgoff, ui32ByteSize, ps_vma->vm_page_prot);
PVR_DPF((PVR_DBG_MESSAGE, "%s: Failed to map contiguous physical address range (%d), trying non-contiguous path", __FUNCTION__, result));
}
+#endif
{
IMG_UINT32 ulVMAPos;
IMG_UINT32 ui32ByteEnd = ui32ByteOffset + ui32ByteSize;
IMG_UINT32 ui32PA;
-
+#if defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+ IMG_BOOL bMixedMap = IMG_FALSE;
+#endif
for(ui32PA = ui32ByteOffset; ui32PA < ui32ByteEnd; ui32PA += PAGE_SIZE)
{
if (!pfn_valid(pfn))
{
- PVR_DPF((PVR_DBG_ERROR,"%s: Error - PFN invalid: 0x%lx", __FUNCTION__, pfn));
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+ PVR_DPF((PVR_DBG_ERROR,"%s: Error - PFN invalid: 0x%x", __FUNCTION__, pfn));
return IMG_FALSE;
+#else
+ bMixedMap = IMG_TRUE;
+#endif
}
}
+#if defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+ if (bMixedMap)
+ {
+ ps_vma->vm_flags |= VM_MIXEDMAP;
+ }
+#endif
ulVMAPos = ps_vma->vm_start;
for(ui32PA = ui32ByteOffset; ui32PA < ui32ByteEnd; ui32PA += PAGE_SIZE)
{
IMG_UINT32 pfn;
- struct page *psPage;
IMG_INT result;
pfn = LinuxMemAreaToCpuPFN(psLinuxMemArea, ui32PA);
- PVR_ASSERT(pfn_valid(pfn));
- psPage = pfn_to_page(pfn);
+#if defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+ if (bMixedMap)
+ {
+ result = vm_insert_mixed(ps_vma, ulVMAPos, pfn);
+ if(result != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"%s: Error - vm_insert_mixed failed (%d)", __FUNCTION__, result));
+ return IMG_FALSE;
+ }
+ }
+ else
+#endif
+ {
+ struct page *psPage;
+
+ PVR_ASSERT(pfn_valid(pfn));
- result = VM_INSERT_PAGE(ps_vma, ulVMAPos, psPage);
- if(result != 0)
- {
- PVR_DPF((PVR_DBG_ERROR,"%s: Error - VM_INSERT_PAGE failed (%d)", __FUNCTION__, result));
- return IMG_FALSE;
- }
+ psPage = pfn_to_page(pfn);
+
+ result = VM_INSERT_PAGE(ps_vma, ulVMAPos, psPage);
+ if(result != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"%s: Error - VM_INSERT_PAGE failed (%d)", __FUNCTION__, result));
+ return IMG_FALSE;
+ }
+ }
ulVMAPos += PAGE_SIZE;
}
}
if (psOffsetStruct->ui32Mapped > 1)
{
- PVR_DPF((PVR_DBG_WARNING, "%s: Offset structure 0x%p is being shared across processes (psOffsetStruct->ui32Mapped: %lu)", __FUNCTION__, psOffsetStruct, psOffsetStruct->ui32Mapped));
+ PVR_DPF((PVR_DBG_WARNING, "%s: Offset structure 0x%p is being shared across processes (psOffsetStruct->ui32Mapped: %u)", __FUNCTION__, psOffsetStruct, psOffsetStruct->ui32Mapped));
PVR_ASSERT((ps_vma->vm_flags & VM_DONTCOPY) == 0);
}
#if defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
- "%s: psLinuxMemArea 0x%p, KVAddress 0x%p MMapOffset %ld, ui32Mapped %d",
+ "%s: psLinuxMemArea 0x%p, KVAddress 0x%p MMapOffset %d, ui32Mapped %d",
__FUNCTION__,
psOffsetStruct->psLinuxMemArea,
LinuxMemAreaToCpuVAddr(psOffsetStruct->psLinuxMemArea),
#if defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
- "%s: psLinuxMemArea 0x%p, CpuVAddr 0x%p ui32MMapOffset %ld, ui32Mapped %d",
+ "%s: psLinuxMemArea %p, CpuVAddr %p ui32MMapOffset %d, ui32Mapped %d",
__FUNCTION__,
psOffsetStruct->psLinuxMemArea,
LinuxMemAreaToCpuVAddr(psOffsetStruct->psLinuxMemArea),
{
if (psOffsetStruct->ui32RefCount != 0)
{
- PVR_DPF((PVR_DBG_MESSAGE, "%s: psOffsetStruct 0x%p has non-zero reference count (ui32RefCount = %lu). User mode address of start of mapping: 0x%lx", __FUNCTION__, psOffsetStruct, psOffsetStruct->ui32RefCount, psOffsetStruct->ui32UserVAddr));
+ PVR_DPF((PVR_DBG_MESSAGE, "%s: psOffsetStruct %p has non-zero reference count (ui32RefCount = %u). User mode address of start of mapping: 0x%x", __FUNCTION__, psOffsetStruct, psOffsetStruct->ui32RefCount, psOffsetStruct->ui32UserVAddr));
}
DestroyOffsetStruct(psOffsetStruct);
ui32ByteSize = ps_vma->vm_end - ps_vma->vm_start;
PVR_DPF((PVR_DBG_MESSAGE, "%s: Received mmap(2) request with ui32MMapOffset 0x%08lx,"
- " and ui32ByteSize %ld(0x%08lx)",
+ " and ui32ByteSize %d(0x%08x)",
__FUNCTION__,
ps_vma->vm_pgoff,
ui32ByteSize, ui32ByteSize));
#if defined(SUPPORT_DRI_DRM)
LinuxUnLockMutex(&g_sMMapMutex);
+#if !defined(SUPPORT_DRI_DRM_EXT)
return drm_mmap(pFile, ps_vma);
+#else
+
+ return -ENOENT;
+#endif
#else
PVR_UNREFERENCED_PARAMETER(pFile);
PVR_DPF((PVR_DBG_ERROR,
- "%s: Attempted to mmap unregistered area at vm_pgoff %ld",
+ "%s: Attempted to mmap unregistered area at vm_pgoff 0x%lx",
__FUNCTION__, ps_vma->vm_pgoff));
iRetVal = -EINVAL;
#endif
psOffsetStruct->ui32UserVAddr = ps_vma->vm_start;
+ if(psOffsetStruct->psLinuxMemArea->bNeedsCacheInvalidate)
+ {
+ IMG_UINT32 ui32RealByteSize, ui32ByteOffset;
+ IMG_VOID *pvBase;
+
+ DetermineUsersSizeAndByteOffset(psOffsetStruct->psLinuxMemArea,
+ &ui32RealByteSize,
+ &ui32ByteOffset);
+
+ ui32RealByteSize = psOffsetStruct->psLinuxMemArea->ui32ByteSize;
+ pvBase = (IMG_VOID *)ps_vma->vm_start + ui32ByteOffset;
+
+ OSInvalidateCPUCacheRangeKM(psOffsetStruct->psLinuxMemArea,
+ pvBase, ui32RealByteSize);
+ psOffsetStruct->psLinuxMemArea->bNeedsCacheInvalidate = IMG_FALSE;
+ }
+
+
MMapVOpenNoLock(ps_vma);
PVR_DPF((PVR_DBG_MESSAGE, "%s: Mapped area at offset 0x%08lx\n",
#if defined(DEBUG_LINUX_MMAP_AREAS)
-#ifdef PVR_PROC_USE_SEQ_FILE
-
static void ProcSeqStartstopMMapRegistations(struct seq_file *sfile,IMG_BOOL start)
{
if(start)
}
-static void ProcSeqShowMMapRegistrations(struct seq_file *sfile,void* el)
+static void ProcSeqShowMMapRegistrations(struct seq_file *sfile, void *el)
{
KV_OFFSET_STRUCT *psOffsetStruct = (KV_OFFSET_STRUCT*)el;
LinuxMemArea *psLinuxMemArea;
{
seq_printf( sfile,
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "Allocations registered for mmap: %lu\n"
- "In total these areas correspond to %lu bytes\n"
+ "Allocations registered for mmap: %u\n"
+ "In total these areas correspond to %u bytes\n"
"psLinuxMemArea "
"UserVAddr "
"KernelVAddr "
"Pid Name Flags\n",
#else
"<mmap_header>\n"
- "\t<count>%lu</count>\n"
- "\t<bytes>%lu</bytes>\n"
+ "\t<count>%u</count>\n"
+ "\t<bytes>%u</bytes>\n"
"</mmap_header>\n",
#endif
g_ui32RegisteredAreas,
seq_printf( sfile,
#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-8p %08lx %-8p %08lx %08lx %-8ld %-24s %-5lu %-8s %08lx(%s)\n",
+ "%-8p %08x %-8p %08x %08x %-8d %-24s %-5u %-8s %08x(%s)\n",
#else
"<mmap_record>\n"
"\t<pointer>%-8p</pointer>\n"
- "\t<user_virtual>%-8lx</user_virtual>\n"
+ "\t<user_virtual>%-8x</user_virtual>\n"
"\t<kernel_virtual>%-8p</kernel_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<mmap_offset>%08lx</mmap_offset>\n"
- "\t<bytes>%-8ld</bytes>\n"
+ "\t<cpu_physical>%08x</cpu_physical>\n"
+ "\t<mmap_offset>%08x</mmap_offset>\n"
+ "\t<bytes>%-8d</bytes>\n"
"\t<linux_mem_area_type>%-24s</linux_mem_area_type>\n"
- "\t<pid>%-5lu</pid>\n"
+ "\t<pid>%-5u</pid>\n"
"\t<name>%-8s</name>\n"
- "\t<flags>%08lx</flags>\n"
+ "\t<flags>%08x</flags>\n"
"\t<flags_string>%s</flags_string>\n"
"</mmap_record>\n",
#endif
HAPFlagsToString(psLinuxMemArea->ui32AreaFlags));
}
-#else
-
-static off_t
-PrintMMapRegistrations(IMG_CHAR *buffer, size_t size, off_t off)
-{
- LinuxMemArea *psLinuxMemArea;
- off_t Ret;
-
- LinuxLockMutex(&g_sMMapMutex);
-
- if(!off)
- {
- Ret = printAppend(buffer, size, 0,
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "Allocations registered for mmap: %lu\n"
- "In total these areas correspond to %lu bytes\n"
- "psLinuxMemArea "
- "UserVAddr "
- "KernelVAddr "
- "CpuPAddr "
- "MMapOffset "
- "ByteLength "
- "LinuxMemType "
- "Pid Name Flags\n",
-#else
- "<mmap_header>\n"
- "\t<count>%lu</count>\n"
- "\t<bytes>%lu</bytes>\n"
- "</mmap_header>\n",
-#endif
- g_ui32RegisteredAreas,
- g_ui32TotalByteSize
- );
-
- goto unlock_and_return;
- }
-
- if (size < 135)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-
- PVR_ASSERT(off != 0);
- list_for_each_entry(psLinuxMemArea, &g_sMMapAreaList, sMMapItem)
- {
- PKV_OFFSET_STRUCT psOffsetStruct;
-
- list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
- {
- off--;
- if (off == 0)
- {
- IMG_UINT32 ui32RealByteSize;
- IMG_UINT32 ui32ByteOffset;
-
- PVR_ASSERT(psOffsetStruct->psLinuxMemArea == psLinuxMemArea);
-
- DetermineUsersSizeAndByteOffset(psLinuxMemArea,
- &ui32RealByteSize,
- &ui32ByteOffset);
-
- Ret = printAppend (buffer, size, 0,
-#if !defined(DEBUG_LINUX_XML_PROC_FILES)
- "%-8p %08lx %-8p %08lx %08lx %-8ld %-24s %-5lu %-8s %08lx(%s)\n",
-#else
- "<mmap_record>\n"
- "\t<pointer>%-8p</pointer>\n"
- "\t<user_virtual>%-8lx</user_virtual>\n"
- "\t<kernel_virtual>%-8p</kernel_virtual>\n"
- "\t<cpu_physical>%08lx</cpu_physical>\n"
- "\t<mmap_offset>%08lx</mmap_offset>\n"
- "\t<bytes>%-8ld</bytes>\n"
- "\t<linux_mem_area_type>%-24s</linux_mem_area_type>\n"
- "\t<pid>%-5lu</pid>\n"
- "\t<name>%-8s</name>\n"
- "\t<flags>%08lx</flags>\n"
- "\t<flags_string>%s</flags_string>\n"
- "</mmap_record>\n",
-#endif
- psLinuxMemArea,
- psOffsetStruct->ui32UserVAddr + ui32ByteOffset,
- LinuxMemAreaToCpuVAddr(psLinuxMemArea),
- LinuxMemAreaToCpuPAddr(psLinuxMemArea,0).uiAddr,
- psOffsetStruct->ui32MMapOffset,
- psLinuxMemArea->ui32ByteSize,
- LinuxMemAreaTypeToString(psLinuxMemArea->eAreaType),
- psOffsetStruct->ui32PID,
- psOffsetStruct->pszName,
- psLinuxMemArea->ui32AreaFlags,
- HAPFlagsToString(psLinuxMemArea->ui32AreaFlags));
- goto unlock_and_return;
- }
- }
- }
- Ret = END_OF_FILE;
-
-unlock_and_return:
- LinuxUnLockMutex(&g_sMMapMutex);
- return Ret;
-}
-#endif
#endif
#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
PVR_DPF((PVR_DBG_MESSAGE,
- "%s(%s, psLinuxMemArea 0x%p, ui32AllocFlags 0x%8lx)",
+ "%s(%s, psLinuxMemArea 0x%p, ui32AllocFlags 0x%8x)",
__FUNCTION__, pszName, psLinuxMemArea, psLinuxMemArea->ui32AreaFlags));
#endif
{
if (psOffsetStruct->ui32Mapped != 0)
{
- PVR_DPF((PVR_DBG_ERROR, "%s: psOffsetStruct 0x%p for memory area 0x0x%p is still mapped; psOffsetStruct->ui32Mapped %lu", __FUNCTION__, psOffsetStruct, psLinuxMemArea, psOffsetStruct->ui32Mapped));
- eError = PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR, "%s: psOffsetStruct 0x%p for memory area 0x0x%p is still mapped; psOffsetStruct->ui32Mapped %u", __FUNCTION__, psOffsetStruct, psLinuxMemArea, psOffsetStruct->ui32Mapped));
+ eError = PVRSRV_ERROR_STILL_MAPPED;
goto exit_unlock;
}
else
}
#if defined(DEBUG_LINUX_MMAP_AREAS)
-#ifdef PVR_PROC_USE_SEQ_FILE
g_ProcMMap = CreateProcReadEntrySeq("mmap", NULL,
ProcSeqNextMMapRegistrations,
ProcSeqShowMMapRegistrations,
ProcSeqOff2ElementMMapRegistrations,
ProcSeqStartstopMMapRegistations
);
-#else
- CreateProcReadEntry("mmap", PrintMMapRegistrations);
-#endif
#endif
return;
PVR_ASSERT(list_empty((&g_sMMapAreaList)));
#if defined(DEBUG_LINUX_MMAP_AREAS)
-#ifdef PVR_PROC_USE_SEQ_FILE
RemoveProcEntrySeq(g_ProcMMap);
-#else
- RemoveProcEntry("mmap");
-#endif
#endif
if(g_psMemmapCache)
#include <linux/mm.h>
#include <linux/list.h>
+#if defined(VM_MIXEDMAP)
+#define PVR_MAKE_ALL_PFNS_SPECIAL
+#endif
+
#include "perproc.h"
#include "mm.h"
LinuxMemArea *psLinuxMemArea;
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
IMG_UINT32 ui32TID;
+#endif
IMG_UINT32 ui32PID;
#if defined(SUPPORT_DRI_DRM)
#include <drm/drmP.h>
+#if defined(PVR_SECURE_DRM_AUTH_EXPORT)
+#include "env_perproc.h"
+#endif
#endif
#if defined(PVR_LDM_PLATFORM_MODULE)
#include <linux/pci.h>
#endif
-#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
#include <asm/uaccess.h>
#endif
#if defined(SUPPORT_DRI_DRM)
#include "pvr_drm.h"
#endif
-#define DRVNAME "pvrsrvkm"
-#define DEVNAME "pvrsrvkm"
+#define DRVNAME PVRSRV_MODNAME
+#define DEVNAME PVRSRV_MODNAME
#if defined(SUPPORT_DRI_DRM)
#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
#endif
MODULE_SUPPORTED_DEVICE(DEVNAME);
-#ifdef DEBUG_PVR
-static IMG_INT debug = DBGPRIV_WARNING;
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
-#include <linux/moduleparam.h>
-module_param(debug, int, 0);
-#else
-MODULE_PARM(debug, "i");
-MODULE_PARM_DESC(debug, "Sets the level of debug output (default=0x4)");
-#endif
-#endif
+#if defined(PVRSRV_NEED_PVR_DPF)
+#include <linux/moduleparam.h>
+extern IMG_UINT32 gPVRDebugLevel;
+module_param(gPVRDebugLevel, uint, 0644);
+MODULE_PARM_DESC(gPVRDebugLevel, "Sets the level of debug output (default 0x7)");
+#endif
-extern IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
-extern IMG_BOOL PVRGetBufferClassJTable(PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable);
EXPORT_SYMBOL(PVRGetDisplayClassJTable);
EXPORT_SYMBOL(PVRGetBufferClassJTable);
-
#if defined(PVR_LDM_MODULE)
static struct class *psPvrClass;
#endif
#if !defined(SUPPORT_DRI_DRM)
-static IMG_INT AssignedMajorNumber;
+static int AssignedMajorNumber;
-static IMG_INT PVRSRVOpen(struct inode* pInode, struct file* pFile);
-static IMG_INT PVRSRVRelease(struct inode* pInode, struct file* pFile);
+static int PVRSRVOpen(struct inode* pInode, struct file* pFile);
+static int PVRSRVRelease(struct inode* pInode, struct file* pFile);
-static struct file_operations pvrsrv_fops = {
- .owner=THIS_MODULE,
- .unlocked_ioctl=PVRSRV_BridgeDispatchKM,
- .open=PVRSRVOpen,
- .release=PVRSRVRelease,
- .mmap=PVRMMap,
+static struct file_operations pvrsrv_fops =
+{
+ .owner = THIS_MODULE,
+ .unlocked_ioctl = PVRSRV_BridgeDispatchKM,
+ .open = PVRSRVOpen,
+ .release = PVRSRVRelease,
+ .mmap = PVRMMap,
};
#endif
IMG_UINT32 gui32ReleasePID;
-#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
static IMG_UINT32 gPVRPowerLevel;
#endif
#endif
#if defined(PVR_LDM_PLATFORM_MODULE)
-static IMG_INT PVRSRVDriverRemove(LDM_DEV *device);
-static IMG_INT PVRSRVDriverProbe(LDM_DEV *device);
+static int PVRSRVDriverRemove(LDM_DEV *device);
+static int PVRSRVDriverProbe(LDM_DEV *device);
#endif
#if defined(PVR_LDM_PCI_MODULE)
-static IMG_VOID PVRSRVDriverRemove(LDM_DEV *device);
-static IMG_INT PVRSRVDriverProbe(LDM_DEV *device, const struct pci_device_id *id);
+static void PVRSRVDriverRemove(LDM_DEV *device);
+static int PVRSRVDriverProbe(LDM_DEV *device, const struct pci_device_id *id);
#endif
-static IMG_INT PVRSRVDriverSuspend(LDM_DEV *device, pm_message_t state);
-static IMG_VOID PVRSRVDriverShutdown(LDM_DEV *device);
-static IMG_INT PVRSRVDriverResume(LDM_DEV *device);
+static int PVRSRVDriverSuspend(LDM_DEV *device, pm_message_t state);
+static void PVRSRVDriverShutdown(LDM_DEV *device);
+static int PVRSRVDriverResume(LDM_DEV *device);
#if defined(PVR_LDM_PCI_MODULE)
struct pci_device_id powervr_id_table[] __devinitdata = {
{ PCI_DEVICE(SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV_DEVICE_ID) },
+#if defined (SYS_SGX_DEV1_DEVICE_ID)
+ { PCI_DEVICE(SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV1_DEVICE_ID) },
+#endif
{ 0 }
};
#if defined(MODULE) && defined(PVR_LDM_PLATFORM_MODULE)
-static IMG_VOID PVRSRVDeviceRelease(struct device *pDevice)
+static IMG_VOID PVRSRVDeviceRelease(struct device unref__ *pDevice)
{
- PVR_UNREFERENCED_PARAMETER(pDevice);
}
static struct platform_device powervr_device = {
#endif
#if defined(PVR_LDM_PLATFORM_MODULE)
-static IMG_INT PVRSRVDriverProbe(LDM_DEV *pDevice)
+static int PVRSRVDriverProbe(LDM_DEV *pDevice)
#endif
#if defined(PVR_LDM_PCI_MODULE)
-static IMG_INT __devinit PVRSRVDriverProbe(LDM_DEV *pDevice, const struct pci_device_id *id)
+static int __devinit PVRSRVDriverProbe(LDM_DEV *pDevice, const struct pci_device_id *id)
#endif
{
SYS_DATA *psSysData;
}
#endif
- if (SysAcquireData(&psSysData) != PVRSRV_OK)
+ psSysData = SysAcquireDataNoCheck();
+ if ( psSysData == IMG_NULL)
{
gpsPVRLDMDev = pDevice;
#if defined (PVR_LDM_PLATFORM_MODULE)
-static IMG_INT PVRSRVDriverRemove(LDM_DEV *pDevice)
+static int PVRSRVDriverRemove(LDM_DEV *pDevice)
#endif
#if defined(PVR_LDM_PCI_MODULE)
-static IMG_VOID __devexit PVRSRVDriverRemove(LDM_DEV *pDevice)
+static void __devexit PVRSRVDriverRemove(LDM_DEV *pDevice)
#endif
{
SYS_DATA *psSysData;
PVR_TRACE(("PVRSRVDriverRemove(pDevice=%p)", pDevice));
- if (SysAcquireData(&psSysData) == PVRSRV_OK)
+ SysAcquireData(&psSysData);
+
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+ if (gPVRPowerLevel != 0)
{
-#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
- if (gPVRPowerLevel != 0)
+ if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
{
- if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
- {
- gPVRPowerLevel = 0;
- }
+ gPVRPowerLevel = 0;
}
+ }
#endif
- SysDeinitialise(psSysData);
+ (IMG_VOID)SysDeinitialise(psSysData);
- gpsPVRLDMDev = IMG_NULL;
- }
+ gpsPVRLDMDev = IMG_NULL;
#if 0
if (PerDeviceSysDeInitialise((IMG_PVOID)pDevice) != PVRSRV_OK)
#if defined(PVR_LDM_MODULE) || defined(SUPPORT_DRI_DRM)
#if defined(SUPPORT_DRI_DRM)
-IMG_INT PVRSRVDriverSuspend(struct drm_device *pDevice, pm_message_t state)
+int PVRSRVDriverSuspend(struct drm_device *pDevice, pm_message_t state)
#else
-static IMG_INT PVRSRVDriverSuspend(LDM_DEV *pDevice, pm_message_t state)
+static int PVRSRVDriverSuspend(LDM_DEV *pDevice, pm_message_t state)
#endif
{
-#if !(defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
+#if !(defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
PVR_TRACE(( "PVRSRVDriverSuspend(pDevice=%p)", pDevice));
if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3) != PVRSRV_OK)
#if defined(SUPPORT_DRI_DRM)
-IMG_INT PVRSRVDriverResume(struct drm_device *pDevice)
+int PVRSRVDriverResume(struct drm_device *pDevice)
#else
-static IMG_INT PVRSRVDriverResume(LDM_DEV *pDevice)
+static int PVRSRVDriverResume(LDM_DEV *pDevice)
#endif
{
-#if !(defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
+#if !(defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM))
PVR_TRACE(("PVRSRVDriverResume(pDevice=%p)", pDevice));
if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) != PVRSRV_OK)
#endif
-#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM)
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL) && !defined(SUPPORT_DRI_DRM)
IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data)
{
IMG_CHAR data_buffer[2];
return (count);
}
-#ifdef PVR_PROC_USE_SEQ_FILE
void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el)
{
seq_printf(sfile, "%lu\n", gPVRPowerLevel);
}
-#else
-IMG_INT PVRProcGetPowerLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
-{
- if (off == 0) {
- *start = (IMG_CHAR *)1;
- return printAppend(page, count, 0, "%lu\n", gPVRPowerLevel);
- }
- *eof = 1;
- return 0;
-}
-#endif
-
#endif
#if defined(SUPPORT_DRI_DRM)
-IMG_INT PVRSRVOpen(struct drm_device unref__ *dev, struct drm_file *pFile)
+int PVRSRVOpen(struct drm_device unref__ *dev, struct drm_file *pFile)
#else
-static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile)
+static int PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile)
#endif
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
IMG_HANDLE hBlockAlloc;
- IMG_INT iRet = -ENOMEM;
+ int iRet = -ENOMEM;
PVRSRV_ERROR eError;
IMG_UINT32 ui32PID;
-
-#if defined(SUPPORT_DRI_DRM)
- PVR_UNREFERENCED_PARAMETER(dev);
-#else
- PVR_UNREFERENCED_PARAMETER(pInode);
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
#endif
LinuxLockMutex(&gPVRSRVLock);
ui32PID = OSGetCurrentProcessIDKM();
- if (PVRSRVProcessConnect(ui32PID) != PVRSRV_OK)
+ if (PVRSRVProcessConnect(ui32PID, 0) != PVRSRV_OK)
goto err_unlock;
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ psEnvPerProc = PVRSRVPerProcessPrivateData(ui32PID);
+ if (psEnvPerProc == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: No per-process private data", __FUNCTION__));
+ goto err_unlock;
+ }
+#endif
+
eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_FILE_PRIVATE_DATA),
(IMG_PVOID *)&psPrivateData,
#if defined(PVR_SECURE_FD_EXPORT)
psPrivateData->hKernelMemInfo = NULL;
+#endif
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ psPrivateData->psDRMFile = pFile;
+
+ list_add_tail(&psPrivateData->sDRMAuthListItem, &psEnvPerProc->sDRMAuthListHead);
#endif
psPrivateData->ui32OpenPID = ui32PID;
psPrivateData->hBlockAlloc = hBlockAlloc;
#if defined(SUPPORT_DRI_DRM)
-IMG_INT PVRSRVRelease(struct drm_device unref__ *dev, struct drm_file *pFile)
+void PVRSRVRelease(void *pvPrivData)
#else
-static IMG_INT PVRSRVRelease(struct inode unref__ * pInode, struct file *pFile)
+static int PVRSRVRelease(struct inode unref__ * pInode, struct file *pFile)
#endif
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
+ LinuxLockMutex(&gPVRSRVLock);
+
#if defined(SUPPORT_DRI_DRM)
- PVR_UNREFERENCED_PARAMETER(dev);
+ psPrivateData = (PVRSRV_FILE_PRIVATE_DATA *)pvPrivData;
#else
- PVR_UNREFERENCED_PARAMETER(pInode);
+ psPrivateData = PRIVATE_DATA(pFile);
+#endif
+ if (psPrivateData != IMG_NULL)
+ {
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ list_del(&psPrivateData->sDRMAuthListItem);
#endif
- LinuxLockMutex(&gPVRSRVLock);
-
- psPrivateData = PRIVATE_DATA(pFile);
+
+ gui32ReleasePID = psPrivateData->ui32OpenPID;
+ PVRSRVProcessDisconnect(psPrivateData->ui32OpenPID);
+ gui32ReleasePID = 0;
-
- gui32ReleasePID = psPrivateData->ui32OpenPID;
- PVRSRVProcessDisconnect(psPrivateData->ui32OpenPID);
- gui32ReleasePID = 0;
+ OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+ sizeof(PVRSRV_FILE_PRIVATE_DATA),
+ psPrivateData, psPrivateData->hBlockAlloc);
- OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
- sizeof(PVRSRV_FILE_PRIVATE_DATA),
- psPrivateData, psPrivateData->hBlockAlloc);
- PRIVATE_DATA(pFile) = NULL;
+#if !defined(SUPPORT_DRI_DRM)
+ PRIVATE_DATA(pFile) = IMG_NULL;
+#endif
+ }
LinuxUnLockMutex(&gPVRSRVLock);
+
+#if !defined(SUPPORT_DRI_DRM)
return 0;
+#endif
}
#if defined(SUPPORT_DRI_DRM)
-IMG_INT PVRCore_Init(IMG_VOID)
+int PVRCore_Init(IMG_VOID)
#else
-static IMG_INT __init PVRCore_Init(IMG_VOID)
+static int __init PVRCore_Init(IMG_VOID)
#endif
{
- IMG_INT error;
+ int error;
#if !defined(PVR_LDM_MODULE)
PVRSRV_ERROR eError;
#else
LinuxInitMutex(&gPVRSRVLock);
-#ifdef DEBUG_PVR
- PVRDebugSetLevel(debug);
-#endif
-
if (CreateProcEntries ())
{
error = -ENOMEM;
return error;
}
+ if (PVROSFuncInit() != PVRSRV_OK)
+ {
+ error = -ENOMEM;
+ goto init_failed;
+ }
+
PVRLinuxMUtilsInit();
if(LinuxMMInit() != PVRSRV_OK)
{
SYS_DATA *psSysData;
- SysAcquireData(&psSysData);
+ psSysData = SysAcquireDataNoCheck();
if (psSysData != IMG_NULL)
{
- SysDeinitialise(psSysData);
+ (IMG_VOID)SysDeinitialise(psSysData);
}
}
#endif
PVRMMapCleanup();
LinuxMMCleanup();
LinuxBridgeDeInit();
+ PVROSFuncDeInit();
RemoveProcEntries();
return error;
#if defined(SUPPORT_DRI_DRM)
-IMG_VOID PVRCore_Cleanup(IMG_VOID)
+void PVRCore_Cleanup(void)
#else
-static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID)
+static void __exit PVRCore_Cleanup(void)
#endif
{
SYS_DATA *psSysData;
#endif
#else
-#if defined(DEBUG_PVR) && defined(PVR_MANUAL_POWER_CONTROL)
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
if (gPVRPowerLevel != 0)
{
if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
}
#endif
- SysDeinitialise(psSysData);
+ (void) SysDeinitialise(psSysData);
#endif
PVRMMapCleanup();
LinuxBridgeDeInit();
+ PVROSFuncDeInit();
+
RemoveProcEntries();
PVR_TRACE(("PVRCore_Cleanup: unloading"));
{
if(mutex_lock_interruptible(psPVRSRVMutex) == -EINTR)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR;
}
else
{
IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
{
- return (IMG_BOOL)mutex_is_locked(psPVRSRVMutex);
+ return (mutex_is_locked(psPVRSRVMutex)) ? IMG_TRUE : IMG_FALSE;
}
if(down_interruptible(&psPVRSRVMutex->sSemaphore) == -EINTR)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR;
}else{
atomic_dec(&psPVRSRVMutex->Count);
return PVRSRV_OK;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
#include <asm/system.h>
#endif
-#if defined(SUPPORT_CPU_CACHED_BUFFERS)
#include <asm/cacheflush.h>
-#endif
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/hugetlb.h>
#include <linux/capability.h>
#include <asm/uaccess.h>
#include <linux/spinlock.h>
-#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || \
+ defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE) || \
+ defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || \
+ defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE) || \
+ defined(PVR_LINUX_USING_WORKQUEUES)
#include <linux/workqueue.h>
#endif
#include "proc.h"
#include "mutex.h"
#include "event.h"
+#include "linkage.h"
+#include "pvr_uaccess.h"
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27))
+#define ON_EACH_CPU(func, info, wait) on_each_cpu(func, info, wait)
+#else
+#define ON_EACH_CPU(func, info, wait) on_each_cpu(func, info, 0, wait)
+#endif
+/*
+#if defined(PVR_LINUX_USING_WORKQUEUES) && !defined(CONFIG_PREEMPT)
+#error "A preemptible Linux kernel is required when using workqueues"
+#endif
+*/
#define EVENT_OBJECT_TIMEOUT_MS (100)
#define HOST_ALLOC_MEM_USING_KMALLOC ((IMG_HANDLE)0)
return PVRSRV_OK;
}
-
+
#if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc)
#else
PVRSRV_ERROR
OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PageSize,
- IMG_VOID **ppvCpuVAddr,
- IMG_HANDLE *phOSMemHandle)
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PageSize,
+ IMG_VOID **ppvCpuVAddr,
+ IMG_HANDLE *phOSMemHandle)
{
LinuxMemArea *psLinuxMemArea;
return PVRSRV_ERROR_INVALID_PARAMS;
}
-#if defined(SUPPORT_CACHEFLUSH_ON_ALLOC)
-
- if(ui32AllocFlags & (PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_UNCACHED))
- {
- OSFlushCPUCacheKM();
- }
-#endif
-
*ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
*phOSMemHandle = psLinuxMemArea;
OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_UINT32 ui32Bytes, IMG_VOID *pvCpuVAddr, IMG_HANDLE hOSMemHandle)
{
LinuxMemArea *psLinuxMemArea;
+ PVRSRV_ERROR eError;
+
PVR_UNREFERENCED_PARAMETER(ui32Bytes);
PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
break;
case PVRSRV_HAP_SINGLE_PROCESS:
case PVRSRV_HAP_MULTI_PROCESS:
- if(PVRMMapRemoveRegisteredArea(psLinuxMemArea) != PVRSRV_OK)
+ eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,
- "OSFreePages(ui32AllocFlags=0x%08X, ui32Bytes=%ld, "
+ "OSFreePages(ui32AllocFlags=0x%08X, ui32Bytes=%d, "
"pvCpuVAddr=%p, hOSMemHandle=%p) FAILED!",
ui32AllocFlags, ui32Bytes, pvCpuVAddr, hOSMemHandle));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
break;
default:
PVRSRV_ERROR OSInitEnvData(IMG_PVOID *ppvEnvSpecificData)
{
ENV_DATA *psEnvData;
+ PVRSRV_ERROR eError;
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), (IMG_VOID **)&psEnvData, IMG_NULL,
- "Environment Data") != PVRSRV_OK)
+ eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), (IMG_VOID **)&psEnvData, IMG_NULL,
+ "Environment Data");
+ if (eError != PVRSRV_OK)
{
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
- if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE,
+ eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE,
&psEnvData->pvBridgeData, IMG_NULL,
- "Bridge Data") != PVRSRV_OK)
+ "Bridge Data");
+ if (eError != PVRSRV_OK)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), psEnvData, IMG_NULL);
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
if (psEnvData->bLISRInstalled)
{
- PVR_DPF((PVR_DBG_ERROR, "OSInstallDeviceLISR: An ISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallDeviceLISR: An ISR has already been installed: IRQ %d cookie %p", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
}
- PVR_TRACE(("Installing device LISR %s on IRQ %d with cookie %x", pszISRName, ui32Irq, pvDeviceNode));
+ PVR_TRACE(("Installing device LISR %s on IRQ %d with cookie %p", pszISRName, ui32Irq, pvDeviceNode));
if(request_irq(ui32Irq, DeviceISRWrapper,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
{
PVR_DPF((PVR_DBG_ERROR,"OSInstallDeviceLISR: Couldn't install device LISR on IRQ %d", ui32Irq));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
}
psEnvData->ui32IRQ = ui32Irq;
if (!psEnvData->bLISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSUninstallDeviceLISR: No LISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_NOT_INSTALLED;
}
- PVR_TRACE(("Uninstalling device LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ PVR_TRACE(("Uninstalling device LISR on IRQ %d with cookie %p", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
if (psEnvData->bLISRInstalled)
{
- PVR_DPF((PVR_DBG_ERROR, "OSInstallSystemLISR: An LISR has already been installed: IRQ %d cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
- return PVRSRV_ERROR_GENERIC;
+ PVR_DPF((PVR_DBG_ERROR, "OSInstallSystemLISR: An LISR has already been installed: IRQ %d cookie %p", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
}
- PVR_TRACE(("Installing system LISR on IRQ %d with cookie %x", ui32Irq, pvSysData));
+ PVR_TRACE(("Installing system LISR on IRQ %d with cookie %p", ui32Irq, pvSysData));
if(request_irq(ui32Irq, SystemISRWrapper,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
#else
IRQF_SHARED
#endif
- , "PowerVR", pvSysData))
+ , PVRSRV_MODNAME, pvSysData))
{
PVR_DPF((PVR_DBG_ERROR,"OSInstallSystemLISR: Couldn't install system LISR on IRQ %d", ui32Irq));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
}
psEnvData->ui32IRQ = ui32Irq;
if (!psEnvData->bLISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSUninstallSystemLISR: No LISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_NOT_INSTALLED;
}
- PVR_TRACE(("Uninstalling system LISR on IRQ %d with cookie %x", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+ PVR_TRACE(("Uninstalling system LISR on IRQ %d with cookie %p", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
if (psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
}
- PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
+ PVR_TRACE(("Installing MISR with cookie %p", pvSysData));
psEnvData->psWorkQueue = create_singlethread_workqueue("pvr_workqueue");
if (psEnvData->psWorkQueue == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: create_singlethreaded_workqueue failed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD;
}
INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
if (!psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_NOT_INSTALLED;
}
PVR_TRACE(("Uninstalling MISR"));
- flush_workqueue(psEnvData->psWorkQueue);
-
destroy_workqueue(psEnvData->psWorkQueue);
psEnvData->bMISRInstalled = IMG_FALSE;
if (psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
}
- PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
+ PVR_TRACE(("Installing MISR with cookie %p", pvSysData));
INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
if (!psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_NOT_INSTALLED;
}
PVR_TRACE(("Uninstalling MISR"));
if (psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
}
- PVR_TRACE(("Installing MISR with cookie %x", pvSysData));
+ PVR_TRACE(("Installing MISR with cookie %p", pvSysData));
tasklet_init(&psEnvData->sMISRTasklet, MISRWrapper, (unsigned long)pvSysData);
if (!psEnvData->bMISRInstalled)
{
PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_ISR_NOT_INSTALLED;
}
PVR_TRACE(("Uninstalling MISR"));
if(!OS_TAS(&psResource->ui32Lock))
psResource->ui32ID = ui32ID;
else
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE;
return eError;
}
if(psResource->ui32ID == ui32ID)
{
psResource->ui32ID = 0;
+ smp_mb();
*pui32Access = 0;
}
else
{
PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked with expected value.", psResource));
PVR_DPF((PVR_DBG_MESSAGE,"Should be %x is actually %x", ui32ID, psResource->ui32ID));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_INVALID_LOCK_ID;
}
}
else
{
PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked", psResource));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_RESOURCE_NOT_LOCKED;
}
return eError;
}
-IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_VOID *pvLinAddr)
+IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvLinAddr)
{
IMG_CPU_PHYADDR CpuPAddr;
+ LinuxMemArea *psLinuxMemArea;
+ IMG_UINTPTR_T uiByteOffset;
+ IMG_UINT32 ui32ByteOffset;
+
+ PVR_ASSERT(hOSMemHandle != IMG_NULL);
+
+
+
+ psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+ uiByteOffset = (IMG_UINTPTR_T)pvLinAddr - (IMG_UINTPTR_T)LinuxMemAreaToCpuVAddr(psLinuxMemArea);
+ ui32ByteOffset = (IMG_UINT32)uiByteOffset;
- CpuPAddr.uiAddr = (IMG_UINTPTR_T)VMallocToPhys(pvLinAddr);
+ CpuPAddr = LinuxMemAreaToCpuPAddr(hOSMemHandle, ui32ByteOffset);
- return CpuPAddr;
+ return CpuPAddr;
}
IMG_UINT32 ui32MappingFlags,
IMG_HANDLE *phOSMemHandle)
{
- if(phOSMemHandle)
- {
- *phOSMemHandle = (IMG_HANDLE)0;
- }
-
if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
{
- IMG_VOID *pvIORemapCookie;
- pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags);
- if(pvIORemapCookie == IMG_NULL)
- {
- return NULL;
- }
- return pvIORemapCookie;
- }
- else
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
- " (Use OSReservePhys otherwise)"));
- return NULL;
+
+ if(phOSMemHandle == IMG_NULL)
+ {
+ IMG_VOID *pvIORemapCookie;
+ pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags);
+ if(pvIORemapCookie == IMG_NULL)
+ {
+ return IMG_NULL;
+ }
+ return pvIORemapCookie;
+ }
+ else
+ {
+ LinuxMemArea *psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+
+ if(psLinuxMemArea == IMG_NULL)
+ {
+ return IMG_NULL;
+ }
+
+ *phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
+ return LinuxMemAreaToCpuVAddr(psLinuxMemArea);
+ }
}
+
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
+ " (Use OSReservePhys otherwise)"));
+
+ return IMG_NULL;
}
IMG_BOOL
-OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE hPageAlloc)
+OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE hOSMemHandle)
{
- PVR_TRACE(("%s: unmapping %d bytes from 0x%08x", __FUNCTION__, ui32Bytes, pvLinAddr));
+ PVR_TRACE(("%s: unmapping %d bytes from %p", __FUNCTION__, ui32Bytes, pvLinAddr));
- PVR_UNREFERENCED_PARAMETER(hPageAlloc);
PVR_UNREFERENCED_PARAMETER(ui32Bytes);
if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
{
- IOUnmapWrapper(pvLinAddr);
+ if (hOSMemHandle == IMG_NULL)
+ {
+ IOUnmapWrapper(pvLinAddr);
+ }
+ else
+ {
+ LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+ PVR_ASSERT(LinuxMemAreaToCpuVAddr(psLinuxMemArea) == pvLinAddr);
+
+ FreeIORemapLinuxMemArea(psLinuxMemArea);
+ }
+
return IMG_TRUE;
}
- else
- {
- PVR_DPF((PVR_DBG_ERROR,
- "OSUnMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
- " (Use OSUnReservePhys otherwise)"));
- return IMG_FALSE;
- }
+
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSUnMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
+ " (Use OSUnReservePhys otherwise)"));
+ return IMG_FALSE;
}
static PVRSRV_ERROR
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
break;
}
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
PVRMMapRegisterArea(psLinuxMemArea);
break;
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
PVRMMapRegisterArea(psLinuxMemArea);
break;
default:
PVR_DPF((PVR_DBG_ERROR,"OSRegisterMem : invalid flags 0x%x\n", ui32MappingFlags));
*phOSMemHandle = (IMG_HANDLE)0;
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_FLAGS;
}
*phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
IMG_HANDLE hOSMemHandle)
{
LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+ PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
PVR_UNREFERENCED_PARAMETER(ui32Bytes);
case PVRSRV_HAP_SINGLE_PROCESS:
case PVRSRV_HAP_MULTI_PROCESS:
{
- if(PVRMMapRemoveRegisteredArea(psLinuxMemArea) != PVRSRV_OK)
+ eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "%s(%p, %d, 0x%08X, %p) FAILED!",
__FUNCTION__, pvCpuVAddr, ui32Bytes,
ui32MappingFlags, hOSMemHandle));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
break;
}
psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
break;
}
psLinuxMemArea = NewIOLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
PVRMMapRegisterArea(psLinuxMemArea);
break;
psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
if(!psLinuxMemArea)
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_BAD_MAPPING;
}
PVRMMapRegisterArea(psLinuxMemArea);
break;
PVR_DPF((PVR_DBG_ERROR,"OSMapPhysToLin : invalid flags 0x%x\n", ui32MappingFlags));
*ppvCpuVAddr = NULL;
*phOSMemHandle = (IMG_HANDLE)0;
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_FLAGS;
}
*phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
IMG_HANDLE hOSMemHandle)
{
LinuxMemArea *psLinuxMemArea;
+ PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
- PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+ PVR_UNREFERENCED_PARAMETER(ui32Bytes);
psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
case PVRSRV_HAP_SINGLE_PROCESS:
case PVRSRV_HAP_MULTI_PROCESS:
{
- if(PVRMMapRemoveRegisteredArea(psLinuxMemArea) != PVRSRV_OK)
+ eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+ if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "%s(%p, %d, 0x%08X, %p) FAILED!",
__FUNCTION__, pvCpuVAddr, ui32Bytes,
ui32MappingFlags, hOSMemHandle));
- return PVRSRV_ERROR_GENERIC;
+ return eError;
}
break;
}
{
int err;
- err = pci_request_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index, "PowerVR");
+ err = pci_request_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index, PVRSRV_MODNAME);
if (err != 0)
{
PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: pci_request_region_failed (%d)", err));
PVRSRV_ERROR OSPCIRequestAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI,
IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_REQUEST, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_REQUEST, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_PCI_CALL_FAILED : PVRSRV_OK;
}
PVRSRV_ERROR OSPCIReleaseAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
{
- return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_RELEASE, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_GENERIC : PVRSRV_OK;
+ return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_RELEASE, hPVRPCI, ui32Index) == 0 ? PVRSRV_ERROR_PCI_CALL_FAILED : PVRSRV_OK;
}
PVRSRV_ERROR OSPCIReleaseDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
if (err != 0)
{
PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_save_state_failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PCI_CALL_FAILED;
}
pci_disable_device(psPVRPCI->psPCIDev);
break;
case -EINVAL:
PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: can't enter requested power state"));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNKNOWN_POWER_STATE;
default:
PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_set_power_state failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNKNOWN_POWER_STATE;
}
err = pci_restore_state(psPVRPCI->psPCIDev);
if (err != 0)
{
PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_restore_state failed (%d)", err));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PCI_CALL_FAILED;
}
err = pci_enable_device(psPVRPCI->psPCIDev);
if (err != 0)
{
PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: Couldn't enable device (%d)", err));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PCI_CALL_FAILED;
}
if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)
{
if (psPVRPCI->abPCIResourceInUse[i])
{
- err = pci_request_region(psPVRPCI->psPCIDev, i, "PowerVR");
+ err = pci_request_region(psPVRPCI->psPCIDev, i, PVRSRV_MODNAME);
if (err != 0)
{
PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_request_region_failed (region %d, error %d)", i, err));
typedef struct TIMER_CALLBACK_DATA_TAG
{
- IMG_BOOL bInUse;
+ IMG_BOOL bInUse;
PFN_TIMER_FUNC pfnTimerFunc;
- IMG_VOID *pvData;
- struct timer_list sTimer;
- IMG_UINT32 ui32Delay;
- IMG_BOOL bActive;
- struct work_struct work;
+ IMG_VOID *pvData;
+ struct timer_list sTimer;
+ IMG_UINT32 ui32Delay;
+ IMG_BOOL bActive;
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ struct work_struct sWork;
+#endif
}TIMER_CALLBACK_DATA;
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+static struct workqueue_struct *psTimerWorkQueue;
+#endif
+
static TIMER_CALLBACK_DATA sTimers[OS_MAX_TIMERS];
-static DEFINE_SPINLOCK(sTimerStructLock);
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+DEFINE_MUTEX(sTimerStructLock);
+#else
+
+static spinlock_t sTimerStructLock = SPIN_LOCK_UNLOCKED;
+#endif
-static void timer_worker(struct work_struct *work)
+static void OSTimerCallbackBody(TIMER_CALLBACK_DATA *psTimerCBData)
{
- TIMER_CALLBACK_DATA *psTimerCBData =
- container_of(work, TIMER_CALLBACK_DATA, work);
+ if (!psTimerCBData->bActive)
+ return;
- if (psTimerCBData->bActive)
- {
- /* call timer callback */
- psTimerCBData->pfnTimerFunc(psTimerCBData->pvData);
-
- /* reset timer */
- mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
- }
+
+ psTimerCBData->pfnTimerFunc(psTimerCBData->pvData);
+
+
+ mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
}
+
static IMG_VOID OSTimerCallbackWrapper(IMG_UINT32 ui32Data)
{
TIMER_CALLBACK_DATA *psTimerCBData = (TIMER_CALLBACK_DATA*)ui32Data;
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ int res;
- schedule_work(&psTimerCBData->work);
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+ res = queue_work(psTimerWorkQueue, &psTimerCBData->sWork);
+#else
+ res = schedule_work(&psTimerCBData->sWork);
+#endif
+ if (res == 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "OSTimerCallbackWrapper: work already queued"));
+ }
+#else
+ OSTimerCallbackBody(psTimerCBData);
+#endif
}
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+static void OSTimerWorkQueueCallBack(struct work_struct *psWork)
+{
+ TIMER_CALLBACK_DATA *psTimerCBData = container_of(psWork, TIMER_CALLBACK_DATA, sWork);
+
+ OSTimerCallbackBody(psTimerCBData);
+}
+#endif
+
IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32 ui32MsTimeout)
{
TIMER_CALLBACK_DATA *psTimerCBData;
IMG_UINT32 ui32i;
+#if !(defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE))
unsigned long ulLockFlags;
+#endif
if(!pfnTimerFunc)
}
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ mutex_lock(&sTimerStructLock);
+#else
spin_lock_irqsave(&sTimerStructLock, ulLockFlags);
+#endif
for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
{
psTimerCBData = &sTimers[ui32i];
break;
}
}
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ mutex_unlock(&sTimerStructLock);
+#else
spin_unlock_irqrestore(&sTimerStructLock, ulLockFlags);
-
+#endif
if (ui32i >= OS_MAX_TIMERS)
{
PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: all timers are in use"));
psTimerCBData->bActive = IMG_FALSE;
- INIT_WORK(&psTimerCBData->work, timer_worker);
+
psTimerCBData->ui32Delay = ((HZ * ui32MsTimeout) < 1000)
? 1
init_timer(&psTimerCBData->sTimer);
- psTimerCBData->sTimer.function = OSTimerCallbackWrapper;
+
+ psTimerCBData->sTimer.function = (IMG_VOID *)OSTimerCallbackWrapper;
psTimerCBData->sTimer.data = (IMG_UINT32)psTimerCBData;
- psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
return (IMG_HANDLE)(ui32i + 1);
}
PVRSRV_ERROR OSEnableTimer (IMG_HANDLE hTimer)
{
TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
- int ret;
PVR_ASSERT(psTimerCBData->bInUse);
PVR_ASSERT(!psTimerCBData->bActive);
psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
- ret = mod_timer(&psTimerCBData->sTimer, psTimerCBData->ui32Delay + jiffies);
- if(ret == 1)
- PVR_DPF((PVR_DBG_WARNING, "OSEnableTimer: enabling active timer"));
-
+ add_timer(&psTimerCBData->sTimer);
+
return PVRSRV_OK;
}
psTimerCBData->bActive = IMG_FALSE;
+ smp_mb();
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+ flush_workqueue(psTimerWorkQueue);
+#endif
+#if defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ flush_scheduled_work();
+#endif
- cancel_work_sync(&psTimerCBData->work);
del_timer_sync(&psTimerCBData->sTimer);
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+
+ flush_workqueue(psTimerWorkQueue);
+#endif
+#if defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ flush_scheduled_work();
+#endif
+
return PVRSRV_OK;
}
else
{
PVR_DPF((PVR_DBG_ERROR, "OSEventObjectCreate: psEventObject is not a valid pointer"));
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT;
}
return eError;
{
PVR_UNREFERENCED_PARAMETER(pvProcess);
- if(copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
+ if(pvr_copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
return PVRSRV_OK;
else
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
}
PVRSRV_ERROR OSCopyFromUser( IMG_PVOID pvProcess,
{
PVR_UNREFERENCED_PARAMETER(pvProcess);
- if(copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
+ if(pvr_copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
return PVRSRV_OK;
else
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
}
IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_UINT32 ui32Bytes)
typedef enum _eWrapMemType_
{
- WRAP_TYPE_CLEANUP,
+ WRAP_TYPE_NULL = 0,
WRAP_TYPE_GET_USER_PAGES,
- WRAP_TYPE_FIND_VMA_PAGES,
- WRAP_TYPE_FIND_VMA_PFN
+ WRAP_TYPE_FIND_VMA
} eWrapMemType;
typedef struct _sWrapMemInfo_
{
eWrapMemType eType;
IMG_INT iNumPages;
+ IMG_INT iNumPagesMapped;
struct page **ppsPages;
IMG_SYS_PHYADDR *psPhysAddr;
IMG_INT iPageOffset;
- IMG_INT iContiguous;
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
IMG_UINT32 ulStartAddr;
IMG_UINT32 ulBeyondEndAddr;
struct vm_area_struct *psVMArea;
#endif
} sWrapMemInfo;
-static IMG_VOID CheckPagesContiguous(sWrapMemInfo *psInfo)
-{
- IMG_INT i;
- IMG_UINT32 ui32AddrChk;
-
- BUG_ON(psInfo == IMG_NULL);
-
- psInfo->iContiguous = 1;
-
- for (i = 0, ui32AddrChk = psInfo->psPhysAddr[0].uiAddr;
- i < psInfo->iNumPages;
- i++, ui32AddrChk += PAGE_SIZE)
- {
- if (psInfo->psPhysAddr[i].uiAddr != ui32AddrChk)
- {
- psInfo->iContiguous = 0;
- break;
- }
- }
-}
-static struct page *CPUVAddrToPage(struct vm_area_struct *psVMArea, IMG_UINT32 ulCPUVAddr)
+static IMG_BOOL CPUVAddrToPFN(struct vm_area_struct *psVMArea, IMG_UINT32 ulCPUVAddr, IMG_UINT32 *pulPFN, struct page **ppsPage)
{
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10))
pgd_t *psPGD;
pmd_t *psPMD;
pte_t *psPTE;
struct mm_struct *psMM = psVMArea->vm_mm;
- IMG_UINT32 ulPFN;
spinlock_t *psPTLock;
- struct page *psPage;
+ IMG_BOOL bRet = IMG_FALSE;
+
+ *pulPFN = 0;
+ *ppsPage = NULL;
psPGD = pgd_offset(psMM, ulCPUVAddr);
if (pgd_none(*psPGD) || pgd_bad(*psPGD))
- return NULL;
+ return bRet;
psPUD = pud_offset(psPGD, ulCPUVAddr);
if (pud_none(*psPUD) || pud_bad(*psPUD))
- return NULL;
+ return bRet;
psPMD = pmd_offset(psPUD, ulCPUVAddr);
if (pmd_none(*psPMD) || pmd_bad(*psPMD))
- return NULL;
-
- psPage = NULL;
+ return bRet;
psPTE = (pte_t *)pte_offset_map_lock(psMM, psPMD, ulCPUVAddr, &psPTLock);
- if ((pte_none(*psPTE) != 0) || (pte_present(*psPTE) == 0) || (pte_write(*psPTE) == 0))
- goto exit_unlock;
- ulPFN = pte_pfn(*psPTE);
- if (!pfn_valid(ulPFN))
- goto exit_unlock;
+ if ((pte_none(*psPTE) == 0) && (pte_present(*psPTE) != 0) && (pte_write(*psPTE) != 0))
+ {
+ *pulPFN = pte_pfn(*psPTE);
+ bRet = IMG_TRUE;
- psPage = pfn_to_page(ulPFN);
+ if (pfn_valid(*pulPFN))
+ {
+ *ppsPage = pfn_to_page(*pulPFN);
- get_page(psPage);
+ get_page(*ppsPage);
+ }
+ }
-exit_unlock:
- pte_unmap_unlock(psPTE, psPTLock);
+ pte_unmap_unlock(psPTE, psPTLock);
- return psPage;
+ return bRet;
#else
- return NULL;
+ return IMG_FALSE;
#endif
}
+
PVRSRV_ERROR OSReleasePhysPageAddr(IMG_HANDLE hOSWrapMem)
{
sWrapMemInfo *psInfo = (sWrapMemInfo *)hOSWrapMem;
IMG_INT i;
- BUG_ON(psInfo == IMG_NULL);
+ if (psInfo == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSReleasePhysPageAddr: called with null wrap handle"));
+ return PVRSRV_OK;
+ }
switch (psInfo->eType)
{
- case WRAP_TYPE_CLEANUP:
- break;
- case WRAP_TYPE_FIND_VMA_PFN:
- break;
+ case WRAP_TYPE_NULL:
+ {
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSReleasePhysPageAddr: called with wrap type WRAP_TYPE_NULL"));
+ break;
+ }
case WRAP_TYPE_GET_USER_PAGES:
{
- for (i = 0; i < psInfo->iNumPages; i++)
+ for (i = 0; i < psInfo->iNumPagesMapped; i++)
{
struct page *psPage = psInfo->ppsPages[i];
+ PVR_ASSERT(psPage != NULL);
+
- if (!PageReserved(psPage));
- {
- SetPageDirty(psPage);
- }
+ if (psInfo->iNumPagesMapped == psInfo->iNumPages)
+ {
+ if (!PageReserved(psPage))
+ {
+ SetPageDirty(psPage);
+ }
+ }
page_cache_release(psPage);
- }
+ }
break;
}
- case WRAP_TYPE_FIND_VMA_PAGES:
+ case WRAP_TYPE_FIND_VMA:
{
for (i = 0; i < psInfo->iNumPages; i++)
{
- put_page_testzero(psInfo->ppsPages[i]);
+ if (psInfo->ppsPages[i] != IMG_NULL)
+ {
+ put_page(psInfo->ppsPages[i]);
+ }
}
break;
}
{
PVR_DPF((PVR_DBG_ERROR,
"OSReleasePhysPageAddr: Unknown wrap type (%d)", psInfo->eType));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_INVALID_WRAP_TYPE;
}
}
return PVRSRV_OK;
}
-PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID* pvCPUVAddr,
+PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
IMG_UINT32 ui32Bytes,
IMG_SYS_PHYADDR *psSysPAddr,
IMG_HANDLE *phOSWrapMem)
IMG_UINT32 ulAddrRange;
IMG_UINT32 ulBeyondEndAddr;
IMG_UINT32 ulAddr;
- IMG_INT iNumPagesMapped;
IMG_INT i;
struct vm_area_struct *psVMArea;
- sWrapMemInfo *psInfo;
+ sWrapMemInfo *psInfo = NULL;
+ IMG_BOOL bHavePageStructs = IMG_FALSE;
+ IMG_BOOL bHaveNoPageStructs = IMG_FALSE;
+ IMG_BOOL bPFNMismatch = IMG_FALSE;
+ IMG_BOOL bMMapSemHeld = IMG_FALSE;
+ PVRSRV_ERROR eError = PVRSRV_ERROR_OUT_OF_MEMORY;
ulStartAddr = ulStartAddrOrig & PAGE_MASK;
ulAddrRange = ulBeyondEndAddr - ulStartAddr;
+ if (ulBeyondEndAddr <= ulStartAddr)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Invalid address range (start %x, length %x)",
+ ulStartAddrOrig, ulAddrRangeOrig));
+ goto error;
+ }
+
+
psInfo = kmalloc(sizeof(*psInfo), GFP_KERNEL);
if (psInfo == NULL)
{
PVR_DPF((PVR_DBG_ERROR,
"OSAcquirePhysPageAddr: Couldn't allocate information structure"));
- return PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto error;
}
memset(psInfo, 0, sizeof(*psInfo));
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
psInfo->ulStartAddr = ulStartAddrOrig;
psInfo->ulBeyondEndAddr = ulBeyondEndAddrOrig;
#endif
{
PVR_DPF((PVR_DBG_ERROR,
"OSAcquirePhysPageAddr: Couldn't allocate page array"));
- goto error_free;
+ goto error;
}
+ memset(psInfo->psPhysAddr, 0, (size_t)psInfo->iNumPages * sizeof(*psInfo->psPhysAddr));
psInfo->ppsPages = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->ppsPages), GFP_KERNEL);
{
PVR_DPF((PVR_DBG_ERROR,
"OSAcquirePhysPageAddr: Couldn't allocate page array"));
- goto error_free;
+ goto error;
}
+ memset(psInfo->ppsPages, 0, (size_t)psInfo->iNumPages * sizeof(*psInfo->ppsPages));
+
+
+ eError = PVRSRV_ERROR_BAD_MAPPING;
+
+
+ psInfo->eType = WRAP_TYPE_GET_USER_PAGES;
down_read(¤t->mm->mmap_sem);
- iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
- up_read(¤t->mm->mmap_sem);
+ bMMapSemHeld = IMG_TRUE;
- if (iNumPagesMapped >= 0)
+
+ psInfo->iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
+
+ if (psInfo->iNumPagesMapped >= 0)
{
- if (iNumPagesMapped != psInfo->iNumPages)
+ if (psInfo->iNumPagesMapped != psInfo->iNumPages)
{
- PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't map all the pages needed (wanted: %d, got %d)", psInfo->iNumPages, iNumPagesMapped));
+ PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't map all the pages needed (wanted: %d, got %d)", psInfo->iNumPages, psInfo->iNumPagesMapped));
-
- for (i = 0; i < iNumPagesMapped; i++)
- {
- page_cache_release(psInfo->ppsPages[i]);
-
- }
- goto error_free;
+ goto error;
}
for (i = 0; i < psInfo->iNumPages; i++)
{
IMG_CPU_PHYADDR CPUPhysAddr;
+ IMG_UINT32 ulPFN;
+
+ ulPFN = page_to_pfn(psInfo->ppsPages[i]);
+ CPUPhysAddr.uiAddr = ulPFN << PAGE_SHIFT;
+ if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ulPFN)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ulPFN));
- CPUPhysAddr.uiAddr = page_to_pfn(psInfo->ppsPages[i]) << PAGE_SHIFT;
+ goto error;
+ }
psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
psSysPAddr[i] = psInfo->psPhysAddr[i];
}
- psInfo->eType = WRAP_TYPE_GET_USER_PAGES;
-
- goto exit_check;
+ goto exit;
}
- PVR_TRACE(("OSAcquirePhysPageAddr: get_user_pages failed (%d), trying something else", iNumPagesMapped));
+ PVR_DPF((PVR_DBG_MESSAGE, "OSAcquirePhysPageAddr: get_user_pages failed (%d), using CPU page table", psInfo->iNumPagesMapped));
- down_read(¤t->mm->mmap_sem);
+ psInfo->eType = WRAP_TYPE_NULL;
+ psInfo->iNumPagesMapped = 0;
+ memset(psInfo->ppsPages, 0, (size_t)psInfo->iNumPages * sizeof(*psInfo->ppsPages));
+
+
+
+ psInfo->eType = WRAP_TYPE_FIND_VMA;
psVMArea = find_vma(current->mm, ulStartAddrOrig);
if (psVMArea == NULL)
{
PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Couldn't find memory region containing start address %lx", ulStartAddrOrig));
+ "OSAcquirePhysPageAddr: Couldn't find memory region containing start address %x", ulStartAddrOrig));
- goto error_release_mmap_sem;
+ goto error;
}
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
psInfo->psVMArea = psVMArea;
#endif
if (ulStartAddrOrig < psVMArea->vm_start)
{
PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: Start address %lx is outside of the region returned by find_vma", ulStartAddrOrig));
- goto error_release_mmap_sem;
+ "OSAcquirePhysPageAddr: Start address %x is outside of the region returned by find_vma", ulStartAddrOrig));
+ goto error;
}
if (ulBeyondEndAddrOrig > psVMArea->vm_end)
{
PVR_DPF((PVR_DBG_ERROR,
- "OSAcquirePhysPageAddr: End address %lx is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
- goto error_release_mmap_sem;
+ "OSAcquirePhysPageAddr: End address %x is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
+ goto error;
}
{
PVR_DPF((PVR_DBG_ERROR,
"OSAcquirePhysPageAddr: Memory region does not represent memory mapped I/O (VMA flags: 0x%lx)", psVMArea->vm_flags));
- goto error_release_mmap_sem;
+ goto error;
}
{
PVR_DPF((PVR_DBG_ERROR,
"OSAcquirePhysPageAddr: No read/write access to memory region (VMA flags: 0x%lx)", psVMArea->vm_flags));
- goto error_release_mmap_sem;
+ goto error;
}
-
for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
{
- struct page *psPage;
+ IMG_CPU_PHYADDR CPUPhysAddr;
+ IMG_UINT32 ulPFN = 0;
- BUG_ON(i >= psInfo->iNumPages);
+ PVR_ASSERT(i < psInfo->iNumPages);
- psPage = CPUVAddrToPage(psVMArea, ulAddr);
- if (psPage == NULL)
- {
- IMG_INT j;
+ if (!CPUVAddrToPFN(psVMArea, ulAddr, &ulPFN, &psInfo->ppsPages[i]))
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Invalid CPU virtual address"));
- PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't lookup page structure for address 0x%lx, trying something else", ulAddr));
+ goto error;
+ }
+ if (psInfo->ppsPages[i] == NULL)
+ {
-
- for (j = 0; j < i; j++)
- {
- put_page_testzero(psInfo->ppsPages[j]);
- }
- break;
- }
+ bHaveNoPageStructs = IMG_TRUE;
- psInfo->ppsPages[i] = psPage;
- }
+#if defined(VM_PFNMAP)
+ if ((psVMArea->vm_flags & VM_PFNMAP) != 0)
+ {
+ IMG_UINT32 ulPFNRaw = ((ulAddr - psVMArea->vm_start) >> PAGE_SHIFT) + psVMArea->vm_pgoff;
- BUG_ON(i > psInfo->iNumPages);
- if (i == psInfo->iNumPages)
- {
-
- for (i = 0; i < psInfo->iNumPages; i++)
- {
- struct page *psPage = psInfo->ppsPages[i];
- IMG_CPU_PHYADDR CPUPhysAddr;
+ if (ulPFNRaw != ulPFN)
+ {
+ bPFNMismatch = IMG_TRUE;
+ }
+ }
+#endif
+ }
+ else
+ {
+ bHavePageStructs = IMG_TRUE;
-
- CPUPhysAddr.uiAddr = page_to_pfn(psPage) << PAGE_SHIFT;
+ psInfo->iNumPagesMapped++;
- psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
- psSysPAddr[i] = psInfo->psPhysAddr[i];
- }
+ PVR_ASSERT(ulPFN == page_to_pfn(psInfo->ppsPages[i]));
+ }
- psInfo->eType = WRAP_TYPE_FIND_VMA_PAGES;
+ CPUPhysAddr.uiAddr = ulPFN << PAGE_SHIFT;
+ if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ulPFN)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ulPFN));
+
+ goto error;
+ }
+
+ psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+ psSysPAddr[i] = psInfo->psPhysAddr[i];
}
- else
- {
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10)) && defined(PVR_SECURE_HANDLES)
-
+ PVR_ASSERT(i == psInfo->iNumPages);
-
- if ((psVMArea->vm_flags & VM_PFNMAP) == 0)
- {
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Region isn't a raw PFN mapping. Giving up."));
- goto error_release_mmap_sem;
- }
-
- for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
- {
- IMG_CPU_PHYADDR CPUPhysAddr;
+#if defined(VM_MIXEDMAP)
+ if ((psVMArea->vm_flags & VM_MIXEDMAP) != 0)
+ {
+ goto exit;
+ }
+#endif
- CPUPhysAddr.uiAddr = ((ulAddr - psVMArea->vm_start) + (psVMArea->vm_pgoff << PAGE_SHIFT)) & PAGE_MASK;
+ if (bHavePageStructs && bHaveNoPageStructs)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Region is VM_MIXEDMAP, but isn't marked as such"));
+ goto error;
+ }
- psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
- psSysPAddr[i] = psInfo->psPhysAddr[i];
- }
- BUG_ON(i != psInfo->iNumPages);
+ if (!bHaveNoPageStructs)
+ {
+
+ goto exit;
+ }
- psInfo->eType = WRAP_TYPE_FIND_VMA_PFN;
+#if defined(VM_PFNMAP)
+ if ((psVMArea->vm_flags & VM_PFNMAP) == 0)
+#endif
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: Region is VM_PFNMAP, but isn't marked as such"));
+ goto error;
+ }
-
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Region can't be locked down"));
-#else
- PVR_DPF((PVR_DBG_WARNING,
- "OSAcquirePhysPageAddr: Raw PFN mappings not supported. Giving up."));
- goto error_release_mmap_sem;
-#endif
+ if (bPFNMismatch)
+ {
+ PVR_DPF((PVR_DBG_ERROR,
+ "OSAcquirePhysPageAddr: PFN calculation mismatch for VM_PFNMAP region"));
+ goto error;
}
+exit:
+ PVR_ASSERT(bMMapSemHeld);
up_read(¤t->mm->mmap_sem);
-exit_check:
- CheckPagesContiguous(psInfo);
+
+ *phOSWrapMem = (IMG_HANDLE)psInfo;
+ if (bHaveNoPageStructs)
+ {
+ PVR_DPF((PVR_DBG_WARNING,
+ "OSAcquirePhysPageAddr: Region contains pages which can't be locked down (no page structures)"));
+ }
+
+ PVR_ASSERT(psInfo->eType != 0);
+#if 0
- *phOSWrapMem = (IMG_HANDLE)psInfo;
+
+ OSCleanCPUCacheRangeKM(pvCPUVAddr, (IMG_VOID *)((IMG_CHAR *)pvCPUVAddr + ui32Bytes));
+#endif
return PVRSRV_OK;
-error_release_mmap_sem:
- up_read(¤t->mm->mmap_sem);
-error_free:
- psInfo->eType = WRAP_TYPE_CLEANUP;
+error:
+ if (bMMapSemHeld)
+ {
+ up_read(¤t->mm->mmap_sem);
+ }
OSReleasePhysPageAddr((IMG_HANDLE)psInfo);
- return PVRSRV_ERROR_GENERIC;
+
+ PVR_ASSERT(eError != PVRSRV_OK);
+
+ return eError;
+}
+
+typedef void (*InnerCacheOp_t)(const void *pvStart, const void *pvEnd);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+typedef void (*InnerCacheOp_mapUnmap_t)(const void *pvStart, const IMG_UINT32 size, const IMG_UINT32 type);
+#endif
+
+typedef void (*OuterCacheOp_t)(unsigned long ulStart, unsigned long ulEnd);
+
+#if defined(CONFIG_OUTER_CACHE)
+
+typedef unsigned long (*MemAreaToPhys_t)(LinuxMemArea *psLinuxMemArea,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32PageNumOffset,
+ IMG_UINT32 ui32PageNum);
+
+static unsigned long VMallocAreaToPhys(LinuxMemArea *psLinuxMemArea,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32PageNumOffset,
+ IMG_UINT32 ui32PageNum)
+{
+ return vmalloc_to_pfn(pvRangeAddrStart + ui32PageNum * PAGE_SIZE) << PAGE_SHIFT;
+}
+
+static unsigned long ExternalKVAreaToPhys(LinuxMemArea *psLinuxMemArea,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32PageNumOffset,
+ IMG_UINT32 ui32PageNum)
+{
+ IMG_SYS_PHYADDR SysPAddr;
+ IMG_CPU_PHYADDR CpuPAddr;
+ SysPAddr = psLinuxMemArea->uData.sExternalKV.uPhysAddr.pSysPhysAddr[ui32PageNumOffset + ui32PageNum];
+ CpuPAddr = SysSysPAddrToCpuPAddr(SysPAddr);
+ return CpuPAddr.uiAddr;
+}
+
+static unsigned long AllocPagesAreaToPhys(LinuxMemArea *psLinuxMemArea,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32PageNumOffset,
+ IMG_UINT32 ui32PageNum)
+{
+ struct page *pPage;
+ pPage = psLinuxMemArea->uData.sPageList.pvPageList[ui32PageNumOffset + ui32PageNum];
+ return page_to_pfn(pPage) << PAGE_SHIFT;
+}
+
+#endif
+
+#ifndef __mips__
+static
+IMG_VOID *FindMMapBaseVAddr(struct list_head *psMMapOffsetStructList,
+ IMG_VOID *pvRangeAddrStart, IMG_UINT32 ui32Length)
+{
+ PKV_OFFSET_STRUCT psOffsetStruct;
+ IMG_VOID *pvMinVAddr;
+
+
+ list_for_each_entry(psOffsetStruct, psMMapOffsetStructList, sAreaItem)
+ {
+ if(OSGetCurrentProcessIDKM() != psOffsetStruct->ui32PID)
+ continue;
+
+ pvMinVAddr = (IMG_VOID *)psOffsetStruct->ui32UserVAddr;
+
+
+ if(pvRangeAddrStart >= pvMinVAddr &&
+ ui32Length <= psOffsetStruct->ui32RealByteSize)
+ return pvMinVAddr;
+ }
+
+ return IMG_NULL;
}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+static
+IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length,
+ void * pfnInnerCacheOp_ptr,
+ OuterCacheOp_t pfnOuterCacheOp,
+ IMG_UINT32 map_unmap)
+#else
+static
+IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length,
+ InnerCacheOp_t pfnInnerCacheOp,
+ OuterCacheOp_t pfnOuterCacheOp)
+#endif
+
+{
+ LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+ IMG_UINT32 ui32AreaLength, ui32AreaOffset = 0;
+ struct list_head *psMMapOffsetStructList;
+ IMG_VOID *pvMinVAddr;
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ InnerCacheOp_t pfnInnerCacheOp = (InnerCacheOp_t)pfnInnerCacheOp_ptr;
+ InnerCacheOp_mapUnmap_t pfnInnerCacheOp_mapUnamp = (InnerCacheOp_mapUnmap_t)pfnInnerCacheOp_ptr;
+#endif
+
+#if defined(CONFIG_OUTER_CACHE)
+ MemAreaToPhys_t pfnMemAreaToPhys = IMG_NULL;
+ IMG_UINT32 ui32PageNumOffset = 0;
+#endif
+
+ PVR_ASSERT(psLinuxMemArea != IMG_NULL);
+
+ ui32AreaLength = psLinuxMemArea->ui32ByteSize;
+ psMMapOffsetStructList = &psLinuxMemArea->sMMapOffsetStructList;
+
+ PVR_ASSERT(ui32Length <= ui32AreaLength);
+
+ if(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC)
+ {
+ ui32AreaOffset = psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset;
+ psLinuxMemArea = psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea;
+ }
+
+
+ PVR_ASSERT(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC);
+
+ switch(psLinuxMemArea->eAreaType)
+ {
+ case LINUX_MEM_AREA_VMALLOC:
+ {
+ pvMinVAddr = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress + ui32AreaOffset;
+
+
+ if(pvRangeAddrStart < pvMinVAddr &&
+ ui32AreaOffset + ui32Length > ui32AreaLength)
+ goto err_blocked;
+
+#if defined(CONFIG_OUTER_CACHE)
+ pfnMemAreaToPhys = VMallocAreaToPhys;
+#endif
+ break;
+ }
+
+ case LINUX_MEM_AREA_EXTERNAL_KV:
+ {
+
+ if (psLinuxMemArea->uData.sExternalKV.bPhysContig == IMG_TRUE)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s: Attempt to flush contiguous external memory", __func__));
+
+ goto err_blocked;
+ }
+
+
+ if (psLinuxMemArea->uData.sExternalKV.pvExternalKV != IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s: Attempt to flush external memory with a kernel virtual address", __func__));
+
+ goto err_blocked;
+ }
+
+
+
+ pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
+ pvRangeAddrStart, ui32Length);
+ if(!pvMinVAddr)
+ goto err_blocked;
+
+#if defined(CONFIG_OUTER_CACHE)
+ ui32PageNumOffset = ((ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
+ pfnMemAreaToPhys = ExternalKVAreaToPhys;
+#endif
+ break;
+ }
+
+ case LINUX_MEM_AREA_ALLOC_PAGES:
+ {
+ pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
+ pvRangeAddrStart, ui32Length);
+ if(!pvMinVAddr)
+ goto err_blocked;
+
+#if defined(CONFIG_OUTER_CACHE)
+ ui32PageNumOffset = ((ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
+ pfnMemAreaToPhys = AllocPagesAreaToPhys;
+#endif
+ break;
+ }
+
+ default:
+ PVR_DBG_BREAK;
+ }
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ if (map_unmap == 0 ) {
+
+ pfnInnerCacheOp(pvRangeAddrStart, pvRangeAddrStart + ui32Length);
+
+ } else if (map_unmap == 1) {
+
+ pfnInnerCacheOp_mapUnamp (pvRangeAddrStart, ui32Length, DMA_TO_DEVICE);
+
+ } else {
+
+ pfnInnerCacheOp_mapUnamp (pvRangeAddrStart, ui32Length, DMA_FROM_DEVICE);
+
+ }
+#else
+pfnInnerCacheOp(pvRangeAddrStart, pvRangeAddrStart + ui32Length);
+#endif
+
+#if defined(CONFIG_OUTER_CACHE)
+
+ if (pfnMemAreaToPhys != IMG_NULL)
+ {
+ unsigned long ulStart, ulEnd, ulLength, ulStartOffset, ulEndOffset;
+ IMG_UINT32 i, ui32NumPages;
+
+
+ ulLength = (unsigned long)ui32Length;
+ ulStartOffset = ((unsigned long)pvRangeAddrStart) & (PAGE_SIZE - 1);
+ ulEndOffset = ((unsigned long)pvRangeAddrStart + ulLength) & (PAGE_SIZE - 1);
+
+ ui32NumPages = (ulStartOffset + ulLength + PAGE_SIZE - 1) >> PAGE_SHIFT;
+ for(i = 0; i < ui32NumPages; i++)
+ {
+ ulStart = pfnMemAreaToPhys(psLinuxMemArea, pvRangeAddrStart,
+ ui32PageNumOffset, i);
+ ulEnd = ulStart + PAGE_SIZE;
-#if defined(SUPPORT_CPU_CACHED_BUFFERS)
+ if(i == ui32NumPages - 1 && ulEndOffset != 0)
+ ulEnd = ulStart + ulEndOffset;
+
+ if(i == 0)
+ ulStart += ulStartOffset;
+
+ pfnOuterCacheOp(ulStart, ulEnd);
+ }
+ }
+ else
+ {
+ PVR_DBG_BREAK;
+ }
+#endif
+
+ return IMG_TRUE;
+
+err_blocked:
+ PVR_DPF((PVR_DBG_WARNING, "%s: Blocked cache op on virtual range "
+ "%p-%p (type %d)", __func__,
+ pvRangeAddrStart, pvRangeAddrStart + ui32Length,
+ psLinuxMemArea->eAreaType));
+ return IMG_FALSE;
+}
+#endif
#if defined(__i386__)
+
+#define ROUND_UP(x,a) (((x) + (a) - 1) & ~((a) - 1))
+
static void per_cpu_cache_flush(void *arg)
{
PVR_UNREFERENCED_PARAMETER(arg);
wbinvd();
}
-#endif
+static void x86_flush_cache_range(const void *pvStart, const void *pvEnd)
+{
+ IMG_BYTE *pbStart = (IMG_BYTE *)pvStart;
+ IMG_BYTE *pbEnd = (IMG_BYTE *)pvEnd;
+ IMG_BYTE *pbBase;
+
+ pbEnd = (IMG_BYTE *)ROUND_UP((IMG_UINTPTR_T)pbEnd,
+ boot_cpu_data.x86_clflush_size);
-IMG_VOID OSFlushCPUCacheKM()
+ mb();
+ for(pbBase = pbStart; pbBase < pbEnd; pbBase += boot_cpu_data.x86_clflush_size)
+ clflush(pbBase);
+ mb();
+}
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID)
{
-#if defined(__arm__)
- flush_cache_all();
-#elif defined(__i386__)
-
- on_each_cpu(per_cpu_cache_flush, NULL, 1);
+
+ ON_EACH_CPU(per_cpu_cache_flush, NULL, 1);
+}
+
+IMG_VOID OSFlushCPUCacheKM(IMG_VOID)
+{
+ ON_EACH_CPU(per_cpu_cache_flush, NULL, 1);
+}
+
+IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) x86_flush_cache_range, IMG_NULL, 0);
#else
-#error "Implement full CPU cache flush for this CPU!"
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ x86_flush_cache_range, IMG_NULL);
+
#endif
}
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) x86_flush_cache_range, IMG_NULL, 0);
+#else
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ x86_flush_cache_range, IMG_NULL);
+#endif
+}
-IMG_VOID OSFlushCPUCacheRangeKM(IMG_VOID *pvRangeAddrStart,
- IMG_VOID *pvRangeAddrEnd)
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
{
- PVR_UNREFERENCED_PARAMETER(pvRangeAddrStart);
- PVR_UNREFERENCED_PARAMETER(pvRangeAddrEnd);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) x86_flush_cache_range, IMG_NULL, 0);
+#else
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ x86_flush_cache_range, IMG_NULL);
+#endif
+}
+
+#else
-
-
#if defined(__arm__)
- flush_cache_all();
-#elif defined(__i386__)
-
- on_each_cpu(per_cpu_cache_flush, NULL, 1);
+
+static void per_cpu_cache_flush(void *arg)
+{
+ PVR_UNREFERENCED_PARAMETER(arg);
+ flush_cache_all();
+}
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID)
+{
+
+ ON_EACH_CPU(per_cpu_cache_flush, NULL, 1);
+#if defined(CONFIG_OUTER_CACHE) && !defined(PVR_NO_FULL_CACHE_OPS)
+ outer_clean_all();
+#endif
+}
+
+IMG_VOID OSFlushCPUCacheKM(IMG_VOID)
+{
+ ON_EACH_CPU(per_cpu_cache_flush, NULL, 1);
+#if defined(CONFIG_OUTER_CACHE) && !defined(PVR_NO_FULL_CACHE_OPS)
+ outer_flush_all();
+#endif
+}
+
+IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) dmac_flush_range, outer_flush_range, 0);
+#else
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ dmac_flush_range, outer_flush_range);
+#endif
+
+}
+
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) dmac_map_area, outer_clean_range, 2);
+#else
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ dmac_clean_range, outer_clean_range);
+#endif
+
+}
+
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ (void *) dmac_unmap_area, outer_inv_range, 1);
#else
-#error "Implement full CPU cache flush for this CPU!"
+ return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+ dmac_inv_range, outer_inv_range);
#endif
}
+#else
+
+#if defined(__mips__)
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID)
+{
+
+ dma_cache_wback(0, 0x100000);
+}
+
+IMG_VOID OSFlushCPUCacheKM(IMG_VOID)
+{
+
+ dma_cache_wback_inv(0, 0x100000);
+}
+
+IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ dma_cache_wback_inv((IMG_UINTPTR_T)pvRangeAddrStart, ui32Length);
+ return IMG_TRUE;
+}
+
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ dma_cache_wback((IMG_UINTPTR_T)pvRangeAddrStart, ui32Length);
+ return IMG_TRUE;
+}
+
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ dma_cache_inv((IMG_UINTPTR_T)pvRangeAddrStart, ui32Length);
+ return IMG_TRUE;
+}
+
+
+#else
+
+#error "Implement CPU cache flush/clean/invalidate primitives for this CPU!"
+
+#endif
+
+#endif
#endif
+PVRSRV_ERROR PVROSFuncInit(IMG_VOID)
+{
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+ {
+ psTimerWorkQueue = create_workqueue("pvr_timer");
+ if (psTimerWorkQueue == NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: couldn't create timer workqueue", __FUNCTION__));
+ return PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD;
+
+ }
+ }
+#endif
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
+ {
+ IMG_UINT32 ui32i;
+
+ for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
+ {
+ TIMER_CALLBACK_DATA *psTimerCBData = &sTimers[ui32i];
+
+ INIT_WORK(&psTimerCBData->sWork, OSTimerWorkQueueCallBack);
+ }
+ }
+#endif
+ return PVRSRV_OK;
+}
+
+IMG_VOID PVROSFuncDeInit(IMG_VOID)
+{
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+ if (psTimerWorkQueue != NULL)
+ {
+ destroy_workqueue(psTimerWorkQueue);
+ }
+#endif
+}
LinuxMMapPerProcessConnect(psEnvPerProc);
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+
+ INIT_LIST_HEAD(&psEnvPerProc->sDRMAuthListHead);
+#endif
+
return PVRSRV_OK;
}
*
******************************************************************************/
-#if defined (SUPPORT_SGX)
+#if defined (SUPPORT_SGX) || defined (SUPPORT_VGX)
#if defined (PDUMP)
#include <asm/atomic.h>
#include <stdarg.h>
-#include "sgxdefs.h"
+#if defined (SUPPORT_SGX)
+#include "sgxdefs.h"
+#endif
#include "services_headers.h"
#include "pvrversion.h"
#include "pvr_debug.h"
#include "dbgdrvif.h"
+#if defined (SUPPORT_SGX)
#include "sgxmmu.h"
+#endif
#include "mm.h"
#include "pdump_km.h"
+#include "pdump_int.h"
-#include <linux/tty.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
static IMG_BOOL PDumpWriteString2 (IMG_CHAR * pszString, IMG_UINT32 ui32Flags);
static IMG_BOOL PDumpWriteILock (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags);
static IMG_VOID DbgSetFrame (PDBG_STREAM psStream, IMG_UINT32 ui32Frame);
-static IMG_UINT32 DbgGetFrame (PDBG_STREAM psStream);
static IMG_VOID DbgSetMarker (PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
-static IMG_UINT32 DbgWrite (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags);
#define PDUMP_DATAMASTER_PIXEL (1)
#define PDUMP_DATAMASTER_EDM (3)
-#define MIN(a,b) (a > b ? b : a)
-
#define MAX_FILE_SIZE 0x40000000
static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
static inline IMG_BOOL PDumpSuspended(IMG_VOID)
{
- return atomic_read(&gsPDumpSuspended) != 0;
+ return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
}
PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
*pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
if ((!*phScript) || PDumpSuspended())
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
}
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpOSGetMessageString(IMG_HANDLE *phMsg,
+PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg,
IMG_UINT32 *pui32MaxLen)
{
- *phMsg = (IMG_HANDLE)gsDBGPdumpState.pszMsg;
+ *ppszMsg = gsDBGPdumpState.pszMsg;
*pui32MaxLen = SZ_MSG_SIZE_MAX;
- if ((!*phMsg) || PDumpSuspended())
+ if ((!*ppszMsg) || PDumpSuspended())
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
}
return PVRSRV_OK;
}
*pui32MaxLen = SZ_FILENAME_SIZE_MAX;
if ((!*ppszFile) || PDumpSuspended())
{
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
}
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
{
IMG_CHAR* pszBuf = hBuf;
- IMG_UINT32 n;
+ IMG_INT32 n;
va_list vaArgs;
va_start(vaArgs, pszFormat);
va_end(vaArgs);
- if (n>=ui32ScriptSizeMax || n==-1)
+ if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
{
PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
}
+#if defined(PDUMP_DEBUG_OUTFILES)
+ g_ui32EveryLineCounter++;
+#endif
return PVRSRV_OK;
}
PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs)
{
- IMG_UINT32 n;
+ IMG_INT32 n;
n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
- if (n>=ui32ScriptSizeMax || n==-1)
+ if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
{
PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
{
+ PVR_UNREFERENCED_PARAMETER(pszFormat);
+
}
PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
{
- IMG_UINT32 n;
+ IMG_INT32 n;
va_list vaArgs;
va_start(vaArgs, pszFormat);
va_end(vaArgs);
- if (n>=ui32ScriptSizeMax || n==-1)
+ if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
{
PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
{
- IMG_UINT32 ui32Count = 0;
+ IMG_UINT32 ui32Count;
IMG_CHAR* pszBuf = hBuffer;
PVR_UNREFERENCED_PARAMETER(hStream);
PVR_UNREFERENCED_PARAMETER(ui32Size);
- PVR_UNREFERENCED_PARAMETER(ui32Size);
+ PVR_UNREFERENCED_PARAMETER(ui32Flags);
}
IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
{
- return atomic_read(&gsPDumpSuspended) != 0;
+ return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
}
IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_UINT32 ui32PageSize,
IMG_DEV_PHYADDR *psDevPAddr)
{
- if(hOSMemHandle)
- {
-
- IMG_CPU_PHYADDR sCpuPAddr;
+ IMG_CPU_PHYADDR sCpuPAddr;
- PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+ PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+ PVR_UNREFERENCED_PARAMETER(ui32PageSize);
- sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
- PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
-
-
- *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- }
- else
- {
- IMG_CPU_PHYADDR sCpuPAddr;
-
- PVR_UNREFERENCED_PARAMETER(ui32Offset);
+
+
+ PVR_ASSERT (hOSMemHandle != IMG_NULL);
+
+ sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
+ PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
- sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
- *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
- }
+
+ *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
}
IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
IMG_UINT32 ui32Offset,
IMG_PUINT8 pui8LinAddr,
+ IMG_UINT32 ui32DataPageMask,
IMG_UINT32 *pui32PageOffset)
{
if(hOSMemHandle)
PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
- *pui32PageOffset = sCpuPAddr.uiAddr & (HOST_PAGESIZE() -1);
+ *pui32PageOffset = sCpuPAddr.uiAddr & ui32DataPageMask;
}
else
{
PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
PVR_UNREFERENCED_PARAMETER(ui32Offset);
- *pui32PageOffset = (IMG_UINT32)pui8LinAddr & (HOST_PAGESIZE() - 1);
+ *pui32PageOffset = ((IMG_UINT32)pui8LinAddr & ui32DataPageMask);
}
}
+IMG_UINT32 PDumpOSDebugDriverWrite( PDBG_STREAM psStream,
+ PDUMP_DDWMODE eDbgDrvWriteMode,
+ IMG_UINT8 *pui8Data,
+ IMG_UINT32 ui32BCount,
+ IMG_UINT32 ui32Level,
+ IMG_UINT32 ui32DbgDrvFlags)
+{
+ switch(eDbgDrvWriteMode)
+ {
+ case PDUMP_WRITE_MODE_CONTINUOUS:
+ PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
+ return gpfnDbgDrv->pfnDBGDrivWrite2(psStream, pui8Data, ui32BCount, ui32Level);
+ case PDUMP_WRITE_MODE_LASTFRAME:
+ return gpfnDbgDrv->pfnWriteLF(psStream, pui8Data, ui32BCount, ui32Level, ui32DbgDrvFlags);
+ case PDUMP_WRITE_MODE_BINCM:
+ PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
+ return gpfnDbgDrv->pfnWriteBINCM(psStream, pui8Data, ui32BCount, ui32Level);
+ case PDUMP_WRITE_MODE_PERSISTENT:
+ PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
+ return gpfnDbgDrv->pfnWritePersist(psStream, pui8Data, ui32BCount, ui32Level);
+ default:
+ PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
+ break;
+ }
+ return 0xFFFFFFFFU;
+}
+IMG_VOID PDumpOSReleaseExecution(IMG_VOID)
+{
+ OSReleaseThreadQuanta();
+}
IMG_VOID PDumpInit(IMG_VOID)
{
IMG_UINT32 i;
+ DBGKM_CONNECT_NOTIFIER sConnectNotifier;
if (!gpfnDbgDrv)
DBGDrvGetServiceTable((IMG_VOID **)&gpfnDbgDrv);
-
if (gpfnDbgDrv == IMG_NULL)
{
return;
}
+
+
+ sConnectNotifier.pfnConnectNotifier = &PDumpConnectionNotify;
+ gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
if(!gsDBGPdumpState.pszFile)
{
gsDBGPdumpState.pszMsg = IMG_NULL;
}
+
+ sConnectNotifier.pfnConnectNotifier = 0;
+ gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
+
gpfnDbgDrv = IMG_NULL;
}
IMG_VOID PDumpDeInit(IMG_VOID)
{
IMG_UINT32 i;
+ DBGKM_CONNECT_NOTIFIER sConnectNotifier;
for(i=0; i < PDUMP_NUM_STREAMS; i++)
{
gsDBGPdumpState.pszMsg = IMG_NULL;
}
+
+ sConnectNotifier.pfnConnectNotifier = 0;
+ gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
+
gpfnDbgDrv = IMG_NULL;
}
}
-IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID)
+IMG_BOOL PDumpOSIsCaptureFrameKM(IMG_VOID)
{
if (PDumpSuspended())
{
return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
}
-PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
+PVRSRV_ERROR PDumpOSSetFrameKM(IMG_UINT32 ui32Frame)
{
IMG_UINT32 ui32Stream;
return PVRSRV_OK;
}
-PVRSRV_ERROR PDumpGetFrameKM(IMG_PUINT32 pui32Frame)
-{
- *pui32Frame = DbgGetFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
-
- return PVRSRV_OK;
-}
-
-
static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
{
static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
{
IMG_UINT32 ui32Written = 0;
- IMG_UINT32 ui32Off = 0;
-
if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
{
+ PVR_DPF((PVR_DBG_MESSAGE, "PDumpWriteILock: Failed to write 0x%x bytes to stream 0x%x", ui32Count, (IMG_UINT32)psStream));
return IMG_TRUE;
}
}
}
-
- while (((IMG_UINT32) ui32Count > 0) && (ui32Written != 0xFFFFFFFF))
- {
- ui32Written = DbgWrite(psStream, &pui8Data[ui32Off], ui32Count, ui32Flags);
-
-
-
-
- if (ui32Written == 0)
- {
- OSReleaseThreadQuanta();
- }
-
- if (ui32Written != 0xFFFFFFFF)
- {
- ui32Off += ui32Written;
- ui32Count -= ui32Written;
- }
- }
+ ui32Written = DbgWrite(psStream, pui8Data, ui32Count, ui32Flags);
if (ui32Written == 0xFFFFFFFF)
{
gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
}
-
-static IMG_UINT32 DbgGetFrame(PDBG_STREAM psStream)
-{
- return gpfnDbgDrv->pfnGetFrame(psStream);
-}
-
static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
{
gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
}
-static IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags)
-{
- IMG_UINT32 ui32BytesWritten;
-
- if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)
- {
-
-
- if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
- (psStream->ui32Start == 0xFFFFFFFFUL) &&
- (psStream->ui32End == 0xFFFFFFFFUL) &&
- psStream->bInitPhaseComplete)
- {
- ui32BytesWritten = ui32BCount;
- }
- else
- {
- ui32BytesWritten = gpfnDbgDrv->pfnDBGDrivWrite2(psStream, pui8Data, ui32BCount, 1);
- }
- }
- else
- {
- if (ui32Flags & PDUMP_FLAGS_LASTFRAME)
- {
- IMG_UINT32 ui32DbgFlags;
-
- ui32DbgFlags = 0;
- if (ui32Flags & PDUMP_FLAGS_RESETLFBUFFER)
- {
- ui32DbgFlags |= WRITELF_FLAGS_RESETBUF;
- }
-
- ui32BytesWritten = gpfnDbgDrv->pfnWriteLF(psStream, pui8Data, ui32BCount, 1, ui32DbgFlags);
- }
- else
- {
- ui32BytesWritten = gpfnDbgDrv->pfnWriteBINCM(psStream, pui8Data, ui32BCount, 1);
- }
- }
-
- return ui32BytesWritten;
-}
-
-
IMG_VOID PDumpSuspendKM(IMG_VOID)
{
atomic_inc(&gsPDumpSuspended);
#ifndef __INCLUDED_PRIVATE_DATA_H_
#define __INCLUDED_PRIVATE_DATA_H_
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+#include <linux/list.h>
+#include <drm/drmP.h>
+#endif
+
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_LINUX_USING_WORKQUEUES)
+#include <linux/workqueue.h>
+#endif
+
typedef struct
{
IMG_HANDLE hKernelMemInfo;
#endif
+#if defined(SUPPORT_DRI_DRM)
+#if defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ struct drm_file *psDRMFile;
+
+
+ struct list_head sDRMAuthListItem;
+#endif
+
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+ struct work_struct sReleaseWork;
+#endif
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+ IMG_PVOID pPriv;
+#endif
+#endif
+
#if defined(SUPPORT_MEMINFO_IDS)
IMG_UINT64 ui64Stamp;
IMG_HANDLE hBlockAlloc;
-
-#if defined(SUPPORT_DRI_DRM_EXT)
- IMG_PVOID pPriv;
-#endif
}
PVRSRV_FILE_PRIVATE_DATA;
#include "linkage.h"
#include "lists.h"
-DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
-
static struct proc_dir_entry * dir;
-#ifndef PVR_PROC_USE_SEQ_FILE
-static off_t procDumpSysNodes(IMG_CHAR *buf, size_t size, off_t off);
-static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off);
-#endif
-
-
static const IMG_CHAR PVRProcDirRoot[] = "pvr";
-
-#ifdef PVR_PROC_USE_SEQ_FILE
-
-#define PVR_PROC_SEQ_START_TOKEN (void*)1
static IMG_INT pvr_proc_open(struct inode *inode,struct file *file);
static void *pvr_proc_seq_start (struct seq_file *m, loff_t *pos);
static void pvr_proc_seq_stop (struct seq_file *m, void *v);
static struct proc_dir_entry* g_pProcVersion;
static struct proc_dir_entry* g_pProcSysNodes;
-#ifdef DEBUG_PVR
+#ifdef DEBUG
static struct proc_dir_entry* g_pProcDebugLevel;
#endif
static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el);
static void* ProcSeqOff2ElementSysNodes(struct seq_file * sfile, loff_t off);
-#endif
-
off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * format, ...)
{
IMG_INT n;
size_t space = size - (size_t)off;
va_list ap;
- PVR_ASSERT(space >= 0);
-
va_start (ap, format);
n = vsnprintf (buffer+off, space, format, ap);
}
-#ifdef PVR_PROC_USE_SEQ_FILE
-
void* ProcSeq1ElementOff2Element(struct seq_file *sfile, loff_t off)
{
+ PVR_UNREFERENCED_PARAMETER(sfile);
if(!off)
return (void*)2;
void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off)
{
+ PVR_UNREFERENCED_PARAMETER(sfile);
+
if(!off)
{
return PVR_PROC_SEQ_START_TOKEN;
struct inode *inode = file->f_path.dentry->d_inode;
struct proc_dir_entry * dp;
+ PVR_UNREFERENCED_PARAMETER(ppos);
dp = PDE(inode);
if (!dp->write_proc)
static void pvr_proc_seq_stop (struct seq_file *proc_seq_file, void *v)
{
PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+ PVR_UNREFERENCED_PARAMETER(v);
+
if(handlers->startstop != NULL)
handlers->startstop(proc_seq_file, IMG_FALSE);
}
}
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDirSeq: cannot make proc entry /proc/%s/%s: no memory", PVRProcDirRoot, name));
- return 0;
+ return NULL;
}
show_handler,
off2element_handler,
startstop_handler,
- NULL
+ whandler
);
}
IMG_CHAR dirname[16];
IMG_INT ret;
- ret = snprintf(dirname, sizeof(dirname), "%lu", ui32PID);
+ ret = snprintf(dirname, sizeof(dirname), "%u", ui32PID);
if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
{
}
}
-#endif
-
static IMG_INT pvr_read_proc(IMG_CHAR *page, IMG_CHAR **start, off_t off,
IMG_INT count, IMG_INT *eof, IMG_VOID *data)
{
+
pvr_read_proc_t *pprn = (pvr_read_proc_t *)data;
off_t len = pprn (page, (size_t)count, off);
IMG_CHAR dirname[16];
IMG_INT ret;
- ret = snprintf(dirname, sizeof(dirname), "%lu", ui32PID);
+ ret = snprintf(dirname, sizeof(dirname), "%u", ui32PID);
if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
{
return -ENOMEM;
}
+
file = create_proc_read_entry (name, S_IFREG | S_IRUGO, dir, pvr_read_proc, (IMG_VOID *)handler);
if (file)
return -ENOMEM;
}
-#ifdef PVR_PROC_USE_SEQ_FILE
g_pProcQueue = CreateProcReadEntrySeq("queue", NULL, NULL, ProcSeqShowQueue, ProcSeqOff2ElementQueue, NULL);
g_pProcVersion = CreateProcReadEntrySeq("version", NULL, NULL, ProcSeqShowVersion, ProcSeq1ElementHeaderOff2Element, NULL);
g_pProcSysNodes = CreateProcReadEntrySeq("nodes", NULL, NULL, ProcSeqShowSysNodes, ProcSeqOff2ElementSysNodes, NULL);
if(!g_pProcQueue || !g_pProcVersion || !g_pProcSysNodes)
-#else
- if (CreateProcReadEntry("queue", QueuePrintQueues) ||
- CreateProcReadEntry("version", procDumpVersion) ||
- CreateProcReadEntry("nodes", procDumpSysNodes))
-#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s files", PVRProcDirRoot));
}
-#ifdef DEBUG_PVR
+#ifdef DEBUG
-#ifdef PVR_PROC_USE_SEQ_FILE
g_pProcDebugLevel = CreateProcEntrySeq("debug_level", NULL, NULL,
ProcSeqShowDebugLevel,
ProcSeq1ElementOff2Element, NULL,
- PVRDebugProcSetLevel);
+ (IMG_VOID*)PVRDebugProcSetLevel);
if(!g_pProcDebugLevel)
-#else
- if (CreateProcEntry ("debug_level", PVRDebugProcGetLevel, PVRDebugProcSetLevel, 0))
-#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/debug_level", PVRProcDirRoot));
}
#ifdef PVR_MANUAL_POWER_CONTROL
-#ifdef PVR_PROC_USE_SEQ_FILE
g_pProcPowerLevel = CreateProcEntrySeq("power_control", NULL, NULL,
ProcSeqShowPowerLevel,
ProcSeq1ElementOff2Element, NULL,
PVRProcSetPowerLevel);
if(!g_pProcPowerLevel)
-#else
- if (CreateProcEntry("power_control", PVRProcGetPowerLevel, PVRProcSetPowerLevel, 0))
-#endif
{
PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/power_control", PVRProcDirRoot));
IMG_VOID RemoveProcEntries(IMG_VOID)
{
-#ifdef DEBUG_PVR
-
-#ifdef PVR_PROC_USE_SEQ_FILE
- RemoveProcEntrySeq( g_pProcDebugLevel );
-#else
- RemoveProcEntry("debug_level");
-#endif
-
+#ifdef DEBUG
+ RemoveProcEntrySeq( g_pProcDebugLevel );
#ifdef PVR_MANUAL_POWER_CONTROL
-#ifdef PVR_PROC_USE_SEQ_FILE
- RemoveProcEntrySeq( g_pProcPowerLevel );
-#else
- RemoveProcEntry("power_control");
-#endif
-#endif
-
+ RemoveProcEntrySeq( g_pProcPowerLevel );
#endif
+#endif
-#ifdef PVR_PROC_USE_SEQ_FILE
- RemoveProcEntrySeq(g_pProcQueue);
- RemoveProcEntrySeq(g_pProcVersion);
+ RemoveProcEntrySeq(g_pProcQueue);
+ RemoveProcEntrySeq(g_pProcVersion);
RemoveProcEntrySeq(g_pProcSysNodes);
-#else
- RemoveProcEntry("queue");
- RemoveProcEntry("version");
- RemoveProcEntry("nodes");
-#endif
- while (dir->subdir)
- {
- PVR_DPF((PVR_DBG_WARNING, "Belatedly removing /proc/%s/%s", PVRProcDirRoot, dir->subdir->name));
+ while (dir->subdir)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "Belatedly removing /proc/%s/%s", PVRProcDirRoot, dir->subdir->name));
- RemoveProcEntry(dir->subdir->name);
- }
+ RemoveProcEntry(dir->subdir->name);
+ }
- remove_proc_entry(PVRProcDirRoot, NULL);
+ remove_proc_entry(PVRProcDirRoot, NULL);
}
-
-#ifdef PVR_PROC_USE_SEQ_FILE
-
static void ProcSeqShowVersion(struct seq_file *sfile,void* el)
{
- SYS_DATA * psSysData;
+ SYS_DATA *psSysData;
IMG_CHAR *pszSystemVersionString = "None";
if(el == PVR_PROC_SEQ_START_TOKEN)
{
- seq_printf( sfile,
- "Version %s (%s) %s\n",
- PVRVERSION_STRING,
- PVR_BUILD_TYPE, PVR_BUILD_DIR);
+ seq_printf(sfile,
+ "Version %s (%s) %s\n",
+ PVRVERSION_STRING,
+ PVR_BUILD_TYPE, PVR_BUILD_DIR);
return;
}
- SysAcquireData(&psSysData);
-
- if(psSysData->pszVersionString)
+ psSysData = SysAcquireDataNoCheck();
+ if(psSysData != IMG_NULL && psSysData->pszVersionString != IMG_NULL)
{
- pszSystemVersionString = psSysData->pszVersionString;
- }
+ pszSystemVersionString = psSysData->pszVersionString;
+ }
seq_printf( sfile, "System Version String: %s\n", pszSystemVersionString);
}
-#else
-
-static off_t procDumpVersion(IMG_CHAR *buf, size_t size, off_t off)
-{
- SYS_DATA *psSysData;
-
- if (off == 0)
- {
- return printAppend(buf, size, 0,
- "Version %s (%s) %s\n",
- PVRVERSION_STRING,
- PVR_BUILD_TYPE, PVR_BUILD_DIR);
- }
-
- SysAcquireData(&psSysData);
-
- if (off == 1)
- {
- IMG_CHAR *pszSystemVersionString = "None";
-
- if(psSysData->pszVersionString)
- {
- pszSystemVersionString = psSysData->pszVersionString;
- }
-
- if(strlen(pszSystemVersionString)
- + strlen("System Version String: \n")
- + 1 > size)
- {
- return 0;
- }
- return printAppend(buf, size, 0,
- "System Version String: %s\n",
- pszSystemVersionString);
- }
-
- return END_OF_FILE;
-}
-
-#endif
-
-
static const IMG_CHAR *deviceTypeToString(PVRSRV_DEVICE_TYPE deviceType)
{
switch (deviceType)
}
}
-IMG_VOID* DecOffPsDev_AnyVaCb(PVRSRV_DEVICE_NODE *psNode, va_list va)
+static IMG_VOID* DecOffPsDev_AnyVaCb(PVRSRV_DEVICE_NODE *psNode, va_list va)
{
off_t *pOff = va_arg(va, off_t*);
if (--(*pOff))
}
}
-#ifdef PVR_PROC_USE_SEQ_FILE
-
static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el)
{
- SYS_DATA * psSysData;
- PVRSRV_DEVICE_NODE *psDevNode = (PVRSRV_DEVICE_NODE*)el;
+ PVRSRV_DEVICE_NODE *psDevNode;
if(el == PVR_PROC_SEQ_START_TOKEN)
{
return;
}
- SysAcquireData(&psSysData);
+ psDevNode = (PVRSRV_DEVICE_NODE*)el;
seq_printf( sfile,
- "%p %-8s %-8s %4d %2lu %p %3lu %p\n",
- psDevNode,
- deviceTypeToString(psDevNode->sDevId.eDeviceType),
- deviceClassToString(psDevNode->sDevId.eDeviceClass),
- psDevNode->sDevId.eDeviceClass,
- psDevNode->ui32RefCount,
- psDevNode->pvDevice,
- psDevNode->ui32pvDeviceSize,
- psDevNode->hResManContext);
-
+ "%p %-8s %-8s %4d %2u %p %3u %p\n",
+ psDevNode,
+ deviceTypeToString(psDevNode->sDevId.eDeviceType),
+ deviceClassToString(psDevNode->sDevId.eDeviceClass),
+ psDevNode->sDevId.eDeviceClass,
+ psDevNode->ui32RefCount,
+ psDevNode->pvDevice,
+ psDevNode->ui32pvDeviceSize,
+ psDevNode->hResManContext);
}
static void* ProcSeqOff2ElementSysNodes(struct seq_file * sfile, loff_t off)
{
SYS_DATA *psSysData;
- PVRSRV_DEVICE_NODE *psDevNode;
- if(!off)
- {
- return PVR_PROC_SEQ_START_TOKEN;
- }
-
- SysAcquireData(&psSysData);
-
+ PVRSRV_DEVICE_NODE*psDevNode = IMG_NULL;
- psDevNode = (PVRSRV_DEVICE_NODE*)
- List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
- DecOffPsDev_AnyVaCb,
- &off);
-
-
- return (void*)psDevNode;
-}
-
-#else
-
-static
-off_t procDumpSysNodes(IMG_CHAR *buf, size_t size, off_t off)
-{
- SYS_DATA *psSysData;
- PVRSRV_DEVICE_NODE *psDevNode;
- off_t len;
-
+ PVR_UNREFERENCED_PARAMETER(sfile);
- if (size < 80)
+ if(!off)
{
- return 0;
+ return PVR_PROC_SEQ_START_TOKEN;
}
- if (off == 0)
+ psSysData = SysAcquireDataNoCheck();
+ if (psSysData != IMG_NULL)
{
- return printAppend(buf, size, 0,
- "Registered nodes\n"
- "Addr Type Class Index Ref pvDev Size Res\n");
- }
-
- SysAcquireData(&psSysData);
-
-
+
psDevNode = (PVRSRV_DEVICE_NODE*)
- List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+ List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
DecOffPsDev_AnyVaCb,
&off);
-
- if (!psDevNode)
- {
- return END_OF_FILE;
}
- len = printAppend(buf, size, 0,
- "%p %-8s %-8s %4d %2lu %p %3lu %p\n",
- psDevNode,
- deviceTypeToString(psDevNode->sDevId.eDeviceType),
- deviceClassToString(psDevNode->sDevId.eDeviceClass),
- psDevNode->sDevId.eDeviceClass,
- psDevNode->ui32RefCount,
- psDevNode->pvDevice,
- psDevNode->ui32pvDeviceSize,
- psDevNode->hResManContext);
- return (len);
+
+ return (void*)psDevNode;
}
-#endif
-
typedef off_t (pvr_read_proc_t)(IMG_CHAR *, size_t, off_t);
-#ifdef PVR_PROC_USE_SEQ_FILE
#define PVR_PROC_SEQ_START_TOKEN (void*)1
typedef void* (pvr_next_proc_seq_t)(struct seq_file *,void*,loff_t);
typedef void* (pvr_off2element_proc_seq_t)(struct seq_file *, loff_t);
void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off);
-
-#endif
-
off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * format, ...)
__attribute__((format(printf, 4, 5)));
IMG_VOID RemoveProcEntries(IMG_VOID);
-#ifdef PVR_PROC_USE_SEQ_FILE
struct proc_dir_entry* CreateProcReadEntrySeq (
const IMG_CHAR* name,
IMG_VOID* data,
IMG_VOID RemoveProcEntrySeq(struct proc_dir_entry* proc_entry);
IMG_VOID RemovePerProcessProcEntrySeq(struct proc_dir_entry* proc_entry);
-#endif
-
#endif
#include "proc.h"
#include "private_data.h"
#include "linkage.h"
+#include "pvr_bridge_km.h"
#if defined(SUPPORT_DRI_DRM)
#include <drm/drmP.h>
+#include "pvr_drm.h"
+#if defined(PVR_SECURE_DRM_AUTH_EXPORT)
+#include "env_perproc.h"
+#endif
#endif
#if defined(SUPPORT_VGX)
#if defined(DEBUG_BRIDGE_KM)
-#ifdef PVR_PROC_USE_SEQ_FILE
static struct proc_dir_entry *g_ProcBridgeStats =0;
static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off);
static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el);
static void* ProcSeqOff2ElementBridgeStats(struct seq_file * sfile, loff_t off);
static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start);
-#else
-static off_t printLinuxBridgeStats(IMG_CHAR * buffer, size_t size, off_t off);
-#endif
-
#endif
extern PVRSRV_LINUX_MUTEX gPVRSRVLock;
{
#if defined(DEBUG_BRIDGE_KM)
{
- IMG_INT iStatus;
-#ifdef PVR_PROC_USE_SEQ_FILE
g_ProcBridgeStats = CreateProcReadEntrySeq(
"bridge_stats",
NULL,
ProcSeqOff2ElementBridgeStats,
ProcSeqStartstopBridgeStats
);
- iStatus = !g_ProcBridgeStats ? -1 : 0;
-#else
- iStatus = CreateProcReadEntry("bridge_stats", printLinuxBridgeStats);
-#endif
-
- if(iStatus!=0)
+ if(!g_ProcBridgeStats)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
}
LinuxBridgeDeInit(IMG_VOID)
{
#if defined(DEBUG_BRIDGE_KM)
-#ifdef PVR_PROC_USE_SEQ_FILE
RemoveProcEntrySeq(g_ProcBridgeStats);
-#else
- RemoveProcEntry("bridge_stats");
-#endif
#endif
}
#if defined(DEBUG_BRIDGE_KM)
-#ifdef PVR_PROC_USE_SEQ_FILE
-
static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start)
{
if(start)
if(el == PVR_PROC_SEQ_START_TOKEN)
{
seq_printf(sfile,
- "Total ioctl call count = %lu\n"
- "Total number of bytes copied via copy_from_user = %lu\n"
- "Total number of bytes copied via copy_to_user = %lu\n"
- "Total number of bytes copied via copy_*_user = %lu\n\n"
+ "Total ioctl call count = %u\n"
+ "Total number of bytes copied via copy_from_user = %u\n"
+ "Total number of bytes copied via copy_to_user = %u\n"
+ "Total number of bytes copied via copy_*_user = %u\n\n"
"%-45s | %-40s | %10s | %20s | %10s\n",
g_BridgeGlobalStats.ui32IOCTLCount,
g_BridgeGlobalStats.ui32TotalCopyFromUserBytes,
}
seq_printf(sfile,
- "%-45s %-40s %-10lu %-20lu %-10lu\n",
+ "%-45s %-40s %-10u %-20u %-10u\n",
psEntry->pszIOCName,
psEntry->pszFunctionName,
psEntry->ui32CallCount,
psEntry->ui32CopyToUserTotalBytes);
}
-#else
-
-static off_t
-printLinuxBridgeStats(IMG_CHAR * buffer, size_t count, off_t off)
-{
- PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY *psEntry;
- off_t Ret;
-
- LinuxLockMutex(&gPVRSRVLock);
-
- if(!off)
- {
- if(count < 500)
- {
- Ret = 0;
- goto unlock_and_return;
- }
- Ret = printAppend(buffer, count, 0,
- "Total ioctl call count = %lu\n"
- "Total number of bytes copied via copy_from_user = %lu\n"
- "Total number of bytes copied via copy_to_user = %lu\n"
- "Total number of bytes copied via copy_*_user = %lu\n\n"
- "%-45s | %-40s | %10s | %20s | %10s\n",
- g_BridgeGlobalStats.ui32IOCTLCount,
- g_BridgeGlobalStats.ui32TotalCopyFromUserBytes,
- g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
- g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
- "Bridge Name",
- "Wrapper Function",
- "Call Count",
- "copy_from_user Bytes",
- "copy_to_user Bytes"
- );
- goto unlock_and_return;
- }
-
- if(off > BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)
- {
- Ret = END_OF_FILE;
- goto unlock_and_return;
- }
-
- if(count < 300)
- {
- Ret = 0;
- goto unlock_and_return;
- }
-
- psEntry = &g_BridgeDispatchTable[off-1];
- Ret = printAppend(buffer, count, 0,
- "%-45s %-40s %-10lu %-20lu %-10lu\n",
- psEntry->pszIOCName,
- psEntry->pszFunctionName,
- psEntry->ui32CallCount,
- psEntry->ui32CopyFromUserTotalBytes,
- psEntry->ui32CopyToUserTotalBytes);
-
-unlock_and_return:
- LinuxUnLockMutex(&gPVRSRVLock);
- return Ret;
-}
#endif
-#endif
-
#if defined(SUPPORT_DRI_DRM)
-IMG_INT
-PVRSRV_BridgeDispatchKM(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile)
+int
+PVRSRV_BridgeDispatchKM(struct drm_device unref__ *dev, void *arg, struct drm_file *pFile)
#else
-IMG_INT32
-PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT unref__ ioctlCmd, IMG_UINT32 arg)
+long
+PVRSRV_BridgeDispatchKM(struct file *pFile, unsigned int unref__ ioctlCmd, unsigned long arg)
#endif
{
IMG_UINT32 cmd;
LinuxLockMutex(&gPVRSRVLock);
#if defined(SUPPORT_DRI_DRM)
- PVR_UNREFERENCED_PARAMETER(dev);
-
psBridgePackageKM = (PVRSRV_BRIDGE_PACKAGE *)arg;
PVR_ASSERT(psBridgePackageKM != IMG_NULL);
#else
- PVR_UNREFERENCED_PARAMETER(ioctlCmd);
-
psBridgePackageKM = &sBridgePackageKM;
if(!OSAccessOK(PVR_VERIFY_WRITE,
}
}
#endif
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+ switch(cmd)
+ {
+ case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
+ case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
+ {
+ PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
+ int authenticated = pFile->authenticated;
+ PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
+
+ if (authenticated)
+ {
+ break;
+ }
+
+
+ psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)PVRSRVProcessPrivateData(psPerProc);
+ if (psEnvPerProc == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: Process private data not allocated", __FUNCTION__));
+ err = -EFAULT;
+ goto unlock_and_return;
+ }
+
+ list_for_each_entry(psPrivateData, &psEnvPerProc->sDRMAuthListHead, sDRMAuthListItem)
+ {
+ struct drm_file *psDRMFile = psPrivateData->psDRMFile;
+
+ if (pFile->master == psDRMFile->master)
+ {
+ authenticated |= psDRMFile->authenticated;
+ if (authenticated)
+ {
+ break;
+ }
+ }
+ }
+
+ if (!authenticated)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: Not authenticated for mapping device or device class memory", __FUNCTION__));
+ err = -EPERM;
+ goto unlock_and_return;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+#endif
err = BridgedDispatchKM(psPerProc, psBridgePackageKM);
if(err != PVRSRV_OK)
*
******************************************************************************/
-
#ifndef AUTOCONF_INCLUDED
#include <linux/config.h>
#endif
#include <linux/hardirq.h>
#include <linux/module.h>
#include <linux/spinlock.h>
-#include <linux/tty.h>
+#include <linux/string.h>
#include <stdarg.h>
#include "img_types.h"
#include "servicesext.h"
#include "pvr_debug.h"
+#include "srvkm.h"
#include "proc.h"
#include "mutex.h"
#include "linkage.h"
+#include "pvr_uaccess.h"
+
+static IMG_BOOL VBAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz,
+ const IMG_CHAR* pszFormat, va_list VArgs)
+ IMG_FORMAT_PRINTF(3, 0);
+
#if defined(PVRSRV_NEED_PVR_DPF)
#define PVR_MAX_FILEPATH_LEN 256
-static IMG_UINT32 gPVRDebugLevel = DBGPRIV_WARNING;
+static IMG_BOOL BAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz,
+ const IMG_CHAR *pszFormat, ...)
+ IMG_FORMAT_PRINTF(3, 4);
+
+IMG_UINT32 gPVRDebugLevel =
+ (DBGPRIV_FATAL | DBGPRIV_ERROR | DBGPRIV_WARNING);
#endif
static PVRSRV_LINUX_MUTEX gsDebugMutexNonIRQ;
-static DEFINE_SPINLOCK(gsDebugLockIRQ);
+
+static spinlock_t gsDebugLockIRQ = SPIN_LOCK_UNLOCKED;
+#if !defined (USE_SPIN_LOCK)
#define USE_SPIN_LOCK (in_interrupt() || !preemptible())
+#endif
static inline void GetBufferLock(unsigned long *pulLockFlags)
{
pszBuf[ui32BufSiz - 1] = 0;
- return (i32Len < 0 || i32Len >= ui32Space);
+ return (i32Len < 0 || i32Len >= (IMG_INT32)ui32Space) ? IMG_TRUE : IMG_FALSE;
}
IMG_VOID PVRDPFInit(IMG_VOID)
{
printk(KERN_INFO "%s\n", pszBuf);
}
-
+
ReleaseBufferLock(ulLockFlags);
va_end(VArgs);
static IMG_BOOL BAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR *pszFormat, ...)
{
- va_list VArgs;
- IMG_BOOL bTrunc;
+ va_list VArgs;
+ IMG_BOOL bTrunc;
- va_start (VArgs, pszFormat);
-
- bTrunc = VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs);
+ va_start (VArgs, pszFormat);
+
+ bTrunc = VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs);
- va_end (VArgs);
+ va_end (VArgs);
- return bTrunc;
+ return bTrunc;
}
IMG_VOID PVRSRVDebugPrintf (
...
)
{
- IMG_BOOL bTrace, bDebug;
- const IMG_CHAR *pszFileName = pszFullFileName;
- IMG_CHAR *pszLeafName;
-
- bTrace = gPVRDebugLevel & ui32DebugLevel & DBGPRIV_CALLTRACE;
- bDebug = ((gPVRDebugLevel & DBGPRIV_ALLLEVELS) >= ui32DebugLevel);
+ IMG_BOOL bTrace;
+ const IMG_CHAR *pszFileName = pszFullFileName;
+ IMG_CHAR *pszLeafName;
+
- if (bTrace || bDebug)
+ bTrace = (IMG_BOOL)(ui32DebugLevel & DBGPRIV_CALLTRACE) ? IMG_TRUE : IMG_FALSE;
+
+ if (gPVRDebugLevel & ui32DebugLevel)
{
va_list vaArgs;
unsigned long ulLockFlags = 0;
GetBufferLock(&ulLockFlags);
- if (bDebug)
+ if (bTrace == IMG_FALSE)
{
switch(ui32DebugLevel)
{
else
{
- if (!bTrace)
+ if (bTrace == IMG_FALSE)
{
#ifdef DEBUG_LOG_PATH_TRUNCATE
IMG_CHAR* pszTruncIter;
IMG_CHAR* pszTruncBackInter;
-
+
pszFileName = pszFullFileName + strlen(DEBUG_LOG_PATH_TRUNCATE)+1;
-
+
strncpy(szFileNameRewrite, pszFileName,PVR_MAX_FILEPATH_LEN);
}
pszTruncIter = szFileNameRewrite;
- while(*pszTruncIter++ != 0)
+ while(*pszTruncIter++ != 0)
{
IMG_CHAR* pszNextStartPoint;
if(
- !( ( *pszTruncIter == '/' && (pszTruncIter-4 >= szFileNameRewrite) ) &&
+ !( ( *pszTruncIter == '/' && (pszTruncIter-4 >= szFileNameRewrite) ) &&
( *(pszTruncIter-1) == '.') &&
( *(pszTruncIter-2) == '.') &&
- ( *(pszTruncIter-3) == '/') )
+ ( *(pszTruncIter-3) == '/') )
) continue;
-
+
pszTruncBackInter = pszTruncIter - 3;
- while(*(--pszTruncBackInter) != '/')
+ while(*(--pszTruncBackInter) != '/')
{
if(pszTruncBackInter <= szFileNameRewrite) break;
}
pszNextStartPoint = pszTruncBackInter;
- while(*pszTruncIter != 0)
+ while(*pszTruncIter != 0)
{
*pszTruncBackInter++ = *pszTruncIter++;
}
#if !defined(__sh__)
pszLeafName = (IMG_CHAR *)strrchr (pszFileName, '\\');
-
+
if (pszLeafName)
{
pszFileName = pszLeafName;
- }
+ }
#endif
- if (BAppend(pszBuf, ui32BufSiz, " [%lu, %s]", ui32Line, pszFileName))
+ if (BAppend(pszBuf, ui32BufSiz, " [%u, %s]", ui32Line, pszFileName))
{
printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
}
#endif
-#if defined(DEBUG_PVR)
-
-IMG_VOID PVRDebugSetLevel(IMG_UINT32 uDebugLevel)
-{
- printk(KERN_INFO "PVR: Setting Debug Level = 0x%x\n",(IMG_UINT)uDebugLevel);
-
- gPVRDebugLevel = uDebugLevel;
-}
+#if defined(DEBUG)
IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data)
{
}
else
{
- if (copy_from_user(data_buffer, buffer, count))
+ if (pvr_copy_from_user(data_buffer, buffer, count))
return -EINVAL;
if (data_buffer[count - 1] != '\n')
return -EINVAL;
- PVRDebugSetLevel(data_buffer[0] - '0');
+ gPVRDebugLevel = data_buffer[0] - '0';
}
return (count);
}
-#ifdef PVR_PROC_USE_SEQ_FILE
-void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el)
-{
- seq_printf(sfile, "%lu\n", gPVRDebugLevel);
-}
-
-#else
-IMG_INT PVRDebugProcGetLevel(IMG_CHAR *page, IMG_CHAR **start, off_t off, IMG_INT count, IMG_INT *eof, IMG_VOID *data)
+void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el)
{
- if (off == 0) {
- *start = (IMG_CHAR *)1;
- return printAppend(page, count, 0, "%lu\n", gPVRDebugLevel);
- }
- *eof = 1;
- return 0;
+ seq_printf(sfile, "%u\n", gPVRDebugLevel);
}
-#endif
#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if defined(SUPPORT_DRI_DRM)
+
+#ifndef AUTOCONF_INCLUDED
+ #include <linux/config.h>
+#endif
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <asm/ioctl.h>
+#include <drm/drmP.h>
+#include <drm/drm.h>
+
+#include "img_defs.h"
+#include "services.h"
+#include "kerneldisplay.h"
+#include "kernelbuffer.h"
+#include "syscommon.h"
+#include "pvrmmap.h"
+#include "mm.h"
+#include "mmap.h"
+#include "mutex.h"
+#include "pvr_debug.h"
+#include "srvkm.h"
+#include "perproc.h"
+#include "handle.h"
+#include "pvr_bridge_km.h"
+#include "pvr_bridge.h"
+#include "proc.h"
+#include "pvrmodule.h"
+#include "pvrversion.h"
+#include "lock.h"
+#include "linkage.h"
+#include "pvr_drm.h"
+
+#if defined(PVR_DRI_DRM_NOT_PCI)
+#include "pvr_drm_mod.h"
+#endif
+
+#define PVR_DRM_NAME PVRSRV_MODNAME
+#define PVR_DRM_DESC "Imagination Technologies PVR DRM"
+
+#if !defined(PVR_DRI_DRM_NOT_PCI)
+struct pci_dev *gpsPVRLDMDev;
+#endif
+
+struct drm_device *gpsPVRDRMDev;
+
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24))
+#error "Linux kernel version 2.6.25 or later required for PVR DRM support"
+#endif
+
+#define PVR_DRM_FILE struct drm_file *
+
+#if !defined(SUPPORT_DRI_DRM_EXT)
+static struct pci_device_id asPciIdList[] = {
+#if defined(PVR_DRI_DRM_NOT_PCI)
+ {1, 1, 1, 1, 0, 0, 0},
+#else
+ {SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+#if defined(SYS_SGX_DEV1_DEVICE_ID)
+ {SYS_SGX_DEV_VENDOR_ID, SYS_SGX_DEV1_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+#endif
+#endif
+ {0}
+};
+#endif
+
+DRI_DRM_STATIC int
+PVRSRVDrmLoad(struct drm_device *dev, unsigned long flags)
+{
+ int iRes;
+
+ PVR_TRACE(("PVRSRVDrmLoad"));
+
+ gpsPVRDRMDev = dev;
+#if !defined(PVR_DRI_DRM_NOT_PCI)
+ gpsPVRLDMDev = dev->pdev;
+#endif
+
+#if defined(PDUMP)
+ iRes = dbgdrv_init();
+ if (iRes != 0)
+ {
+ return iRes;
+ }
+#endif
+
+ iRes = PVRCore_Init();
+ if (iRes != 0)
+ {
+ goto exit_dbgdrv_cleanup;
+ }
+
+#if defined(DISPLAY_CONTROLLER)
+ iRes = PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Init)(dev);
+ if (iRes != 0)
+ {
+ goto exit_pvrcore_cleanup;
+ }
+#endif
+ return 0;
+
+#if defined(DISPLAY_CONTROLLER)
+exit_pvrcore_cleanup:
+ PVRCore_Cleanup();
+#endif
+exit_dbgdrv_cleanup:
+#if defined(PDUMP)
+ dbgdrv_cleanup();
+#endif
+ return iRes;
+}
+
+DRI_DRM_STATIC int
+PVRSRVDrmUnload(struct drm_device *dev)
+{
+ PVR_TRACE(("PVRSRVDrmUnload"));
+
+#if defined(DISPLAY_CONTROLLER)
+ PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Cleanup)(dev);
+#endif
+
+ PVRCore_Cleanup();
+
+#if defined(PDUMP)
+ dbgdrv_cleanup();
+#endif
+
+ return 0;
+}
+
+DRI_DRM_STATIC int
+PVRSRVDrmOpen(struct drm_device *dev, struct drm_file *file)
+{
+ return PVRSRVOpen(dev, file);
+}
+
+#if defined(SUPPORT_DRI_DRM_EXT) && !defined(PVR_LINUX_USING_WORKQUEUES)
+DRI_DRM_STATIC void
+PVRSRVDrmPostClose(struct drm_device *dev, struct drm_file *file)
+{
+ PVRSRVRelease(file->driver_priv);
+
+ file->driver_priv = NULL;
+}
+#else
+DRI_DRM_STATIC int
+PVRSRVDrmRelease(struct inode *inode, struct file *filp)
+{
+ struct drm_file *file_priv = filp->private_data;
+ void *psDriverPriv = file_priv->driver_priv;
+ int ret;
+
+ ret = drm_release(inode, filp);
+
+ if (ret != 0)
+ {
+
+ PVR_DPF((PVR_DBG_ERROR, "%s : drm_release failed: %d",
+ __FUNCTION__, ret));
+ }
+
+ PVRSRVRelease(psDriverPriv);
+
+ return 0;
+}
+#endif
+
+DRI_DRM_STATIC int
+PVRDRMIsMaster(struct drm_device *dev, void *arg, struct drm_file *pFile)
+{
+ return 0;
+}
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+int
+PVRDRM_Dummy_ioctl(struct drm_device *dev, void *arg, struct drm_file *pFile)
+{
+ return 0;
+}
+#endif
+
+DRI_DRM_STATIC int
+PVRDRMUnprivCmd(struct drm_device *dev, void *arg, struct drm_file *pFile)
+{
+ int ret = 0;
+
+ LinuxLockMutex(&gPVRSRVLock);
+
+ if (arg == NULL)
+ {
+ ret = -EFAULT;
+ }
+ else
+ {
+ IMG_UINT32 *pui32Args = (IMG_UINT32 *)arg;
+ IMG_UINT32 ui32Cmd = pui32Args[0];
+ IMG_UINT32 *pui32OutArg = (IMG_UINT32 *)arg;
+
+ switch (ui32Cmd)
+ {
+ case PVR_DRM_UNPRIV_INIT_SUCCESFUL:
+ *pui32OutArg = PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL) ? 1 : 0;
+ break;
+
+ default:
+ ret = -EFAULT;
+ }
+
+ }
+
+ LinuxUnLockMutex(&gPVRSRVLock);
+
+ return ret;
+}
+
+#if defined(DISPLAY_CONTROLLER) && defined(PVR_DISPLAY_CONTROLLER_DRM_IOCTL)
+static int
+PVRDRM_Display_ioctl(struct drm_device *dev, void *arg, struct drm_file *pFile)
+{
+ int res;
+
+ LinuxLockMutex(&gPVRSRVLock);
+
+ res = PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Ioctl)(dev, arg, pFile);
+
+ LinuxUnLockMutex(&gPVRSRVLock);
+
+ return res;
+}
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
+#define PVR_DRM_FOPS_IOCTL .unlocked_ioctl
+#define PVR_DRM_UNLOCKED DRM_UNLOCKED
+#else
+#define PVR_DRM_FOPS_IOCTL .ioctl
+#define PVR_DRM_UNLOCKED 0
+#endif
+
+#if !defined(SUPPORT_DRI_DRM_EXT)
+struct drm_ioctl_desc sPVRDrmIoctls[] = {
+ DRM_IOCTL_DEF(PVR_DRM_SRVKM_IOCTL, PVRSRV_BridgeDispatchKM, PVR_DRM_UNLOCKED),
+ DRM_IOCTL_DEF(PVR_DRM_IS_MASTER_IOCTL, PVRDRMIsMaster, DRM_MASTER | PVR_DRM_UNLOCKED),
+ DRM_IOCTL_DEF(PVR_DRM_UNPRIV_IOCTL, PVRDRMUnprivCmd, PVR_DRM_UNLOCKED),
+#if defined(PDUMP)
+ DRM_IOCTL_DEF(PVR_DRM_DBGDRV_IOCTL, dbgdrv_ioctl, PVR_DRM_UNLOCKED),
+#endif
+#if defined(DISPLAY_CONTROLLER) && defined(PVR_DISPLAY_CONTROLLER_DRM_IOCTL)
+ DRM_IOCTL_DEF(PVR_DRM_DISP_IOCTL, PVRDRM_Display_ioctl, DRM_MASTER | PVR_DRM_UNLOCKED)
+#endif
+};
+
+static int pvr_max_ioctl = DRM_ARRAY_SIZE(sPVRDrmIoctls);
+
+static struct drm_driver sPVRDrmDriver =
+{
+ .driver_features = 0,
+ .dev_priv_size = 0,
+ .load = PVRSRVDrmLoad,
+ .unload = PVRSRVDrmUnload,
+ .open = PVRSRVDrmOpen,
+ .suspend = PVRSRVDriverSuspend,
+ .resume = PVRSRVDriverResume,
+ .get_map_ofs = drm_core_get_map_ofs,
+ .get_reg_ofs = drm_core_get_reg_ofs,
+ .ioctls = sPVRDrmIoctls,
+ .fops =
+ {
+ .owner = THIS_MODULE,
+ .open = drm_open,
+ .release = PVRSRVDrmRelease,
+ PVR_DRM_FOPS_IOCTL = drm_ioctl,
+ .mmap = PVRMMap,
+ .poll = drm_poll,
+ .fasync = drm_fasync,
+ },
+ .pci_driver =
+ {
+ .name = PVR_DRM_NAME,
+ .id_table = asPciIdList,
+ },
+
+ .name = PVR_DRM_NAME,
+ .desc = PVR_DRM_DESC,
+ .date = PVR_BUILD_DATE,
+ .major = PVRVERSION_MAJ,
+ .minor = PVRVERSION_MIN,
+ .patchlevel = PVRVERSION_BUILD,
+};
+
+static int __init PVRSRVDrmInit(void)
+{
+ int iRes;
+ sPVRDrmDriver.num_ioctls = pvr_max_ioctl;
+
+
+ PVRDPFInit();
+
+#if defined(PVR_DRI_DRM_NOT_PCI)
+ iRes = drm_pvr_dev_add();
+ if (iRes != 0)
+ {
+ return iRes;
+ }
+#endif
+
+ iRes = drm_init(&sPVRDrmDriver);
+#if defined(PVR_DRI_DRM_NOT_PCI)
+ if (iRes != 0)
+ {
+ drm_pvr_dev_remove();
+ }
+#endif
+ return iRes;
+}
+
+static void __exit PVRSRVDrmExit(void)
+{
+ drm_exit(&sPVRDrmDriver);
+
+#if defined(PVR_DRI_DRM_NOT_PCI)
+ drm_pvr_dev_remove();
+#endif
+}
+
+module_init(PVRSRVDrmInit);
+module_exit(PVRSRVDrmExit);
+#endif
+#endif
+
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__PVR_DRM_H__)
+#define __PVR_DRM_H__
+
+#include "pvr_drm_shared.h"
+
+#if defined(SUPPORT_DRI_DRM)
+#define PVR_DRM_MAKENAME_HELPER(x, y) x ## y
+#define PVR_DRM_MAKENAME(x, y) PVR_DRM_MAKENAME_HELPER(x, y)
+
+int PVRCore_Init(void);
+void PVRCore_Cleanup(void);
+int PVRSRVOpen(struct drm_device *dev, struct drm_file *pFile);
+void PVRSRVRelease(void *pvPrivData);
+int PVRSRVDriverSuspend(struct drm_device *pDevice, pm_message_t state);
+int PVRSRVDriverResume(struct drm_device *pDevice);
+
+int PVRSRV_BridgeDispatchKM(struct drm_device *dev, void *arg, struct drm_file *pFile);
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+#define DRI_DRM_STATIC
+int PVRSRVDrmLoad(struct drm_device *dev, unsigned long flags);
+int PVRSRVDrmUnload(struct drm_device *dev);
+int PVRSRVDrmOpen(struct drm_device *dev, struct drm_file *file);
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+DRI_DRM_STATIC int PVRSRVDrmRelease(struct inode *inode, struct file *filp);
+#else
+void PVRSRVDrmPostClose(struct drm_device *dev, struct drm_file *file);
+#endif
+int PVRDRMIsMaster(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile);
+int PVRDRMUnprivCmd(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile);
+int PVRDRM_Dummy_ioctl(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile);
+#else
+#define DRI_DRM_STATIC static
+#endif
+
+#if defined(DISPLAY_CONTROLLER)
+extern int PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Init)(struct drm_device *);
+extern void PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Cleanup)(struct drm_device *);
+extern int PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Suspend)(struct drm_device *);
+extern int PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Resume)(struct drm_device *);
+#if defined(PVR_DISPLAY_CONTROLLER_DRM_IOCTL)
+extern int PVR_DRM_MAKENAME(DISPLAY_CONTROLLER, _Ioctl)(struct drm_device *dev, void *arg, struct drm_file *pFile);
+#endif
+#endif
+
+#if defined(PDUMP)
+int dbgdrv_init(void);
+void dbgdrv_cleanup(void);
+IMG_INT dbgdrv_ioctl(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile);
+#endif
+
+#if !defined(SUPPORT_DRI_DRM_EXT)
+#define PVR_DRM_SRVKM_IOCTL _IO(0, PVR_DRM_SRVKM_CMD)
+#define PVR_DRM_IS_MASTER_IOCTL _IO(0, PVR_DRM_IS_MASTER_CMD)
+#define PVR_DRM_UNPRIV_IOCTL _IO(0, PVR_DRM_UNPRIV_CMD)
+#define PVR_DRM_DBGDRV_IOCTL _IO(0, PVR_DRM_DBGDRV_CMD)
+#define PVR_DRM_DISP_IOCTL _IO(0, PVR_DRM_DISP_CMD)
+#endif
+
+#endif
+
+#endif
+
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef __PVR_UACCESS_H__
+#define __PVR_UACCESS_H__
+
+#ifndef AUTOCONF_INCLUDED
+ #include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+#include <asm/uaccess.h>
+
+static inline unsigned long pvr_copy_to_user(void __user *pvTo, const void *pvFrom, unsigned long ulBytes)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
+ if (access_ok(VERIFY_WRITE, pvTo, ulBytes))
+ {
+ return __copy_to_user(pvTo, pvFrom, ulBytes);
+ }
+ return ulBytes;
+#else
+ return copy_to_user(pvTo, pvFrom, ulBytes);
+#endif
+}
+
+static inline unsigned long pvr_copy_from_user(void *pvTo, const void __user *pvFrom, unsigned long ulBytes)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
+
+ if (access_ok(VERIFY_READ, pvFrom, ulBytes))
+ {
+ return __copy_from_user(pvTo, pvFrom, ulBytes);
+ }
+ return ulBytes;
+#else
+ return copy_from_user(pvTo, pvFrom, ulBytes);
+#endif
+}
+
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef _OCPDEFS_H_
+#define _OCPDEFS_H_
+
+#define EUR_CR_OCP_REVISION 0xFE00
+#define EUR_CR_OCP_REVISION_REV_MASK 0xFFFFFFFFUL
+#define EUR_CR_OCP_REVISION_REV_SHIFT 0
+#define EUR_CR_OCP_REVISION_REV_SIGNED 0
+
+#define EUR_CR_OCP_HWINFO 0xFE04
+#define EUR_CR_OCP_HWINFO_SYS_BUS_WIDTH_MASK 0x00000003UL
+#define EUR_CR_OCP_HWINFO_SYS_BUS_WIDTH_SHIFT 0
+#define EUR_CR_OCP_HWINFO_SYS_BUS_WIDTH_SIGNED 0
+
+#define EUR_CR_OCP_HWINFO_MEM_BUS_WIDTH_MASK 0x00000004UL
+#define EUR_CR_OCP_HWINFO_MEM_BUS_WIDTH_SHIFT 2
+#define EUR_CR_OCP_HWINFO_MEM_BUS_WIDTH_SIGNED 0
+
+#define EUR_CR_OCP_SYSCONFIG 0xFE10
+#define EUR_CR_OCP_SYSCONFIG_IDLE_MODE_MASK 0x0000000CUL
+#define EUR_CR_OCP_SYSCONFIG_IDLE_MODE_SHIFT 2
+#define EUR_CR_OCP_SYSCONFIG_IDLE_MODE_SIGNED 0
+
+#define EUR_CR_OCP_SYSCONFIG_STANDBY_MODE_MASK 0x00000030UL
+#define EUR_CR_OCP_SYSCONFIG_STANDBY_MODE_SHIFT 4
+#define EUR_CR_OCP_SYSCONFIG_STANDBY_MODE_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_RAW_0 0xFE24
+#define EUR_CR_OCP_IRQSTATUS_RAW_0_INIT_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_RAW_0_INIT_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_RAW_0_INIT_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_RAW_1 0xFE28
+#define EUR_CR_OCP_IRQSTATUS_RAW_1_TARGET_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_RAW_1_TARGET_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_RAW_1_TARGET_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_RAW_2 0xFE2C
+#define EUR_CR_OCP_IRQSTATUS_RAW_2_SGXCORE_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_RAW_2_SGXCORE_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_RAW_2_SGXCORE_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_0 0xFE30
+#define EUR_CR_OCP_IRQSTATUS_0_INIT_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_0_INIT_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_0_INIT_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_1 0xFE34
+#define EUR_CR_OCP_IRQSTATUS_1_TARGET_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_1_TARGET_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_1_TARGET_SIGNED 0
+
+#define EUR_CR_OCP_IRQSTATUS_2 0xFE38
+#define EUR_CR_OCP_IRQSTATUS_2_SGXCORE_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQSTATUS_2_SGXCORE_SHIFT 0
+#define EUR_CR_OCP_IRQSTATUS_2_SGXCORE_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_SET_0 0xFE3C
+#define EUR_CR_OCP_IRQENABLE_SET_0_INIT_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_SET_0_INIT_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_SET_0_INIT_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_SET_1 0xFE40
+#define EUR_CR_OCP_IRQENABLE_SET_1_TARGET_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_SET_1_TARGET_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_SET_1_TARGET_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_SET_2 0xFE44
+#define EUR_CR_OCP_IRQENABLE_SET_2_SGXCORE_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_SET_2_SGXCORE_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_SET_2_SGXCORE_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_CLR_0 0xFE48
+#define EUR_CR_OCP_IRQENABLE_CLR_0_INIT_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_CLR_0_INIT_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_CLR_0_INIT_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_CLR_1 0xFE4C
+#define EUR_CR_OCP_IRQENABLE_CLR_1_TARGET_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_CLR_1_TARGET_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_CLR_1_TARGET_SIGNED 0
+
+#define EUR_CR_OCP_IRQENABLE_CLR_2 0xFE50
+#define EUR_CR_OCP_IRQENABLE_CLR_2_SGXCORE_MASK 0x00000001UL
+#define EUR_CR_OCP_IRQENABLE_CLR_2_SGXCORE_SHIFT 0
+#define EUR_CR_OCP_IRQENABLE_CLR_2_SGXCORE_SIGNED 0
+
+#define EUR_CR_OCP_PAGE_CONFIG 0xFF00
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_SIZE_MASK 0x00000001UL
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_SIZE_SHIFT 0
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_SIZE_SIGNED 0
+
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_CHECK_ENABLE_MASK 0x00000004UL
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_CHECK_ENABLE_SHIFT 2
+#define EUR_CR_OCP_PAGE_CONFIG_MEM_PAGE_CHECK_ENABLE_SIGNED 0
+
+#define EUR_CR_OCP_PAGE_CONFIG_SIZE_MASK 0x00000018UL
+#define EUR_CR_OCP_PAGE_CONFIG_SIZE_SHIFT 3
+#define EUR_CR_OCP_PAGE_CONFIG_SIZE_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT 0xFF04
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNEXPECTED_MASK 0x00000001UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNEXPECTED_SHIFT 0
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNEXPECTED_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNUSED_TAG_MASK 0x00000002UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNUSED_TAG_SHIFT 1
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_UNUSED_TAG_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_ERROR_MASK 0x00000004UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_ERROR_SHIFT 2
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_RESP_ERROR_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_PAGE_CROSS_ERROR_MASK 0x00000008UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_PAGE_CROSS_ERROR_SHIFT 3
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_PAGE_CROSS_ERROR_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_READ_TAG_FIFO_OVR_MASK 0x00000010UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_READ_TAG_FIFO_OVR_SHIFT 4
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_READ_TAG_FIFO_OVR_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_MEM_REQ_FIFO_OVR_MASK 0x00000020UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_MEM_REQ_FIFO_OVR_SHIFT 5
+#define EUR_CR_OCP_INTERRUPT_EVENT_INIT_MEM_REQ_FIFO_OVR_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_RESP_FIFO_FULL_MASK 0x00000100UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_RESP_FIFO_FULL_SHIFT 8
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_RESP_FIFO_FULL_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_CMD_FIFO_FULL_MASK 0x00000200UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_CMD_FIFO_FULL_SHIFT 9
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_CMD_FIFO_FULL_SIGNED 0
+
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_INVALID_OCP_CMD_MASK 0x00000400UL
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_INVALID_OCP_CMD_SHIFT 10
+#define EUR_CR_OCP_INTERRUPT_EVENT_TARGET_INVALID_OCP_CMD_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_CONFIG 0xFF08
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_TARGET_IDLE_MASK 0x00000003UL
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_TARGET_IDLE_SHIFT 0
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_TARGET_IDLE_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_INIT_IDLE_MASK 0x0000000CUL
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_INIT_IDLE_SHIFT 2
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_INIT_IDLE_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_PASS_DATA_MASK 0x00000010UL
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_PASS_DATA_SHIFT 4
+#define EUR_CR_OCP_DEBUG_CONFIG_FORCE_PASS_DATA_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_CONFIG_SELECT_INIT_IDLE_MASK 0x00000020UL
+#define EUR_CR_OCP_DEBUG_CONFIG_SELECT_INIT_IDLE_SHIFT 5
+#define EUR_CR_OCP_DEBUG_CONFIG_SELECT_INIT_IDLE_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_MASK 0x80000000UL
+#define EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_SHIFT 31
+#define EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS 0xFF0C
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_MCONNECT_MASK 0x00000003UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_MCONNECT_SHIFT 0
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_MCONNECT_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SCONNECT_MASK 0x00000004UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SCONNECT_SHIFT 2
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SCONNECT_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEREQ_MASK 0x00000008UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEREQ_SHIFT 3
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEREQ_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SDISCACK_MASK 0x00000030UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SDISCACK_SHIFT 4
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SDISCACK_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEACK_MASK 0x000000C0UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEACK_SHIFT 6
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_SIDLEACK_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MCONNECT0_MASK 0x00000300UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MCONNECT0_SHIFT 8
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MCONNECT0_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT0_MASK 0x00000400UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT0_SHIFT 10
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT0_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT1_MASK 0x00000800UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT1_SHIFT 11
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT1_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT2_MASK 0x00001000UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT2_SHIFT 12
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_SCONNECT2_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCACK_MASK 0x00006000UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCACK_SHIFT 13
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCACK_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCREQ_MASK 0x00008000UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCREQ_SHIFT 15
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MDISCREQ_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MWAIT_MASK 0x00010000UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MWAIT_SHIFT 16
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MWAIT_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MSTANDBY_MASK 0x00020000UL
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MSTANDBY_SHIFT 17
+#define EUR_CR_OCP_DEBUG_STATUS_INIT_MSTANDBY_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_CMD_OUT_MASK 0x001C0000UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_CMD_OUT_SHIFT 18
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_CMD_OUT_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_WHICH_TARGET_REGISTER_MASK 0x03E00000UL
+#define EUR_CR_OCP_DEBUG_STATUS_WHICH_TARGET_REGISTER_SHIFT 21
+#define EUR_CR_OCP_DEBUG_STATUS_WHICH_TARGET_REGISTER_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_ERROR_MASK 0x04000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_ERROR_SHIFT 26
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_ERROR_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_FIFO_FULL_MASK 0x08000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_FIFO_FULL_SHIFT 27
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_FIFO_FULL_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_FIFO_FULL_MASK 0x10000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_FIFO_FULL_SHIFT 28
+#define EUR_CR_OCP_DEBUG_STATUS_RESP_FIFO_FULL_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_IDLE_MASK 0x20000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_IDLE_SHIFT 29
+#define EUR_CR_OCP_DEBUG_STATUS_TARGET_IDLE_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_RESP_DEBUG_STATE_MASK 0x40000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_RESP_DEBUG_STATE_SHIFT 30
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_RESP_DEBUG_STATE_SIGNED 0
+
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_DEBUG_STATE_MASK 0x80000000UL
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_DEBUG_STATE_SHIFT 31
+#define EUR_CR_OCP_DEBUG_STATUS_CMD_DEBUG_STATE_SIGNED 0
+
+
+#endif
+
#define _SGX530DEFS_KM_H_
#define EUR_CR_CLKGATECTL 0x0000
-#define EUR_CR_CLKGATECTL_2D_CLKG_MASK 0x00000003UL
+#define EUR_CR_CLKGATECTL_2D_CLKG_MASK 0x00000003U
#define EUR_CR_CLKGATECTL_2D_CLKG_SHIFT 0
-#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK 0x00000030UL
+#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK 0x00000030U
#define EUR_CR_CLKGATECTL_ISP_CLKG_SHIFT 4
-#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK 0x00000300UL
+#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK 0x00000300U
#define EUR_CR_CLKGATECTL_TSP_CLKG_SHIFT 8
-#define EUR_CR_CLKGATECTL_TA_CLKG_MASK 0x00003000UL
+#define EUR_CR_CLKGATECTL_TA_CLKG_MASK 0x00003000U
#define EUR_CR_CLKGATECTL_TA_CLKG_SHIFT 12
-#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK 0x00030000UL
+#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK 0x00030000U
#define EUR_CR_CLKGATECTL_DPM_CLKG_SHIFT 16
-#define EUR_CR_CLKGATECTL_USE_CLKG_MASK 0x00300000UL
+#define EUR_CR_CLKGATECTL_USE_CLKG_MASK 0x00300000U
#define EUR_CR_CLKGATECTL_USE_CLKG_SHIFT 20
-#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_MASK 0x01000000UL
+#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_MASK 0x01000000U
#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_SHIFT 24
#define EUR_CR_CLKGATESTATUS 0x0004
-#define EUR_CR_CLKGATESTATUS_2D_CLKS_MASK 0x00000001UL
+#define EUR_CR_CLKGATESTATUS_2D_CLKS_MASK 0x00000001U
#define EUR_CR_CLKGATESTATUS_2D_CLKS_SHIFT 0
-#define EUR_CR_CLKGATESTATUS_ISP_CLKS_MASK 0x00000010UL
+#define EUR_CR_CLKGATESTATUS_ISP_CLKS_MASK 0x00000010U
#define EUR_CR_CLKGATESTATUS_ISP_CLKS_SHIFT 4
-#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK 0x00000100UL
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK 0x00000100U
#define EUR_CR_CLKGATESTATUS_TSP_CLKS_SHIFT 8
-#define EUR_CR_CLKGATESTATUS_TA_CLKS_MASK 0x00001000UL
+#define EUR_CR_CLKGATESTATUS_TA_CLKS_MASK 0x00001000U
#define EUR_CR_CLKGATESTATUS_TA_CLKS_SHIFT 12
-#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK 0x00010000UL
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK 0x00010000U
#define EUR_CR_CLKGATESTATUS_DPM_CLKS_SHIFT 16
-#define EUR_CR_CLKGATESTATUS_USE_CLKS_MASK 0x00100000UL
+#define EUR_CR_CLKGATESTATUS_USE_CLKS_MASK 0x00100000U
#define EUR_CR_CLKGATESTATUS_USE_CLKS_SHIFT 20
#define EUR_CR_CLKGATECTLOVR 0x0008
-#define EUR_CR_CLKGATECTLOVR_2D_CLKO_MASK 0x00000003UL
+#define EUR_CR_CLKGATECTLOVR_2D_CLKO_MASK 0x00000003U
#define EUR_CR_CLKGATECTLOVR_2D_CLKO_SHIFT 0
-#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_MASK 0x00000030UL
+#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_MASK 0x00000030U
#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_SHIFT 4
-#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK 0x00000300UL
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK 0x00000300U
#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_SHIFT 8
-#define EUR_CR_CLKGATECTLOVR_TA_CLKO_MASK 0x00003000UL
+#define EUR_CR_CLKGATECTLOVR_TA_CLKO_MASK 0x00003000U
#define EUR_CR_CLKGATECTLOVR_TA_CLKO_SHIFT 12
-#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK 0x00030000UL
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK 0x00030000U
#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_SHIFT 16
-#define EUR_CR_CLKGATECTLOVR_USE_CLKO_MASK 0x00300000UL
+#define EUR_CR_CLKGATECTLOVR_USE_CLKO_MASK 0x00300000U
#define EUR_CR_CLKGATECTLOVR_USE_CLKO_SHIFT 20
#define EUR_CR_CORE_ID 0x0010
-#define EUR_CR_CORE_ID_CONFIG_MASK 0x0000FFFFUL
+#define EUR_CR_CORE_ID_CONFIG_MASK 0x0000FFFFU
#define EUR_CR_CORE_ID_CONFIG_SHIFT 0
-#define EUR_CR_CORE_ID_ID_MASK 0xFFFF0000UL
+#define EUR_CR_CORE_ID_ID_MASK 0xFFFF0000U
#define EUR_CR_CORE_ID_ID_SHIFT 16
#define EUR_CR_CORE_REVISION 0x0014
-#define EUR_CR_CORE_REVISION_MAINTENANCE_MASK 0x000000FFUL
+#define EUR_CR_CORE_REVISION_MAINTENANCE_MASK 0x000000FFU
#define EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT 0
-#define EUR_CR_CORE_REVISION_MINOR_MASK 0x0000FF00UL
+#define EUR_CR_CORE_REVISION_MINOR_MASK 0x0000FF00U
#define EUR_CR_CORE_REVISION_MINOR_SHIFT 8
-#define EUR_CR_CORE_REVISION_MAJOR_MASK 0x00FF0000UL
+#define EUR_CR_CORE_REVISION_MAJOR_MASK 0x00FF0000U
#define EUR_CR_CORE_REVISION_MAJOR_SHIFT 16
-#define EUR_CR_CORE_REVISION_DESIGNER_MASK 0xFF000000UL
+#define EUR_CR_CORE_REVISION_DESIGNER_MASK 0xFF000000U
#define EUR_CR_CORE_REVISION_DESIGNER_SHIFT 24
#define EUR_CR_DESIGNER_REV_FIELD1 0x0018
-#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_MASK 0xFFFFFFFFUL
+#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_MASK 0xFFFFFFFFU
#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_SHIFT 0
#define EUR_CR_DESIGNER_REV_FIELD2 0x001C
-#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_MASK 0xFFFFFFFFUL
+#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_MASK 0xFFFFFFFFU
#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_SHIFT 0
#define EUR_CR_SOFT_RESET 0x0080
-#define EUR_CR_SOFT_RESET_BIF_RESET_MASK 0x00000001UL
+#define EUR_CR_SOFT_RESET_BIF_RESET_MASK 0x00000001U
#define EUR_CR_SOFT_RESET_BIF_RESET_SHIFT 0
-#define EUR_CR_SOFT_RESET_TWOD_RESET_MASK 0x00000002UL
+#define EUR_CR_SOFT_RESET_TWOD_RESET_MASK 0x00000002U
#define EUR_CR_SOFT_RESET_TWOD_RESET_SHIFT 1
-#define EUR_CR_SOFT_RESET_DPM_RESET_MASK 0x00000004UL
+#define EUR_CR_SOFT_RESET_DPM_RESET_MASK 0x00000004U
#define EUR_CR_SOFT_RESET_DPM_RESET_SHIFT 2
-#define EUR_CR_SOFT_RESET_TA_RESET_MASK 0x00000008UL
+#define EUR_CR_SOFT_RESET_TA_RESET_MASK 0x00000008U
#define EUR_CR_SOFT_RESET_TA_RESET_SHIFT 3
-#define EUR_CR_SOFT_RESET_USE_RESET_MASK 0x00000010UL
+#define EUR_CR_SOFT_RESET_USE_RESET_MASK 0x00000010U
#define EUR_CR_SOFT_RESET_USE_RESET_SHIFT 4
-#define EUR_CR_SOFT_RESET_ISP_RESET_MASK 0x00000020UL
+#define EUR_CR_SOFT_RESET_ISP_RESET_MASK 0x00000020U
#define EUR_CR_SOFT_RESET_ISP_RESET_SHIFT 5
-#define EUR_CR_SOFT_RESET_TSP_RESET_MASK 0x00000040UL
+#define EUR_CR_SOFT_RESET_TSP_RESET_MASK 0x00000040U
#define EUR_CR_SOFT_RESET_TSP_RESET_SHIFT 6
#define EUR_CR_EVENT_HOST_ENABLE2 0x0110
-#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_TA_MASK 0x00000010U
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_TA_SHIFT 4
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_3D_MASK 0x00000008U
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_3D_SHIFT 3
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_DL_MASK 0x00000004U
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_DL_SHIFT 2
+#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_SHIFT 0
#define EUR_CR_EVENT_HOST_CLEAR2 0x0114
-#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_TA_MASK 0x00000010U
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_TA_SHIFT 4
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_3D_MASK 0x00000008U
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_3D_SHIFT 3
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_DL_MASK 0x00000004U
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_DL_SHIFT 2
+#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_SHIFT 0
#define EUR_CR_EVENT_STATUS2 0x0118
-#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_STATUS2_TRIG_TA_MASK 0x00000010U
+#define EUR_CR_EVENT_STATUS2_TRIG_TA_SHIFT 4
+#define EUR_CR_EVENT_STATUS2_TRIG_3D_MASK 0x00000008U
+#define EUR_CR_EVENT_STATUS2_TRIG_3D_SHIFT 3
+#define EUR_CR_EVENT_STATUS2_TRIG_DL_MASK 0x00000004U
+#define EUR_CR_EVENT_STATUS2_TRIG_DL_SHIFT 2
+#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_SHIFT 0
-#define EUR_CR_EVENT_STATUS 0x012CUL
-#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_STATUS 0x012CU
+#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_STATUS_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_STATUS_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_STATUS_TIMER_SHIFT 29
-#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_STATUS_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_STATUS_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_STATUS_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_STATUS_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_STATUS_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_STATUS_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_STATUS_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_STATUS_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_STATUS_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_STATUS_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_STATUS_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_STATUS_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_STATUS_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_STATUS_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_STATUS_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_STATUS_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_STATUS_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_STATUS_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_STATUS_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_STATUS_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_STATUS_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_STATUS_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_STATUS_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_STATUS_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_STATUS_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_STATUS_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_STATUS_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_STATUS_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_STATUS_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_STATUS_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_STATUS_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_STATUS_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_STATUS_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_SHIFT 0
#define EUR_CR_EVENT_HOST_ENABLE 0x0130
-#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_HOST_ENABLE_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_HOST_ENABLE_TIMER_SHIFT 29
-#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_SHIFT 0
#define EUR_CR_EVENT_HOST_CLEAR 0x0134
-#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_HOST_CLEAR_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_HOST_CLEAR_TIMER_SHIFT 29
-#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_SHIFT 0
-#define EUR_CR_PDS 0x0ABC
-#define EUR_CR_PDS_DOUT_TIMEOUT_DISABLE_MASK 0x00000040UL
-#define EUR_CR_PDS_DOUT_TIMEOUT_DISABLE_SHIFT 6
#define EUR_CR_PDS_EXEC_BASE 0x0AB8
-#define EUR_CR_PDS_EXEC_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_PDS_EXEC_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_PDS_EXEC_BASE_ADDR_SHIFT 20
#define EUR_CR_EVENT_KICKER 0x0AC4
-#define EUR_CR_EVENT_KICKER_ADDRESS_MASK 0x0FFFFFF0UL
+#define EUR_CR_EVENT_KICKER_ADDRESS_MASK 0x0FFFFFF0U
#define EUR_CR_EVENT_KICKER_ADDRESS_SHIFT 4
#define EUR_CR_EVENT_KICK 0x0AC8
-#define EUR_CR_EVENT_KICK_NOW_MASK 0x00000001UL
+#define EUR_CR_EVENT_KICK_NOW_MASK 0x00000001U
#define EUR_CR_EVENT_KICK_NOW_SHIFT 0
#define EUR_CR_EVENT_TIMER 0x0ACC
-#define EUR_CR_EVENT_TIMER_ENABLE_MASK 0x01000000UL
+#define EUR_CR_EVENT_TIMER_ENABLE_MASK 0x01000000U
#define EUR_CR_EVENT_TIMER_ENABLE_SHIFT 24
-#define EUR_CR_EVENT_TIMER_VALUE_MASK 0x00FFFFFFUL
+#define EUR_CR_EVENT_TIMER_VALUE_MASK 0x00FFFFFFU
#define EUR_CR_EVENT_TIMER_VALUE_SHIFT 0
#define EUR_CR_PDS_INV0 0x0AD0
-#define EUR_CR_PDS_INV0_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV0_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV0_DSC_SHIFT 0
#define EUR_CR_PDS_INV1 0x0AD4
-#define EUR_CR_PDS_INV1_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV1_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV1_DSC_SHIFT 0
#define EUR_CR_PDS_INV2 0x0AD8
-#define EUR_CR_PDS_INV2_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV2_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV2_DSC_SHIFT 0
#define EUR_CR_PDS_INV3 0x0ADC
-#define EUR_CR_PDS_INV3_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV3_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV3_DSC_SHIFT 0
#define EUR_CR_PDS_INV_CSC 0x0AE0
-#define EUR_CR_PDS_INV_CSC_KICK_MASK 0x00000001UL
+#define EUR_CR_PDS_INV_CSC_KICK_MASK 0x00000001U
#define EUR_CR_PDS_INV_CSC_KICK_SHIFT 0
#define EUR_CR_PDS_PC_BASE 0x0B2C
-#define EUR_CR_PDS_PC_BASE_ADDRESS_MASK 0x3FFFFFFFUL
+#define EUR_CR_PDS_PC_BASE_ADDRESS_MASK 0x3FFFFFFFU
#define EUR_CR_PDS_PC_BASE_ADDRESS_SHIFT 0
#define EUR_CR_BIF_CTRL 0x0C00
-#define EUR_CR_BIF_CTRL_NOREORDER_MASK 0x00000001UL
+#define EUR_CR_BIF_CTRL_NOREORDER_MASK 0x00000001U
#define EUR_CR_BIF_CTRL_NOREORDER_SHIFT 0
-#define EUR_CR_BIF_CTRL_PAUSE_MASK 0x00000002UL
+#define EUR_CR_BIF_CTRL_PAUSE_MASK 0x00000002U
#define EUR_CR_BIF_CTRL_PAUSE_SHIFT 1
-#define EUR_CR_BIF_CTRL_FLUSH_MASK 0x00000004UL
+#define EUR_CR_BIF_CTRL_FLUSH_MASK 0x00000004U
#define EUR_CR_BIF_CTRL_FLUSH_SHIFT 2
-#define EUR_CR_BIF_CTRL_INVALDC_MASK 0x00000008UL
+#define EUR_CR_BIF_CTRL_INVALDC_MASK 0x00000008U
#define EUR_CR_BIF_CTRL_INVALDC_SHIFT 3
-#define EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK 0x00000010UL
+#define EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK 0x00000010U
#define EUR_CR_BIF_CTRL_CLEAR_FAULT_SHIFT 4
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_MASK 0x00000100UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_MASK 0x00000100U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_SHIFT 8
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_MASK 0x00000200UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_MASK 0x00000200U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_SHIFT 9
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_MASK 0x00000400UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_MASK 0x00000400U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_SHIFT 10
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_TWOD_MASK 0x00000800UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TWOD_MASK 0x00000800U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_TWOD_SHIFT 11
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_MASK 0x00001000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_MASK 0x00001000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_SHIFT 12
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_MASK 0x00002000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_MASK 0x00002000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_SHIFT 13
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_MASK 0x00004000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_MASK 0x00004000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_SHIFT 14
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_MASK 0x00008000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_MASK 0x00008000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_SHIFT 15
#define EUR_CR_BIF_INT_STAT 0x0C04
-#define EUR_CR_BIF_INT_STAT_FAULT_MASK 0x00003FFFUL
+#define EUR_CR_BIF_INT_STAT_FAULT_MASK 0x00003FFFU
#define EUR_CR_BIF_INT_STAT_FAULT_SHIFT 0
-#define EUR_CR_BIF_INT_STAT_PF_N_RW_MASK 0x00004000UL
+#define EUR_CR_BIF_INT_STAT_PF_N_RW_MASK 0x00004000U
#define EUR_CR_BIF_INT_STAT_PF_N_RW_SHIFT 14
+#define EUR_CR_BIF_INT_STAT_FLUSH_COMPLETE_MASK 0x00008000U
+#define EUR_CR_BIF_INT_STAT_FLUSH_COMPLETE_SHIFT 15
#define EUR_CR_BIF_FAULT 0x0C08
-#define EUR_CR_BIF_FAULT_ADDR_MASK 0x0FFFF000UL
+#define EUR_CR_BIF_FAULT_ADDR_MASK 0x0FFFF000U
#define EUR_CR_BIF_FAULT_ADDR_SHIFT 12
#define EUR_CR_BIF_DIR_LIST_BASE0 0x0C84
-#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_MASK 0xFFFFF000UL
+#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_MASK 0xFFFFF000U
#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_SHIFT 12
#define EUR_CR_BIF_TWOD_REQ_BASE 0x0C88
-#define EUR_CR_BIF_TWOD_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_TWOD_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_TWOD_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_BIF_TA_REQ_BASE 0x0C90
-#define EUR_CR_BIF_TA_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_TA_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_TA_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_BIF_MEM_REQ_STAT 0x0CA8
-#define EUR_CR_BIF_MEM_REQ_STAT_READS_MASK 0x000000FFUL
+#define EUR_CR_BIF_MEM_REQ_STAT_READS_MASK 0x000000FFU
#define EUR_CR_BIF_MEM_REQ_STAT_READS_SHIFT 0
#define EUR_CR_BIF_3D_REQ_BASE 0x0CAC
-#define EUR_CR_BIF_3D_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_3D_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_3D_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_BIF_ZLS_REQ_BASE 0x0CB0
-#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_2D_BLIT_STATUS 0x0E04
-#define EUR_CR_2D_BLIT_STATUS_COMPLETE_MASK 0x00FFFFFFUL
+#define EUR_CR_2D_BLIT_STATUS_COMPLETE_MASK 0x00FFFFFFU
#define EUR_CR_2D_BLIT_STATUS_COMPLETE_SHIFT 0
-#define EUR_CR_2D_BLIT_STATUS_BUSY_MASK 0x01000000UL
+#define EUR_CR_2D_BLIT_STATUS_BUSY_MASK 0x01000000U
#define EUR_CR_2D_BLIT_STATUS_BUSY_SHIFT 24
#define EUR_CR_2D_VIRTUAL_FIFO_0 0x0E10
-#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_MASK 0x00000001UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_MASK 0x00000001U
#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_SHIFT 0
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MASK 0x0000000EUL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MASK 0x0000000EU
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_SHIFT 1
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_MASK 0x00000FF0UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_MASK 0x00000FF0U
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_SHIFT 4
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_MASK 0x0000F000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_MASK 0x0000F000U
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_SHIFT 12
#define EUR_CR_2D_VIRTUAL_FIFO_1 0x0E14
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_MASK 0x00000FFFUL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_MASK 0x00000FFFU
#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_SHIFT 0
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_MASK 0x00FFF000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_MASK 0x00FFF000U
#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_SHIFT 12
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_MASK 0xFF000000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_MASK 0xFF000000U
#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_SHIFT 24
#define EUR_CR_USE_CODE_BASE(X) (0x0A0C + (4 * (X)))
-#define EUR_CR_USE_CODE_BASE_ADDR_MASK 0x00FFFFFFUL
+#define EUR_CR_USE_CODE_BASE_ADDR_MASK 0x00FFFFFFU
#define EUR_CR_USE_CODE_BASE_ADDR_SHIFT 0
-#define EUR_CR_USE_CODE_BASE_DM_MASK 0x03000000UL
+#define EUR_CR_USE_CODE_BASE_DM_MASK 0x03000000U
#define EUR_CR_USE_CODE_BASE_DM_SHIFT 24
#define EUR_CR_USE_CODE_BASE_SIZE_UINT32 16
#define EUR_CR_USE_CODE_BASE_NUM_ENTRIES 16
+#define EUR_CR_MNE_CR_CTRL 0x0D00
+#define EUR_CR_MNE_CR_CTRL_BYP_CC_N_MASK 0x00010000U
+#define EUR_CR_MNE_CR_CTRL_BYP_CC_N_SHIFT 16
+#define EUR_CR_MNE_CR_CTRL_BYP_CC_MASK 0x00008000U
+#define EUR_CR_MNE_CR_CTRL_BYP_CC_SHIFT 15
+#define EUR_CR_MNE_CR_CTRL_USE_INVAL_ADDR_MASK 0x00007800U
+#define EUR_CR_MNE_CR_CTRL_USE_INVAL_ADDR_SHIFT 11
+#define EUR_CR_MNE_CR_CTRL_BYPASS_ALL_MASK 0x00000400U
+#define EUR_CR_MNE_CR_CTRL_BYPASS_ALL_SHIFT 10
+#define EUR_CR_MNE_CR_CTRL_BYPASS_MASK 0x000003E0U
+#define EUR_CR_MNE_CR_CTRL_BYPASS_SHIFT 5
+#define EUR_CR_MNE_CR_CTRL_PAUSE_MASK 0x00000010U
+#define EUR_CR_MNE_CR_CTRL_PAUSE_SHIFT 4
+#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_MASK 0x0000000EU
+#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT 1
+#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_PDS_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT+2)
+#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_USEC_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT+1)
+#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_CACHE_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT)
+#define EUR_CR_MNE_CR_CTRL_INVAL_ALL_MASK 0x00000001U
+#define EUR_CR_MNE_CR_CTRL_INVAL_ALL_SHIFT 0
+#define EUR_CR_MNE_CR_USE_INVAL 0x0D04
+#define EUR_CR_MNE_CR_USE_INVAL_ADDR_MASK 0xFFFFFFFFU
+#define EUR_CR_MNE_CR_USE_INVAL_ADDR_SHIFT 0
+#define EUR_CR_MNE_CR_STAT 0x0D08
+#define EUR_CR_MNE_CR_STAT_PAUSED_MASK 0x00000400U
+#define EUR_CR_MNE_CR_STAT_PAUSED_SHIFT 10
+#define EUR_CR_MNE_CR_STAT_READS_MASK 0x000003FFU
+#define EUR_CR_MNE_CR_STAT_READS_SHIFT 0
+#define EUR_CR_MNE_CR_STAT_STATS 0x0D0C
+#define EUR_CR_MNE_CR_STAT_STATS_RST_MASK 0x000FFFF0U
+#define EUR_CR_MNE_CR_STAT_STATS_RST_SHIFT 4
+#define EUR_CR_MNE_CR_STAT_STATS_SEL_MASK 0x0000000FU
+#define EUR_CR_MNE_CR_STAT_STATS_SEL_SHIFT 0
+#define EUR_CR_MNE_CR_STAT_STATS_OUT 0x0D10
+#define EUR_CR_MNE_CR_STAT_STATS_OUT_VALUE_MASK 0xFFFFFFFFU
+#define EUR_CR_MNE_CR_STAT_STATS_OUT_VALUE_SHIFT 0
+#define EUR_CR_MNE_CR_EVENT_STATUS 0x0D14
+#define EUR_CR_MNE_CR_EVENT_STATUS_INVAL_MASK 0x00000001U
+#define EUR_CR_MNE_CR_EVENT_STATUS_INVAL_SHIFT 0
+#define EUR_CR_MNE_CR_EVENT_CLEAR 0x0D18
+#define EUR_CR_MNE_CR_EVENT_CLEAR_INVAL_MASK 0x00000001U
+#define EUR_CR_MNE_CR_EVENT_CLEAR_INVAL_SHIFT 0
+#define EUR_CR_MNE_CR_CTRL_INVAL 0x0D20
#endif
#define _SGX540DEFS_KM_H_
#define EUR_CR_CLKGATECTL 0x0000
-#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK 0x00000003UL
+#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK 0x00000003U
#define EUR_CR_CLKGATECTL_ISP_CLKG_SHIFT 0
-#define EUR_CR_CLKGATECTL_ISP2_CLKG_MASK 0x0000000CUL
+#define EUR_CR_CLKGATECTL_ISP2_CLKG_MASK 0x0000000CU
#define EUR_CR_CLKGATECTL_ISP2_CLKG_SHIFT 2
-#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK 0x00000030UL
+#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK 0x00000030U
#define EUR_CR_CLKGATECTL_TSP_CLKG_SHIFT 4
-#define EUR_CR_CLKGATECTL_TE_CLKG_MASK 0x000000C0UL
+#define EUR_CR_CLKGATECTL_TE_CLKG_MASK 0x000000C0U
#define EUR_CR_CLKGATECTL_TE_CLKG_SHIFT 6
-#define EUR_CR_CLKGATECTL_MTE_CLKG_MASK 0x00000300UL
+#define EUR_CR_CLKGATECTL_MTE_CLKG_MASK 0x00000300U
#define EUR_CR_CLKGATECTL_MTE_CLKG_SHIFT 8
-#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK 0x00000C00UL
+#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK 0x00000C00U
#define EUR_CR_CLKGATECTL_DPM_CLKG_SHIFT 10
-#define EUR_CR_CLKGATECTL_VDM_CLKG_MASK 0x00003000UL
+#define EUR_CR_CLKGATECTL_VDM_CLKG_MASK 0x00003000U
#define EUR_CR_CLKGATECTL_VDM_CLKG_SHIFT 12
-#define EUR_CR_CLKGATECTL_PDS_CLKG_MASK 0x0000C000UL
+#define EUR_CR_CLKGATECTL_PDS_CLKG_MASK 0x0000C000U
#define EUR_CR_CLKGATECTL_PDS_CLKG_SHIFT 14
-#define EUR_CR_CLKGATECTL_IDXFIFO_CLKG_MASK 0x00030000UL
+#define EUR_CR_CLKGATECTL_IDXFIFO_CLKG_MASK 0x00030000U
#define EUR_CR_CLKGATECTL_IDXFIFO_CLKG_SHIFT 16
-#define EUR_CR_CLKGATECTL_TA_CLKG_MASK 0x000C0000UL
+#define EUR_CR_CLKGATECTL_TA_CLKG_MASK 0x000C0000U
#define EUR_CR_CLKGATECTL_TA_CLKG_SHIFT 18
-#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_MASK 0x01000000UL
+#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_MASK 0x01000000U
#define EUR_CR_CLKGATECTL_AUTO_MAN_REG_SHIFT 24
-#define EUR_CR_CLKGATECTL_SYSTEM_CLKG_MASK 0x10000000UL
+#define EUR_CR_CLKGATECTL_SYSTEM_CLKG_MASK 0x10000000U
#define EUR_CR_CLKGATECTL_SYSTEM_CLKG_SHIFT 28
#define EUR_CR_CLKGATECTL2 0x0004
-#define EUR_CR_CLKGATECTL2_PBE_CLKG_MASK 0x00000003UL
+#define EUR_CR_CLKGATECTL2_PBE_CLKG_MASK 0x00000003U
#define EUR_CR_CLKGATECTL2_PBE_CLKG_SHIFT 0
-#define EUR_CR_CLKGATECTL2_CACHEL2_CLKG_MASK 0x0000000CUL
+#define EUR_CR_CLKGATECTL2_CACHEL2_CLKG_MASK 0x0000000CU
#define EUR_CR_CLKGATECTL2_CACHEL2_CLKG_SHIFT 2
-#define EUR_CR_CLKGATECTL2_UCACHEL2_CLKG_MASK 0x00000030UL
+#define EUR_CR_CLKGATECTL2_UCACHEL2_CLKG_MASK 0x00000030U
#define EUR_CR_CLKGATECTL2_UCACHEL2_CLKG_SHIFT 4
-#define EUR_CR_CLKGATECTL2_USE0_CLKG_MASK 0x000000C0UL
+#define EUR_CR_CLKGATECTL2_USE0_CLKG_MASK 0x000000C0U
#define EUR_CR_CLKGATECTL2_USE0_CLKG_SHIFT 6
-#define EUR_CR_CLKGATECTL2_ITR0_CLKG_MASK 0x00000300UL
+#define EUR_CR_CLKGATECTL2_ITR0_CLKG_MASK 0x00000300U
#define EUR_CR_CLKGATECTL2_ITR0_CLKG_SHIFT 8
-#define EUR_CR_CLKGATECTL2_TEX0_CLKG_MASK 0x00000C00UL
+#define EUR_CR_CLKGATECTL2_TEX0_CLKG_MASK 0x00000C00U
#define EUR_CR_CLKGATECTL2_TEX0_CLKG_SHIFT 10
-#define EUR_CR_CLKGATECTL2_MADD0_CLKG_MASK 0x00003000UL
+#define EUR_CR_CLKGATECTL2_MADD0_CLKG_MASK 0x00003000U
#define EUR_CR_CLKGATECTL2_MADD0_CLKG_SHIFT 12
-#define EUR_CR_CLKGATECTL2_USE1_CLKG_MASK 0x0000C000UL
+#define EUR_CR_CLKGATECTL2_USE1_CLKG_MASK 0x0000C000U
#define EUR_CR_CLKGATECTL2_USE1_CLKG_SHIFT 14
-#define EUR_CR_CLKGATECTL2_ITR1_CLKG_MASK 0x00030000UL
+#define EUR_CR_CLKGATECTL2_ITR1_CLKG_MASK 0x00030000U
#define EUR_CR_CLKGATECTL2_ITR1_CLKG_SHIFT 16
-#define EUR_CR_CLKGATECTL2_TEX1_CLKG_MASK 0x000C0000UL
+#define EUR_CR_CLKGATECTL2_TEX1_CLKG_MASK 0x000C0000U
#define EUR_CR_CLKGATECTL2_TEX1_CLKG_SHIFT 18
-#define EUR_CR_CLKGATECTL2_MADD1_CLKG_MASK 0x00300000UL
+#define EUR_CR_CLKGATECTL2_MADD1_CLKG_MASK 0x00300000U
#define EUR_CR_CLKGATECTL2_MADD1_CLKG_SHIFT 20
#define EUR_CR_CLKGATESTATUS 0x0008
-#define EUR_CR_CLKGATESTATUS_ISP_CLKS_MASK 0x00000001UL
+#define EUR_CR_CLKGATESTATUS_ISP_CLKS_MASK 0x00000001U
#define EUR_CR_CLKGATESTATUS_ISP_CLKS_SHIFT 0
-#define EUR_CR_CLKGATESTATUS_ISP2_CLKS_MASK 0x00000002UL
+#define EUR_CR_CLKGATESTATUS_ISP2_CLKS_MASK 0x00000002U
#define EUR_CR_CLKGATESTATUS_ISP2_CLKS_SHIFT 1
-#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK 0x00000004UL
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK 0x00000004U
#define EUR_CR_CLKGATESTATUS_TSP_CLKS_SHIFT 2
-#define EUR_CR_CLKGATESTATUS_TE_CLKS_MASK 0x00000008UL
+#define EUR_CR_CLKGATESTATUS_TE_CLKS_MASK 0x00000008U
#define EUR_CR_CLKGATESTATUS_TE_CLKS_SHIFT 3
-#define EUR_CR_CLKGATESTATUS_MTE_CLKS_MASK 0x00000010UL
+#define EUR_CR_CLKGATESTATUS_MTE_CLKS_MASK 0x00000010U
#define EUR_CR_CLKGATESTATUS_MTE_CLKS_SHIFT 4
-#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK 0x00000020UL
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK 0x00000020U
#define EUR_CR_CLKGATESTATUS_DPM_CLKS_SHIFT 5
-#define EUR_CR_CLKGATESTATUS_VDM_CLKS_MASK 0x00000040UL
+#define EUR_CR_CLKGATESTATUS_VDM_CLKS_MASK 0x00000040U
#define EUR_CR_CLKGATESTATUS_VDM_CLKS_SHIFT 6
-#define EUR_CR_CLKGATESTATUS_PDS_CLKS_MASK 0x00000080UL
+#define EUR_CR_CLKGATESTATUS_PDS_CLKS_MASK 0x00000080U
#define EUR_CR_CLKGATESTATUS_PDS_CLKS_SHIFT 7
-#define EUR_CR_CLKGATESTATUS_PBE_CLKS_MASK 0x00000100UL
+#define EUR_CR_CLKGATESTATUS_PBE_CLKS_MASK 0x00000100U
#define EUR_CR_CLKGATESTATUS_PBE_CLKS_SHIFT 8
-#define EUR_CR_CLKGATESTATUS_CACHEL2_CLKS_MASK 0x00000200UL
+#define EUR_CR_CLKGATESTATUS_CACHEL2_CLKS_MASK 0x00000200U
#define EUR_CR_CLKGATESTATUS_CACHEL2_CLKS_SHIFT 9
-#define EUR_CR_CLKGATESTATUS_UCACHEL2_CLKS_MASK 0x00000400UL
+#define EUR_CR_CLKGATESTATUS_UCACHEL2_CLKS_MASK 0x00000400U
#define EUR_CR_CLKGATESTATUS_UCACHEL2_CLKS_SHIFT 10
-#define EUR_CR_CLKGATESTATUS_USE0_CLKS_MASK 0x00000800UL
+#define EUR_CR_CLKGATESTATUS_USE0_CLKS_MASK 0x00000800U
#define EUR_CR_CLKGATESTATUS_USE0_CLKS_SHIFT 11
-#define EUR_CR_CLKGATESTATUS_ITR0_CLKS_MASK 0x00001000UL
+#define EUR_CR_CLKGATESTATUS_ITR0_CLKS_MASK 0x00001000U
#define EUR_CR_CLKGATESTATUS_ITR0_CLKS_SHIFT 12
-#define EUR_CR_CLKGATESTATUS_TEX0_CLKS_MASK 0x00002000UL
+#define EUR_CR_CLKGATESTATUS_TEX0_CLKS_MASK 0x00002000U
#define EUR_CR_CLKGATESTATUS_TEX0_CLKS_SHIFT 13
-#define EUR_CR_CLKGATESTATUS_MADD0_CLKS_MASK 0x00004000UL
+#define EUR_CR_CLKGATESTATUS_MADD0_CLKS_MASK 0x00004000U
#define EUR_CR_CLKGATESTATUS_MADD0_CLKS_SHIFT 14
-#define EUR_CR_CLKGATESTATUS_USE1_CLKS_MASK 0x00008000UL
+#define EUR_CR_CLKGATESTATUS_USE1_CLKS_MASK 0x00008000U
#define EUR_CR_CLKGATESTATUS_USE1_CLKS_SHIFT 15
-#define EUR_CR_CLKGATESTATUS_ITR1_CLKS_MASK 0x00010000UL
+#define EUR_CR_CLKGATESTATUS_ITR1_CLKS_MASK 0x00010000U
#define EUR_CR_CLKGATESTATUS_ITR1_CLKS_SHIFT 16
-#define EUR_CR_CLKGATESTATUS_TEX1_CLKS_MASK 0x00020000UL
+#define EUR_CR_CLKGATESTATUS_TEX1_CLKS_MASK 0x00020000U
#define EUR_CR_CLKGATESTATUS_TEX1_CLKS_SHIFT 17
-#define EUR_CR_CLKGATESTATUS_MADD1_CLKS_MASK 0x00040000UL
+#define EUR_CR_CLKGATESTATUS_MADD1_CLKS_MASK 0x00040000U
#define EUR_CR_CLKGATESTATUS_MADD1_CLKS_SHIFT 18
-#define EUR_CR_CLKGATESTATUS_IDXFIFO_CLKS_MASK 0x00080000UL
+#define EUR_CR_CLKGATESTATUS_IDXFIFO_CLKS_MASK 0x00080000U
#define EUR_CR_CLKGATESTATUS_IDXFIFO_CLKS_SHIFT 19
-#define EUR_CR_CLKGATESTATUS_TA_CLKS_MASK 0x00100000UL
+#define EUR_CR_CLKGATESTATUS_TA_CLKS_MASK 0x00100000U
#define EUR_CR_CLKGATESTATUS_TA_CLKS_SHIFT 20
#define EUR_CR_CLKGATECTLOVR 0x000C
-#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_MASK 0x00000003UL
+#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_MASK 0x00000003U
#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_SHIFT 0
-#define EUR_CR_CLKGATECTLOVR_ISP2_CLKO_MASK 0x0000000CUL
+#define EUR_CR_CLKGATECTLOVR_ISP2_CLKO_MASK 0x0000000CU
#define EUR_CR_CLKGATECTLOVR_ISP2_CLKO_SHIFT 2
-#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK 0x00000030UL
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK 0x00000030U
#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_SHIFT 4
-#define EUR_CR_CLKGATECTLOVR_TE_CLKO_MASK 0x000000C0UL
+#define EUR_CR_CLKGATECTLOVR_TE_CLKO_MASK 0x000000C0U
#define EUR_CR_CLKGATECTLOVR_TE_CLKO_SHIFT 6
-#define EUR_CR_CLKGATECTLOVR_MTE_CLKO_MASK 0x00000300UL
+#define EUR_CR_CLKGATECTLOVR_MTE_CLKO_MASK 0x00000300U
#define EUR_CR_CLKGATECTLOVR_MTE_CLKO_SHIFT 8
-#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK 0x00000C00UL
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK 0x00000C00U
#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_SHIFT 10
-#define EUR_CR_CLKGATECTLOVR_VDM_CLKO_MASK 0x00003000UL
+#define EUR_CR_CLKGATECTLOVR_VDM_CLKO_MASK 0x00003000U
#define EUR_CR_CLKGATECTLOVR_VDM_CLKO_SHIFT 12
-#define EUR_CR_CLKGATECTLOVR_PDS_CLKO_MASK 0x0000C000UL
+#define EUR_CR_CLKGATECTLOVR_PDS_CLKO_MASK 0x0000C000U
#define EUR_CR_CLKGATECTLOVR_PDS_CLKO_SHIFT 14
-#define EUR_CR_CLKGATECTLOVR_IDXFIFO_CLKO_MASK 0x00030000UL
+#define EUR_CR_CLKGATECTLOVR_IDXFIFO_CLKO_MASK 0x00030000U
#define EUR_CR_CLKGATECTLOVR_IDXFIFO_CLKO_SHIFT 16
-#define EUR_CR_CLKGATECTLOVR_TA_CLKO_MASK 0x000C0000UL
+#define EUR_CR_CLKGATECTLOVR_TA_CLKO_MASK 0x000C0000U
#define EUR_CR_CLKGATECTLOVR_TA_CLKO_SHIFT 18
#define EUR_CR_POWER 0x001C
-#define EUR_CR_POWER_PIPE_DISABLE_MASK 0x00000001UL
+#define EUR_CR_POWER_PIPE_DISABLE_MASK 0x00000001U
#define EUR_CR_POWER_PIPE_DISABLE_SHIFT 0
#define EUR_CR_CORE_ID 0x0020
-#define EUR_CR_CORE_ID_CONFIG_MASK 0x0000FFFFUL
+#define EUR_CR_CORE_ID_CONFIG_MASK 0x0000FFFFU
#define EUR_CR_CORE_ID_CONFIG_SHIFT 0
-#define EUR_CR_CORE_ID_ID_MASK 0xFFFF0000UL
+#define EUR_CR_CORE_ID_ID_MASK 0xFFFF0000U
#define EUR_CR_CORE_ID_ID_SHIFT 16
#define EUR_CR_CORE_REVISION 0x0024
-#define EUR_CR_CORE_REVISION_MAINTENANCE_MASK 0x000000FFUL
+#define EUR_CR_CORE_REVISION_MAINTENANCE_MASK 0x000000FFU
#define EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT 0
-#define EUR_CR_CORE_REVISION_MINOR_MASK 0x0000FF00UL
+#define EUR_CR_CORE_REVISION_MINOR_MASK 0x0000FF00U
#define EUR_CR_CORE_REVISION_MINOR_SHIFT 8
-#define EUR_CR_CORE_REVISION_MAJOR_MASK 0x00FF0000UL
+#define EUR_CR_CORE_REVISION_MAJOR_MASK 0x00FF0000U
#define EUR_CR_CORE_REVISION_MAJOR_SHIFT 16
-#define EUR_CR_CORE_REVISION_DESIGNER_MASK 0xFF000000UL
+#define EUR_CR_CORE_REVISION_DESIGNER_MASK 0xFF000000U
#define EUR_CR_CORE_REVISION_DESIGNER_SHIFT 24
#define EUR_CR_DESIGNER_REV_FIELD1 0x0028
-#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_MASK 0xFFFFFFFFUL
+#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_MASK 0xFFFFFFFFU
#define EUR_CR_DESIGNER_REV_FIELD1_DESIGNER_REV_FIELD1_SHIFT 0
#define EUR_CR_DESIGNER_REV_FIELD2 0x002C
-#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_MASK 0xFFFFFFFFUL
+#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_MASK 0xFFFFFFFFU
#define EUR_CR_DESIGNER_REV_FIELD2_DESIGNER_REV_FIELD2_SHIFT 0
#define EUR_CR_SOFT_RESET 0x0080
-#define EUR_CR_SOFT_RESET_BIF_RESET_MASK 0x00000001UL
+#define EUR_CR_SOFT_RESET_BIF_RESET_MASK 0x00000001U
#define EUR_CR_SOFT_RESET_BIF_RESET_SHIFT 0
-#define EUR_CR_SOFT_RESET_VDM_RESET_MASK 0x00000002UL
+#define EUR_CR_SOFT_RESET_VDM_RESET_MASK 0x00000002U
#define EUR_CR_SOFT_RESET_VDM_RESET_SHIFT 1
-#define EUR_CR_SOFT_RESET_DPM_RESET_MASK 0x00000004UL
+#define EUR_CR_SOFT_RESET_DPM_RESET_MASK 0x00000004U
#define EUR_CR_SOFT_RESET_DPM_RESET_SHIFT 2
-#define EUR_CR_SOFT_RESET_TE_RESET_MASK 0x00000008UL
+#define EUR_CR_SOFT_RESET_TE_RESET_MASK 0x00000008U
#define EUR_CR_SOFT_RESET_TE_RESET_SHIFT 3
-#define EUR_CR_SOFT_RESET_MTE_RESET_MASK 0x00000010UL
+#define EUR_CR_SOFT_RESET_MTE_RESET_MASK 0x00000010U
#define EUR_CR_SOFT_RESET_MTE_RESET_SHIFT 4
-#define EUR_CR_SOFT_RESET_ISP_RESET_MASK 0x00000020UL
+#define EUR_CR_SOFT_RESET_ISP_RESET_MASK 0x00000020U
#define EUR_CR_SOFT_RESET_ISP_RESET_SHIFT 5
-#define EUR_CR_SOFT_RESET_ISP2_RESET_MASK 0x00000040UL
+#define EUR_CR_SOFT_RESET_ISP2_RESET_MASK 0x00000040U
#define EUR_CR_SOFT_RESET_ISP2_RESET_SHIFT 6
-#define EUR_CR_SOFT_RESET_TSP_RESET_MASK 0x00000080UL
+#define EUR_CR_SOFT_RESET_TSP_RESET_MASK 0x00000080U
#define EUR_CR_SOFT_RESET_TSP_RESET_SHIFT 7
-#define EUR_CR_SOFT_RESET_PDS_RESET_MASK 0x00000100UL
+#define EUR_CR_SOFT_RESET_PDS_RESET_MASK 0x00000100U
#define EUR_CR_SOFT_RESET_PDS_RESET_SHIFT 8
-#define EUR_CR_SOFT_RESET_PBE_RESET_MASK 0x00000200UL
+#define EUR_CR_SOFT_RESET_PBE_RESET_MASK 0x00000200U
#define EUR_CR_SOFT_RESET_PBE_RESET_SHIFT 9
-#define EUR_CR_SOFT_RESET_CACHEL2_RESET_MASK 0x00000400UL
+#define EUR_CR_SOFT_RESET_CACHEL2_RESET_MASK 0x00000400U
#define EUR_CR_SOFT_RESET_CACHEL2_RESET_SHIFT 10
-#define EUR_CR_SOFT_RESET_UCACHEL2_RESET_MASK 0x00000800UL
+#define EUR_CR_SOFT_RESET_UCACHEL2_RESET_MASK 0x00000800U
#define EUR_CR_SOFT_RESET_UCACHEL2_RESET_SHIFT 11
-#define EUR_CR_SOFT_RESET_MADD_RESET_MASK 0x00001000UL
+#define EUR_CR_SOFT_RESET_MADD_RESET_MASK 0x00001000U
#define EUR_CR_SOFT_RESET_MADD_RESET_SHIFT 12
-#define EUR_CR_SOFT_RESET_ITR_RESET_MASK 0x00002000UL
+#define EUR_CR_SOFT_RESET_ITR_RESET_MASK 0x00002000U
#define EUR_CR_SOFT_RESET_ITR_RESET_SHIFT 13
-#define EUR_CR_SOFT_RESET_TEX_RESET_MASK 0x00004000UL
+#define EUR_CR_SOFT_RESET_TEX_RESET_MASK 0x00004000U
#define EUR_CR_SOFT_RESET_TEX_RESET_SHIFT 14
-#define EUR_CR_SOFT_RESET_USE_RESET_MASK 0x00008000UL
+#define EUR_CR_SOFT_RESET_USE_RESET_MASK 0x00008000U
#define EUR_CR_SOFT_RESET_USE_RESET_SHIFT 15
-#define EUR_CR_SOFT_RESET_IDXFIFO_RESET_MASK 0x00010000UL
+#define EUR_CR_SOFT_RESET_IDXFIFO_RESET_MASK 0x00010000U
#define EUR_CR_SOFT_RESET_IDXFIFO_RESET_SHIFT 16
-#define EUR_CR_SOFT_RESET_TA_RESET_MASK 0x00020000UL
+#define EUR_CR_SOFT_RESET_TA_RESET_MASK 0x00020000U
#define EUR_CR_SOFT_RESET_TA_RESET_SHIFT 17
#define EUR_CR_EVENT_HOST_ENABLE2 0x0110
-#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_TA_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_TA_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_TA_SHIFT 4
-#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_3D_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_3D_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_3D_SHIFT 3
-#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_DL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_DL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_ENABLE2_TRIG_DL_SHIFT 2
-#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_ENABLE2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_ENABLE2_DPM_TA_FREE_LOAD_SHIFT 0
#define EUR_CR_EVENT_HOST_CLEAR2 0x0114
-#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_TA_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_TA_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_TA_SHIFT 4
-#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_3D_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_3D_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_3D_SHIFT 3
-#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_DL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_DL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_CLEAR2_TRIG_DL_SHIFT 2
-#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_CLEAR2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_CLEAR2_DPM_TA_FREE_LOAD_SHIFT 0
#define EUR_CR_EVENT_STATUS2 0x0118
-#define EUR_CR_EVENT_STATUS2_TRIG_TA_MASK 0x00000010UL
+#define EUR_CR_EVENT_STATUS2_TRIG_TA_MASK 0x00000010U
#define EUR_CR_EVENT_STATUS2_TRIG_TA_SHIFT 4
-#define EUR_CR_EVENT_STATUS2_TRIG_3D_MASK 0x00000008UL
+#define EUR_CR_EVENT_STATUS2_TRIG_3D_MASK 0x00000008U
#define EUR_CR_EVENT_STATUS2_TRIG_3D_SHIFT 3
-#define EUR_CR_EVENT_STATUS2_TRIG_DL_MASK 0x00000004UL
+#define EUR_CR_EVENT_STATUS2_TRIG_DL_MASK 0x00000004U
#define EUR_CR_EVENT_STATUS2_TRIG_DL_SHIFT 2
-#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_MASK 0x00000002UL
+#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_MASK 0x00000002U
#define EUR_CR_EVENT_STATUS2_DPM_3D_FREE_LOAD_SHIFT 1
-#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_MASK 0x00000001UL
+#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_MASK 0x00000001U
#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_SHIFT 0
-#define EUR_CR_EVENT_STATUS 0x012CUL
-#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_STATUS 0x012CU
+#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_STATUS_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_STATUS_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_STATUS_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_STATUS_TIMER_SHIFT 29
-#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_STATUS_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_STATUS_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_STATUS_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_STATUS_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_STATUS_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_STATUS_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_STATUS_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_STATUS_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_STATUS_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_STATUS_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_STATUS_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_STATUS_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_STATUS_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_STATUS_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_STATUS_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_STATUS_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_STATUS_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_STATUS_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_STATUS_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_STATUS_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_STATUS_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_STATUS_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_STATUS_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_STATUS_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_STATUS_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_STATUS_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_STATUS_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_STATUS_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_STATUS_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_STATUS_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_STATUS_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_STATUS_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_STATUS_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_STATUS_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_STATUS_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_STATUS_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_STATUS_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_STATUS_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_STATUS_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_SHIFT 0
#define EUR_CR_EVENT_HOST_ENABLE 0x0130
-#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_HOST_ENABLE_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_HOST_ENABLE_TIMER_SHIFT 29
-#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_HOST_ENABLE_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_HOST_ENABLE_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_HOST_ENABLE_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_HOST_ENABLE_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_ENABLE_DPM_3D_MEM_FREE_SHIFT 0
#define EUR_CR_EVENT_HOST_CLEAR 0x0134
-#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_MASK 0x80000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_MASK 0x80000000U
#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_SHIFT 31
-#define EUR_CR_EVENT_HOST_CLEAR_TIMER_MASK 0x20000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TIMER_MASK 0x20000000U
#define EUR_CR_EVENT_HOST_CLEAR_TIMER_SHIFT 29
-#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_MASK 0x10000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_MASK 0x10000000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_SHIFT 28
-#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_MASK 0x08000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_MASK 0x08000000U
#define EUR_CR_EVENT_HOST_CLEAR_TWOD_COMPLETE_SHIFT 27
-#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_MASK 0x04000000U
#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_SHIFT 26
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_MASK 0x02000000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_MASK 0x01000000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_MASK 0x01000000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_SHIFT 24
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_MASK 0x00800000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_MASK 0x00800000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_END_TILE_SHIFT 23
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_MASK 0x00400000UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_MASK 0x00400000U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_SHIFT 22
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_MASK 0x00200000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_MASK 0x00200000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_LOADED_SHIFT 21
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_MASK 0x00100000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_MASK 0x00100000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_SHIFT 20
-#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_MASK 0x00080000UL
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_MASK 0x00080000U
#define EUR_CR_EVENT_HOST_CLEAR_OTPM_FLUSHED_SHIFT 19
-#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_MASK 0x00040000UL
+#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_MASK 0x00040000U
#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_SHIFT 18
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_MASK 0x00020000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_MASK 0x00020000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_HALT_SHIFT 17
-#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_MASK 0x00010000UL
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_MASK 0x00010000U
#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_SHIFT 16
-#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_MASK 0x00008000UL
+#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_MASK 0x00008000U
#define EUR_CR_EVENT_HOST_CLEAR_BREAKPOINT_SHIFT 15
-#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK 0x00004000UL
+#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK 0x00004000U
#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_SHIFT 14
-#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_MASK 0x00002000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_MASK 0x00002000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_FINISHED_SHIFT 13
-#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_MASK 0x00001000UL
+#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_MASK 0x00001000U
#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_SHIFT 12
-#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_MASK 0x00000800UL
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_MASK 0x00000800U
#define EUR_CR_EVENT_HOST_CLEAR_TPC_CLEAR_SHIFT 11
-#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_MASK 0x00000400UL
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_MASK 0x00000400U
#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_SHIFT 10
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_MASK 0x00000200UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_MASK 0x00000200U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_CLEAR_SHIFT 9
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_MASK 0x00000100UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_MASK 0x00000100U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_SHIFT 8
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_MASK 0x00000080UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_MASK 0x00000080U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_STORE_SHIFT 7
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_MASK 0x00000040UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_MASK 0x00000040U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_SHIFT 6
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_MASK 0x00000020UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_MASK 0x00000020U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_LOAD_SHIFT 5
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_MASK 0x00000010UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_MASK 0x00000010U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_SHIFT 4
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_MASK 0x00000008UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_MASK 0x00000008U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_REACHED_MEM_THRESH_SHIFT 3
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_MASK 0x00000004U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_GBL_SHIFT 2
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_MASK 0x00000002U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_OUT_OF_MEMORY_MT_SHIFT 1
-#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_MASK 0x00000001UL
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_MASK 0x00000001U
#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_SHIFT 0
#define EUR_CR_TIMER 0x0144
-#define EUR_CR_TIMER_VALUE_MASK 0xFFFFFFFFUL
+#define EUR_CR_TIMER_VALUE_MASK 0xFFFFFFFFU
#define EUR_CR_TIMER_VALUE_SHIFT 0
#define EUR_CR_EVENT_KICK1 0x0AB0
-#define EUR_CR_EVENT_KICK1_NOW_MASK 0x000000FFUL
+#define EUR_CR_EVENT_KICK1_NOW_MASK 0x000000FFU
#define EUR_CR_EVENT_KICK1_NOW_SHIFT 0
#define EUR_CR_PDS_EXEC_BASE 0x0AB8
-#define EUR_CR_PDS_EXEC_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_PDS_EXEC_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_PDS_EXEC_BASE_ADDR_SHIFT 20
#define EUR_CR_EVENT_KICK2 0x0AC0
-#define EUR_CR_EVENT_KICK2_NOW_MASK 0x00000001UL
+#define EUR_CR_EVENT_KICK2_NOW_MASK 0x00000001U
#define EUR_CR_EVENT_KICK2_NOW_SHIFT 0
#define EUR_CR_EVENT_KICKER 0x0AC4
-#define EUR_CR_EVENT_KICKER_ADDRESS_MASK 0x0FFFFFF0UL
+#define EUR_CR_EVENT_KICKER_ADDRESS_MASK 0x0FFFFFF0U
#define EUR_CR_EVENT_KICKER_ADDRESS_SHIFT 4
#define EUR_CR_EVENT_KICK 0x0AC8
-#define EUR_CR_EVENT_KICK_NOW_MASK 0x00000001UL
+#define EUR_CR_EVENT_KICK_NOW_MASK 0x00000001U
#define EUR_CR_EVENT_KICK_NOW_SHIFT 0
#define EUR_CR_EVENT_TIMER 0x0ACC
-#define EUR_CR_EVENT_TIMER_ENABLE_MASK 0x01000000UL
+#define EUR_CR_EVENT_TIMER_ENABLE_MASK 0x01000000U
#define EUR_CR_EVENT_TIMER_ENABLE_SHIFT 24
-#define EUR_CR_EVENT_TIMER_VALUE_MASK 0x00FFFFFFUL
+#define EUR_CR_EVENT_TIMER_VALUE_MASK 0x00FFFFFFU
#define EUR_CR_EVENT_TIMER_VALUE_SHIFT 0
#define EUR_CR_PDS_INV0 0x0AD0
-#define EUR_CR_PDS_INV0_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV0_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV0_DSC_SHIFT 0
#define EUR_CR_PDS_INV1 0x0AD4
-#define EUR_CR_PDS_INV1_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV1_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV1_DSC_SHIFT 0
#define EUR_CR_EVENT_KICK3 0x0AD8
-#define EUR_CR_EVENT_KICK3_NOW_MASK 0x00000001UL
+#define EUR_CR_EVENT_KICK3_NOW_MASK 0x00000001U
#define EUR_CR_EVENT_KICK3_NOW_SHIFT 0
#define EUR_CR_PDS_INV3 0x0ADC
-#define EUR_CR_PDS_INV3_DSC_MASK 0x00000001UL
+#define EUR_CR_PDS_INV3_DSC_MASK 0x00000001U
#define EUR_CR_PDS_INV3_DSC_SHIFT 0
#define EUR_CR_PDS_INV_CSC 0x0AE0
-#define EUR_CR_PDS_INV_CSC_KICK_MASK 0x00000001UL
+#define EUR_CR_PDS_INV_CSC_KICK_MASK 0x00000001U
#define EUR_CR_PDS_INV_CSC_KICK_SHIFT 0
#define EUR_CR_PDS_PC_BASE 0x0B2C
-#define EUR_CR_PDS_PC_BASE_ADDRESS_MASK 0x00FFFFFFUL
+#define EUR_CR_PDS_PC_BASE_ADDRESS_MASK 0x00FFFFFFU
#define EUR_CR_PDS_PC_BASE_ADDRESS_SHIFT 0
#define EUR_CR_BIF_CTRL 0x0C00
-#define EUR_CR_BIF_CTRL_NOREORDER_MASK 0x00000001UL
+#define EUR_CR_BIF_CTRL_NOREORDER_MASK 0x00000001U
#define EUR_CR_BIF_CTRL_NOREORDER_SHIFT 0
-#define EUR_CR_BIF_CTRL_PAUSE_MASK 0x00000002UL
+#define EUR_CR_BIF_CTRL_PAUSE_MASK 0x00000002U
#define EUR_CR_BIF_CTRL_PAUSE_SHIFT 1
-#define EUR_CR_BIF_CTRL_FLUSH_MASK 0x00000004UL
+#define EUR_CR_BIF_CTRL_FLUSH_MASK 0x00000004U
#define EUR_CR_BIF_CTRL_FLUSH_SHIFT 2
-#define EUR_CR_BIF_CTRL_INVALDC_MASK 0x00000008UL
+#define EUR_CR_BIF_CTRL_INVALDC_MASK 0x00000008U
#define EUR_CR_BIF_CTRL_INVALDC_SHIFT 3
-#define EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK 0x00000010UL
+#define EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK 0x00000010U
#define EUR_CR_BIF_CTRL_CLEAR_FAULT_SHIFT 4
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_MASK 0x00000100UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_MASK 0x00000100U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_SHIFT 8
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_MASK 0x00000200UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_MASK 0x00000200U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_VDM_SHIFT 9
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_MASK 0x00000400UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_MASK 0x00000400U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_SHIFT 10
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_MASK 0x00001000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_MASK 0x00001000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_SHIFT 12
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_MASK 0x00002000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_MASK 0x00002000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_SHIFT 13
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_MASK 0x00004000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_MASK 0x00004000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_SHIFT 14
-#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_MASK 0x00008000UL
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_MASK 0x00008000U
#define EUR_CR_BIF_CTRL_MMU_BYPASS_USE_SHIFT 15
#define EUR_CR_BIF_INT_STAT 0x0C04
-#define EUR_CR_BIF_INT_STAT_FAULT_MASK 0x00003FFFUL
+#define EUR_CR_BIF_INT_STAT_FAULT_MASK 0x00003FFFU
#define EUR_CR_BIF_INT_STAT_FAULT_SHIFT 0
-#define EUR_CR_BIF_INT_STAT_PF_N_RW_MASK 0x00004000UL
+#define EUR_CR_BIF_INT_STAT_PF_N_RW_MASK 0x00004000U
#define EUR_CR_BIF_INT_STAT_PF_N_RW_SHIFT 14
-#define EUR_CR_BIF_INT_STAT_FLUSH_COMPLETE_MASK 0x00008000UL
+#define EUR_CR_BIF_INT_STAT_FLUSH_COMPLETE_MASK 0x00008000U
#define EUR_CR_BIF_INT_STAT_FLUSH_COMPLETE_SHIFT 15
#define EUR_CR_BIF_FAULT 0x0C08
-#define EUR_CR_BIF_FAULT_SB_MASK 0x000001F0UL
+#define EUR_CR_BIF_FAULT_SB_MASK 0x000001F0U
#define EUR_CR_BIF_FAULT_SB_SHIFT 4
-#define EUR_CR_BIF_FAULT_ADDR_MASK 0x0FFFF000UL
+#define EUR_CR_BIF_FAULT_ADDR_MASK 0x0FFFF000U
#define EUR_CR_BIF_FAULT_ADDR_SHIFT 12
#define EUR_CR_BIF_DIR_LIST_BASE0 0x0C84
-#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_MASK 0xFFFFF000UL
+#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_MASK 0xFFFFF000U
#define EUR_CR_BIF_DIR_LIST_BASE0_ADDR_SHIFT 12
#define EUR_CR_BIF_TA_REQ_BASE 0x0C90
-#define EUR_CR_BIF_TA_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_TA_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_TA_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_BIF_MEM_REQ_STAT 0x0CA8
-#define EUR_CR_BIF_MEM_REQ_STAT_READS_MASK 0x000000FFUL
+#define EUR_CR_BIF_MEM_REQ_STAT_READS_MASK 0x000000FFU
#define EUR_CR_BIF_MEM_REQ_STAT_READS_SHIFT 0
#define EUR_CR_BIF_3D_REQ_BASE 0x0CAC
-#define EUR_CR_BIF_3D_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_3D_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_3D_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_BIF_ZLS_REQ_BASE 0x0CB0
-#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_MASK 0x0FF00000UL
+#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_MASK 0x0FF00000U
#define EUR_CR_BIF_ZLS_REQ_BASE_ADDR_SHIFT 20
#define EUR_CR_2D_BLIT_STATUS 0x0E04
-#define EUR_CR_2D_BLIT_STATUS_COMPLETE_MASK 0x00FFFFFFUL
+#define EUR_CR_2D_BLIT_STATUS_COMPLETE_MASK 0x00FFFFFFU
#define EUR_CR_2D_BLIT_STATUS_COMPLETE_SHIFT 0
-#define EUR_CR_2D_BLIT_STATUS_BUSY_MASK 0x01000000UL
+#define EUR_CR_2D_BLIT_STATUS_BUSY_MASK 0x01000000U
#define EUR_CR_2D_BLIT_STATUS_BUSY_SHIFT 24
#define EUR_CR_2D_VIRTUAL_FIFO_0 0x0E10
-#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_MASK 0x00000001UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_MASK 0x00000001U
#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_SHIFT 0
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MASK 0x0000000EUL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MASK 0x0000000EU
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_SHIFT 1
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_MASK 0x00000FF0UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_MASK 0x00000FF0U
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_SHIFT 4
-#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_MASK 0x0000F000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_MASK 0x0000F000U
#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_MUL_SHIFT 12
#define EUR_CR_2D_VIRTUAL_FIFO_1 0x0E14
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_MASK 0x00000FFFUL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_MASK 0x00000FFFU
#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_SHIFT 0
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_MASK 0x00FFF000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_MASK 0x00FFF000U
#define EUR_CR_2D_VIRTUAL_FIFO_1_MAX_ACC_SHIFT 12
-#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_MASK 0xFF000000UL
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_MASK 0xFF000000U
#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_METRIC_SHIFT 24
#define EUR_CR_USE_CODE_BASE(X) (0x0A0C + (4 * (X)))
-#define EUR_CR_USE_CODE_BASE_ADDR_MASK 0x00FFFFFFUL
+#define EUR_CR_USE_CODE_BASE_ADDR_MASK 0x00FFFFFFU
#define EUR_CR_USE_CODE_BASE_ADDR_SHIFT 0
-#define EUR_CR_USE_CODE_BASE_DM_MASK 0x03000000UL
+#define EUR_CR_USE_CODE_BASE_DM_MASK 0x03000000U
#define EUR_CR_USE_CODE_BASE_DM_SHIFT 24
#define EUR_CR_USE_CODE_BASE_SIZE_UINT32 16
#define EUR_CR_USE_CODE_BASE_NUM_ENTRIES 16
-#define EUR_CR_MNE_CR_CTRL 0x0D00
-#define EUR_CR_MNE_CR_CTRL_BYP_CC_N_MASK 0x00010000UL
-#define EUR_CR_MNE_CR_CTRL_BYP_CC_N_SHIFT 16
-#define EUR_CR_MNE_CR_CTRL_BYP_CC_MASK 0x00008000UL
-#define EUR_CR_MNE_CR_CTRL_BYP_CC_SHIFT 15
-#define EUR_CR_MNE_CR_CTRL_USE_INVAL_ADDR_MASK 0x00007800UL
-#define EUR_CR_MNE_CR_CTRL_USE_INVAL_ADDR_SHIFT 11
-#define EUR_CR_MNE_CR_CTRL_BYPASS_ALL_MASK 0x00000400UL
-#define EUR_CR_MNE_CR_CTRL_BYPASS_ALL_SHIFT 10
-#define EUR_CR_MNE_CR_CTRL_BYPASS_MASK 0x000003E0UL
-#define EUR_CR_MNE_CR_CTRL_BYPASS_SHIFT 5
-#define EUR_CR_MNE_CR_CTRL_PAUSE_MASK 0x00000010UL
-#define EUR_CR_MNE_CR_CTRL_PAUSE_SHIFT 4
-#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_MASK 0x0000000EUL
-#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT 1
-#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_PDS_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT+2)
-#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_USEC_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT+1)
-#define EUR_CR_MNE_CR_CTRL_INVAL_PREQ_CACHE_MASK (1UL<<EUR_CR_MNE_CR_CTRL_INVAL_PREQ_SHIFT)
-#define EUR_CR_MNE_CR_CTRL_INVAL_ALL_MASK 0x00000001UL
-#define EUR_CR_MNE_CR_CTRL_INVAL_ALL_SHIFT 0
-#define EUR_CR_MNE_CR_USE_INVAL 0x0D04
-#define EUR_CR_MNE_CR_USE_INVAL_ADDR_MASK 0xFFFFFFFFUL
-#define EUR_CR_MNE_CR_USE_INVAL_ADDR_SHIFT 0
-#define EUR_CR_MNE_CR_STAT 0x0D08
-#define EUR_CR_MNE_CR_STAT_PAUSED_MASK 0x00000400UL
-#define EUR_CR_MNE_CR_STAT_PAUSED_SHIFT 10
-#define EUR_CR_MNE_CR_STAT_READS_MASK 0x000003FFUL
-#define EUR_CR_MNE_CR_STAT_READS_SHIFT 0
-#define EUR_CR_MNE_CR_STAT_STATS 0x0D0C
-#define EUR_CR_MNE_CR_STAT_STATS_RST_MASK 0x000FFFF0UL
-#define EUR_CR_MNE_CR_STAT_STATS_RST_SHIFT 4
-#define EUR_CR_MNE_CR_STAT_STATS_SEL_MASK 0x0000000FUL
-#define EUR_CR_MNE_CR_STAT_STATS_SEL_SHIFT 0
-#define EUR_CR_MNE_CR_STAT_STATS_OUT 0x0D10
-#define EUR_CR_MNE_CR_STAT_STATS_OUT_VALUE_MASK 0xFFFFFFFFUL
-#define EUR_CR_MNE_CR_STAT_STATS_OUT_VALUE_SHIFT 0
-#define EUR_CR_MNE_CR_EVENT_STATUS 0x0D14
-#define EUR_CR_MNE_CR_EVENT_STATUS_INVAL_MASK 0x00000001UL
-#define EUR_CR_MNE_CR_EVENT_STATUS_INVAL_SHIFT 0
-#define EUR_CR_MNE_CR_EVENT_CLEAR 0x0D18
-#define EUR_CR_MNE_CR_EVENT_CLEAR_INVAL_MASK 0x00000001UL
-#define EUR_CR_MNE_CR_EVENT_CLEAR_INVAL_SHIFT 0
-#define EUR_CR_MNE_CR_CTRL_INVAL 0x0D20
#endif
#if defined(SGX543)
#include "sgx543defs.h"
#else
+#if defined(SGX544)
+#include "sgx544defs.h"
+#else
#if defined(SGX545)
#include "sgx545defs.h"
#else
#if defined(SGX531)
#include "sgx531defs.h"
+#else
+#if defined(SGX554)
+#include "sgx554defs.h"
+#endif
+#endif
#endif
#endif
#endif
#else
#include "sgxmpdefs.h"
#endif
+#else
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+#include "mnemedefs.h"
+#endif
#endif
#endif
#endif
#if SGX_CORE_REV == 100
+ #define FIX_HW_BRN_28889
+ #else
+ #if SGX_CORE_REV == 111
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == SGX_CORE_REV_HEAD
#error "sgxerrata.h: SGX520 Core Revision unspecified"
#endif
#endif
+ #endif
#define SGX_CORE_DEFINED
#endif
#define SGX_CORE_REV SGX_CORE_REV_HEAD
#endif
+ #if SGX_CORE_REV == 103
+ #define FIX_HW_BRN_22934
+ #else
- #if SGX_CORE_REV == 103
- #define FIX_HW_BRN_22934
- #else
#if SGX_CORE_REV == 110
- #define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == 111
#define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == 120
#define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == 121
#define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == 125
+ #define FIX_HW_BRN_22934
+ #define FIX_HW_BRN_28889
#else
#if SGX_CORE_REV == SGX_CORE_REV_HEAD
#endif
#endif
#endif
- #endif
#endif
#endif
-
+ #endif
#define SGX_CORE_DEFINED
#endif
#if SGX_CORE_REV == 101
#define FIX_HW_BRN_26620
#define FIX_HW_BRN_28011
+ #else
+ #if SGX_CORE_REV == 110
+
#else
#if SGX_CORE_REV == SGX_CORE_REV_HEAD
#error "sgxerrata.h: SGX531 Core Revision unspecified"
#endif
#endif
+ #endif
#define SGX_CORE_DEFINED
#endif
#define SGX_CORE_REV SGX_CORE_REV_HEAD
#endif
- #if SGX_CORE_REV == 111
- #define FIX_HW_BRN_23281
- #define FIX_HW_BRN_23410
- #define FIX_HW_BRN_22693
- #define FIX_HW_BRN_22934
- #define FIX_HW_BRN_22997
- #define FIX_HW_BRN_23030
- #else
- #if SGX_CORE_REV == 1111
- #define FIX_HW_BRN_23281
- #define FIX_HW_BRN_23410
- #define FIX_HW_BRN_22693
- #define FIX_HW_BRN_22934
- #define FIX_HW_BRN_22997
- #define FIX_HW_BRN_23030
- #else
#if SGX_CORE_REV == 112
#define FIX_HW_BRN_23281
#define FIX_HW_BRN_23410
#endif
#endif
#endif
- #endif
- #endif
#define SGX_CORE_DEFINED
#endif
#define FIX_HW_BRN_28011
#else
#if SGX_CORE_REV == 120
+ #define FIX_HW_BRN_26620
#define FIX_HW_BRN_28011
#else
#if SGX_CORE_REV == 121
#define FIX_HW_BRN_28011
#define FIX_HW_BRN_27510
- #else
- #if SGX_CORE_REV == 101
-
#else
#if SGX_CORE_REV == SGX_CORE_REV_HEAD
#error "sgxerrata.h: SGX541 Core Revision unspecified"
#endif
#endif
- #endif
#define SGX_CORE_DEFINED
#else
#endif
#if defined(SGX543) && !defined(SGX_CORE_DEFINED)
- #if defined(SGX_FEATURE_MP)
+
+ #define SGX_CORE_REV_HEAD 0
+ #if defined(USE_SGX_CORE_REV_HEAD)
- #define SGX_CORE_REV_HEAD 0
- #if defined(USE_SGX_CORE_REV_HEAD)
-
- #define SGX_CORE_REV SGX_CORE_REV_HEAD
- #endif
+ #define SGX_CORE_REV SGX_CORE_REV_HEAD
+ #endif
- #if SGX_CORE_REV == 100
+ #if SGX_CORE_REV == 113
+ #define FIX_HW_BRN_29997
+ #define FIX_HW_BRN_30954
+ #define FIX_HW_BRN_31093
+ #define FIX_HW_BRN_31195
- #else
- #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+ #else
+ #if SGX_CORE_REV == 122
+ #define FIX_HW_BRN_29997
+ #define FIX_HW_BRN_30954
+ #define FIX_HW_BRN_31093
+ #define FIX_HW_BRN_31195
- #else
- #error "sgxerrata.h: SGX543 Core Revision unspecified"
- #endif
- #endif
+ #else
+ #if SGX_CORE_REV == 140
+ #define FIX_HW_BRN_30954
+ #define FIX_HW_BRN_31195
+
+ #else
+ #if SGX_CORE_REV == SGX_CORE_REV_HEAD
- #define SGX_CORE_DEFINED
- #else
- #error "sgxerrata.h: SGX543 only supports MP configs (SGX_FEATURE_MP)"
- #endif
+ #else
+ #error "sgxerrata.h: SGX543 Core Revision unspecified"
+ #endif
+ #endif
+ #endif
+ #endif
+
+ #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX544) && !defined(SGX_CORE_DEFINED)
+
+ #define SGX_CORE_REV_HEAD 0
+ #if defined(USE_SGX_CORE_REV_HEAD)
+
+ #define SGX_CORE_REV SGX_CORE_REV_HEAD
+ #endif
+
+ #if SGX_CORE_REV == 100
+
+ #else
+ #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+
+ #else
+ #error "sgxerrata.h: SGX544 Core Revision unspecified"
+ #endif
+ #endif
+
+ #define SGX_CORE_DEFINED
#endif
#if defined(SGX545) && !defined(SGX_CORE_DEFINED)
#define FIX_HW_BRN_26620
#define FIX_HW_BRN_27266
#define FIX_HW_BRN_27456
+ #define FIX_HW_BRN_29702
+ #define FIX_HW_BRN_29823
#else
#if SGX_CORE_REV == 109
-
+ #define FIX_HW_BRN_29702
+ #define FIX_HW_BRN_29823
+ #else
+ #if SGX_CORE_REV == 1012
+ #define FIX_HW_BRN_29823
+ #else
+ #if SGX_CORE_REV == 1013
+ #define FIX_HW_BRN_29823
#else
#if SGX_CORE_REV == SGX_CORE_REV_HEAD
#endif
#endif
#endif
+ #endif
+ #endif
+
+ #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX554) && !defined(SGX_CORE_DEFINED)
+
+ #define SGX_CORE_REV_HEAD 0
+ #if defined(USE_SGX_CORE_REV_HEAD)
+
+ #define SGX_CORE_REV SGX_CORE_REV_HEAD
+ #endif
+
+ #if SGX_CORE_REV == 100
+
+ #else
+ #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+
+ #else
+ #error "sgxerrata.h: SGX554 Core Revision unspecified"
+ #endif
+ #endif
#define SGX_CORE_DEFINED
#endif
#define SGX_FEATURE_ADDRESS_SPACE_SIZE (28)
#define SGX_FEATURE_AUTOCLOCKGATING
#else
+#if defined(SGX531)
+ #define SGX_CORE_FRIENDLY_NAME "SGX531"
+ #define SGX_CORE_ID SGX_CORE_ID_531
+ #define SGX_FEATURE_ADDRESS_SPACE_SIZE (28)
+ #define SGX_FEATURE_AUTOCLOCKGATING
+ #define SGX_FEATURE_MULTI_EVENT_KICK
+#else
#if defined(SGX535)
#define SGX_CORE_FRIENDLY_NAME "SGX535"
#define SGX_CORE_ID SGX_CORE_ID_535
#define SGX_FEATURE_BIF_NUM_DIRLISTS (8)
#define SGX_FEATURE_AUTOCLOCKGATING
#define SGX_FEATURE_MONOLITHIC_UKERNEL
+ #define SGX_FEATURE_SPM_MODE_0
#define SGX_FEATURE_MULTI_EVENT_KICK
#define SGX_FEATURE_DATA_BREAKPOINTS
+ #define SGX_FEATURE_2D_HARDWARE
+ #define SGX_FEATURE_PTLA
+ #define SGX_FEATURE_EXTENDED_PERF_COUNTERS
#else
-#if defined(SGX531)
- #define SGX_CORE_FRIENDLY_NAME "SGX531"
- #define SGX_CORE_ID SGX_CORE_ID_531
- #define SGX_FEATURE_ADDRESS_SPACE_SIZE (28)
+#if defined(SGX544)
+ #define SGX_CORE_FRIENDLY_NAME "SGX544"
+ #define SGX_CORE_ID SGX_CORE_ID_544
+ #define SGX_FEATURE_USE_NO_INSTRUCTION_PAIRING
+ #define SGX_FEATURE_USE_UNLIMITED_PHASES
+ #define SGX_FEATURE_ADDRESS_SPACE_SIZE (32)
+ #define SGX_FEATURE_MULTIPLE_MEM_CONTEXTS
+ #define SGX_FEATURE_BIF_NUM_DIRLISTS (8)
#define SGX_FEATURE_AUTOCLOCKGATING
+ #define SGX_FEATURE_MONOLITHIC_UKERNEL
+ #define SGX_FEATURE_SPM_MODE_0
#define SGX_FEATURE_MULTI_EVENT_KICK
+ #define SGX_FEATURE_DATA_BREAKPOINTS
+ #define SGX_FEATURE_EXTENDED_PERF_COUNTERS
#else
#if defined(SGX545)
#define SGX_CORE_FRIENDLY_NAME "SGX545"
#define SGX_FEATURE_AUTOCLOCKGATING
#define SGX_FEATURE_USE_NO_INSTRUCTION_PAIRING
#define SGX_FEATURE_USE_UNLIMITED_PHASES
- #define SGX_FEATURE_DXT_TEXTURES
#define SGX_FEATURE_VOLUME_TEXTURES
#define SGX_FEATURE_HOST_ALLOC_FROM_DPM
#define SGX_FEATURE_MULTIPLE_MEM_CONTEXTS
#define SGX_FEATURE_MAX_TA_RENDER_TARGETS (512)
#define SGX_FEATURE_SPM_MODE_0
#define SGX_FEATURE_SECONDARY_REQUIRES_USE_KICK
- #define SGX_FEATURE_DCU
+ #define SGX_FEATURE_WRITEBACK_DCU
#define SGX_FEATURE_BIF_WIDE_TILING_AND_4K_ADDRESS
#define SGX_FEATURE_MULTI_EVENT_KICK
+#else
+#if defined(SGX554)
+ #define SGX_CORE_FRIENDLY_NAME "SGX554"
+ #define SGX_CORE_ID SGX_CORE_ID_554
+ #define SGX_FEATURE_USE_NO_INSTRUCTION_PAIRING
+ #define SGX_FEATURE_USE_UNLIMITED_PHASES
+ #define SGX_FEATURE_ADDRESS_SPACE_SIZE (32)
+ #define SGX_FEATURE_MULTIPLE_MEM_CONTEXTS
+ #define SGX_FEATURE_BIF_NUM_DIRLISTS (8)
+ #define SGX_FEATURE_AUTOCLOCKGATING
+ #define SGX_FEATURE_MONOLITHIC_UKERNEL
+ #define SGX_FEATURE_SPM_MODE_0
+ #define SGX_FEATURE_MULTI_EVENT_KICK
+ #define SGX_FEATURE_DATA_BREAKPOINTS
+ #define SGX_FEATURE_EXTENDED_PERF_COUNTERS
+#endif
+#endif
#endif
#endif
#endif
#define __SGXMMU_KM_H__
#define SGX_MMU_PAGE_SHIFT (12)
-#define SGX_MMU_PAGE_SIZE (1UL<<SGX_MMU_PAGE_SHIFT)
-#define SGX_MMU_PAGE_MASK (SGX_MMU_PAGE_SIZE - 1UL)
+#define SGX_MMU_PAGE_SIZE (1U<<SGX_MMU_PAGE_SHIFT)
+#define SGX_MMU_PAGE_MASK (SGX_MMU_PAGE_SIZE - 1U)
#define SGX_MMU_PD_SHIFT (10)
-#define SGX_MMU_PD_SIZE (1UL<<SGX_MMU_PD_SHIFT)
-#define SGX_MMU_PD_MASK (0xFFC00000UL)
+#define SGX_MMU_PD_SIZE (1U<<SGX_MMU_PD_SHIFT)
+#define SGX_MMU_PD_MASK (0xFFC00000U)
#if defined(SGX_FEATURE_36BIT_MMU)
- #define SGX_MMU_PDE_ADDR_MASK (0xFFFFFF00UL)
+ #define SGX_MMU_PDE_ADDR_MASK (0xFFFFFF00U)
#define SGX_MMU_PDE_ADDR_ALIGNSHIFT (4)
#else
- #define SGX_MMU_PDE_ADDR_MASK (0xFFFFF000UL)
+ #define SGX_MMU_PDE_ADDR_MASK (0xFFFFF000U)
#define SGX_MMU_PDE_ADDR_ALIGNSHIFT (0)
#endif
-#define SGX_MMU_PDE_VALID (0x00000001UL)
-#define SGX_MMU_PDE_PAGE_SIZE_4K (0x00000000UL)
+#define SGX_MMU_PDE_VALID (0x00000001U)
+#define SGX_MMU_PDE_PAGE_SIZE_4K (0x00000000U)
#if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)
- #define SGX_MMU_PDE_PAGE_SIZE_16K (0x00000002UL)
- #define SGX_MMU_PDE_PAGE_SIZE_64K (0x00000004UL)
- #define SGX_MMU_PDE_PAGE_SIZE_256K (0x00000006UL)
- #define SGX_MMU_PDE_PAGE_SIZE_1M (0x00000008UL)
- #define SGX_MMU_PDE_PAGE_SIZE_4M (0x0000000AUL)
- #define SGX_MMU_PDE_PAGE_SIZE_MASK (0x0000000EUL)
+ #define SGX_MMU_PDE_PAGE_SIZE_16K (0x00000002U)
+ #define SGX_MMU_PDE_PAGE_SIZE_64K (0x00000004U)
+ #define SGX_MMU_PDE_PAGE_SIZE_256K (0x00000006U)
+ #define SGX_MMU_PDE_PAGE_SIZE_1M (0x00000008U)
+ #define SGX_MMU_PDE_PAGE_SIZE_4M (0x0000000AU)
+ #define SGX_MMU_PDE_PAGE_SIZE_MASK (0x0000000EU)
#else
- #define SGX_MMU_PDE_WRITEONLY (0x00000002UL)
- #define SGX_MMU_PDE_READONLY (0x00000004UL)
- #define SGX_MMU_PDE_CACHECONSISTENT (0x00000008UL)
- #define SGX_MMU_PDE_EDMPROTECT (0x00000010UL)
+ #define SGX_MMU_PDE_WRITEONLY (0x00000002U)
+ #define SGX_MMU_PDE_READONLY (0x00000004U)
+ #define SGX_MMU_PDE_CACHECONSISTENT (0x00000008U)
+ #define SGX_MMU_PDE_EDMPROTECT (0x00000010U)
#endif
#define SGX_MMU_PT_SHIFT (10)
-#define SGX_MMU_PT_SIZE (1UL<<SGX_MMU_PT_SHIFT)
-#define SGX_MMU_PT_MASK (0x003FF000UL)
+#define SGX_MMU_PT_SIZE (1U<<SGX_MMU_PT_SHIFT)
+#define SGX_MMU_PT_MASK (0x003FF000U)
#if defined(SGX_FEATURE_36BIT_MMU)
- #define SGX_MMU_PTE_ADDR_MASK (0xFFFFFF00UL)
+ #define SGX_MMU_PTE_ADDR_MASK (0xFFFFFF00U)
#define SGX_MMU_PTE_ADDR_ALIGNSHIFT (4)
#else
- #define SGX_MMU_PTE_ADDR_MASK (0xFFFFF000UL)
+ #define SGX_MMU_PTE_ADDR_MASK (0xFFFFF000U)
#define SGX_MMU_PTE_ADDR_ALIGNSHIFT (0)
#endif
-#define SGX_MMU_PTE_VALID (0x00000001UL)
-#define SGX_MMU_PTE_WRITEONLY (0x00000002UL)
-#define SGX_MMU_PTE_READONLY (0x00000004UL)
-#define SGX_MMU_PTE_CACHECONSISTENT (0x00000008UL)
-#define SGX_MMU_PTE_EDMPROTECT (0x00000010UL)
+#define SGX_MMU_PTE_VALID (0x00000001U)
+#define SGX_MMU_PTE_WRITEONLY (0x00000002U)
+#define SGX_MMU_PTE_READONLY (0x00000004U)
+#define SGX_MMU_PTE_CACHECONSISTENT (0x00000008U)
+#define SGX_MMU_PTE_EDMPROTECT (0x00000010U)
#endif
#if defined(__cplusplus)
extern "C"{
-#endif
-
+#endif
+
typedef struct _BM_HEAP_ BM_HEAP;
struct _BM_MAPPING_
BM_MAPPING *pMapping;
IMG_UINT32 ui32RefCount;
+ IMG_UINT32 ui32ExportCount;
} BM_BUF;
struct _BM_HEAP_
RA_ARENA *pVMArena;
DEV_ARENA_DESCRIPTOR sDevArena;
MMU_HEAP *pMMUHeap;
+ PDUMP_MMU_ATTRIB *psMMUAttrib;
struct _BM_HEAP_ *psNext;
struct _BM_HEAP_ **ppsThis;
BM_HEAP *psBMHeap;
-
+
BM_HEAP *psBMSharedHeap;
typedef IMG_VOID *BM_HANDLE;
-#define BP_POOL_MASK 0x7
+#define BP_POOL_MASK 0x7
#define BP_CONTIGUOUS (1 << 3)
#define BP_PARAMBUFFER (1 << 4)
IMG_BOOL *pbCreated);
-IMG_HANDLE
+IMG_HANDLE
BM_CreateHeap (IMG_HANDLE hBMContext,
DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo);
-IMG_VOID
+IMG_VOID
BM_DestroyHeap (IMG_HANDLE hDevMemHeap);
-IMG_BOOL
+IMG_BOOL
BM_Reinitialise (PVRSRV_DEVICE_NODE *psDeviceNode);
IMG_BOOL
BM_HANDLE *phBuf);
IMG_VOID
-BM_Free (BM_HANDLE hBuf,
+BM_Free (BM_HANDLE hBuf,
IMG_UINT32 ui32Flags);
IMG_HANDLE
BM_HandleToOSMemHandle (BM_HANDLE hBuf);
-IMG_BOOL
-BM_ContiguousStatistics (IMG_UINT32 uFlags,
- IMG_UINT32 *pTotalBytes,
- IMG_UINT32 *pAvailableBytes);
-
-
IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
IMG_DEV_VIRTADDR sDevVPageAddr,
IMG_DEV_PHYADDR *psDevPAddr);
-PVRSRV_ERROR BM_GetHeapInfo(IMG_HANDLE hDevMemHeap,
- PVRSRV_HEAP_INFO *psHeapInfo);
-
MMU_CONTEXT* BM_GetMMUContext(IMG_HANDLE hDevMemHeap);
MMU_CONTEXT* BM_GetMMUContextFromMemContext(IMG_HANDLE hDevMemContext);
IMG_HANDLE BM_GetMappingHandle(PVRSRV_KERNEL_MEM_INFO *psMemInfo);
+IMG_VOID BM_Export(BM_HANDLE hBuf);
+
+IMG_VOID BM_FreeExport(BM_HANDLE hBuf, IMG_UINT32 ui32Flags);
+
#if defined(__cplusplus)
}
#endif
IMG_UINT32 ui32DataPageSize;
+ IMG_UINT32 ui32XTileStride;
+
} DEVICE_MEMORY_HEAP_INFO;
typedef struct _DEVICE_MEMORY_INFO_
} DEV_ARENA_DESCRIPTOR;
+
+typedef struct _PDUMP_MMU_ATTRIB_
+{
+ PVRSRV_DEVICE_IDENTIFIER sDevId;
+
+ IMG_CHAR *pszPDRegRegion;
+
+
+ IMG_UINT32 ui32DataPageMask;
+
+
+ IMG_UINT32 ui32PTEValid;
+ IMG_UINT32 ui32PTSize;
+ IMG_UINT32 ui32PTEAlignShift;
+
+
+ IMG_UINT32 ui32PDEMask;
+ IMG_UINT32 ui32PDEAlignShift;
+
+} PDUMP_MMU_ATTRIB;
+
typedef struct _SYS_DATA_TAG_ *PSYS_DATA;
typedef struct _PVRSRV_DEVICE_NODE_
PVRSRV_ERROR (*pfnMMUInitialise)(struct _PVRSRV_DEVICE_NODE_*, MMU_CONTEXT**, IMG_DEV_PHYADDR*);
IMG_VOID (*pfnMMUFinalise)(MMU_CONTEXT*);
IMG_VOID (*pfnMMUInsertHeap)(MMU_CONTEXT*, MMU_HEAP*);
- MMU_HEAP* (*pfnMMUCreate)(MMU_CONTEXT*,DEV_ARENA_DESCRIPTOR*,RA_ARENA**);
+ MMU_HEAP* (*pfnMMUCreate)(MMU_CONTEXT*,DEV_ARENA_DESCRIPTOR*,RA_ARENA**,PDUMP_MMU_ATTRIB **ppsMMUAttrib);
IMG_VOID (*pfnMMUDelete)(MMU_HEAP*);
IMG_BOOL (*pfnMMUAlloc)(MMU_HEAP*pMMU,
IMG_SIZE_T uSize,
IMG_SIZE_T uSize,
IMG_UINT32 ui32MemFlags,
IMG_HANDLE hUniqueTag);
-
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+ IMG_BOOL (*pfnMMUIsHeapShared)(MMU_HEAP *);
+#endif
IMG_DEV_PHYADDR (*pfnMMUGetPhysPageAddr)(MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR sDevVPageAddr);
IMG_DEV_PHYADDR (*pfnMMUGetPDDevPAddr)(MMU_CONTEXT *pMMUContext);
+ PVRSRV_ERROR (*pfnAllocMemTilingRange)(struct _PVRSRV_DEVICE_NODE_ *psDeviceNode,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 ui32TilingStride,
+ IMG_UINT32 *pui32RangeIndex);
+ PVRSRV_ERROR (*pfnFreeMemTilingRange)(struct _PVRSRV_DEVICE_NODE_ *psDeviceNode,
+ IMG_UINT32 ui32RangeIndex);
+
+
IMG_BOOL (*pfnDeviceISR)(IMG_VOID*);
IMG_VOID *pvISRData;
struct _PVRSRV_DEVICE_NODE_ *psNext;
struct _PVRSRV_DEVICE_NODE_ **ppsThis;
+
+#if defined(PDUMP)
+
+ PVRSRV_ERROR (*pfnPDumpInitDevice)(struct _PVRSRV_DEVICE_NODE_ *psDeviceNode);
+
+ IMG_UINT32 (*pfnMMUGetContextID)(IMG_HANDLE hDevMemContext);
+#endif
} PVRSRV_DEVICE_NODE;
PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
PVRSRV_HANDLE_TYPE_MMAP_INFO,
- PVRSRV_HANDLE_TYPE_SOC_TIMER
+ PVRSRV_HANDLE_TYPE_SOC_TIMER,
+ PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ
} PVRSRV_HANDLE_TYPE;
typedef enum
}\
}
+#define DECLARE_LIST_REVERSE(TYPE) \
+IMG_VOID List_##TYPE##_Reverse(TYPE **ppsHead)
+
+#define IMPLEMENT_LIST_REVERSE(TYPE) \
+IMG_VOID List_##TYPE##_Reverse(TYPE **ppsHead)\
+{\
+ TYPE *psTmpNode1; \
+ TYPE *psTmpNode2; \
+ TYPE *psCurNode; \
+ psTmpNode1 = IMG_NULL; \
+ psCurNode = *ppsHead; \
+ while(psCurNode) { \
+ psTmpNode2 = psCurNode->psNext; \
+ psCurNode->psNext = psTmpNode1; \
+ psTmpNode1 = psCurNode; \
+ psCurNode = psTmpNode2; \
+ if(psCurNode) \
+ { \
+ psTmpNode1->ppsThis = &(psCurNode->psNext); \
+ } \
+ else \
+ { \
+ psTmpNode1->ppsThis = ppsHead; \
+ } \
+ } \
+ *ppsHead = psTmpNode1; \
+}
#define IS_LAST_ELEMENT(x) ((x)->psNext == IMG_NULL)
+#include "services_headers.h"
+
+DECLARE_LIST_ANY_VA(BM_HEAP);
+DECLARE_LIST_ANY_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_ANY_VA_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_FOR_EACH_VA(BM_HEAP);
+DECLARE_LIST_REMOVE(BM_HEAP);
+DECLARE_LIST_INSERT(BM_HEAP);
+
+DECLARE_LIST_ANY_VA(BM_CONTEXT);
+DECLARE_LIST_ANY_VA_2(BM_CONTEXT, IMG_HANDLE, IMG_NULL);
+DECLARE_LIST_ANY_VA_2(BM_CONTEXT, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_FOR_EACH(BM_CONTEXT);
+DECLARE_LIST_REMOVE(BM_CONTEXT);
+DECLARE_LIST_INSERT(BM_CONTEXT);
+
+DECLARE_LIST_ANY_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_ANY_VA(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_ANY_VA_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_FOR_EACH(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_INSERT(PVRSRV_DEVICE_NODE);
+DECLARE_LIST_REMOVE(PVRSRV_DEVICE_NODE);
+
+DECLARE_LIST_ANY_VA(PVRSRV_POWER_DEV);
+DECLARE_LIST_ANY_VA_2(PVRSRV_POWER_DEV, PVRSRV_ERROR, PVRSRV_OK);
+DECLARE_LIST_INSERT(PVRSRV_POWER_DEV);
+DECLARE_LIST_REMOVE(PVRSRV_POWER_DEV);
+
+#undef DECLARE_LIST_ANY_2
+#undef DECLARE_LIST_ANY_VA
+#undef DECLARE_LIST_ANY_VA_2
+#undef DECLARE_LIST_FOR_EACH
+#undef DECLARE_LIST_FOR_EACH_VA
+#undef DECLARE_LIST_INSERT
+#undef DECLARE_LIST_REMOVE
+
+IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va);
+IMG_VOID* MatchPowerDeviceIndex_AnyVaCb(PVRSRV_POWER_DEV *psPowerDev, va_list va);
+
#endif
+
#endif
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(DEBUG) || defined(TIMING)
typedef struct
#if defined(__linux__) && defined(__KERNEL__)
#include <linux/hardirq.h>
#include <linux/string.h>
+#include <asm/system.h>
+#if defined(__arm__)
+#include <asm/memory.h>
+#endif
#endif
#define HOST_PAGESIZE OSGetPageSize
-#define HOST_PAGEMASK (~(HOST_PAGESIZE()-1))
-#define HOST_PAGEALIGN(addr) (((addr)+HOST_PAGESIZE()-1)&HOST_PAGEMASK)
+#define HOST_PAGEMASK (HOST_PAGESIZE()-1)
+#define HOST_PAGEALIGN(addr) (((addr) + HOST_PAGEMASK) & ~HOST_PAGEMASK)
#define PVRSRV_OS_HEAP_MASK 0xf
#define PVRSRV_OS_PAGEABLE_HEAP 0x1
PVRSRV_ERROR OSUninstallSystemLISR(IMG_VOID *pvSysData);
PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData);
PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData);
-IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_VOID* pvLinAddr);
+IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_HANDLE, IMG_VOID* pvLinAddr);
IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_SIZE_T ui32Size);
IMG_VOID *OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE *phOSMemHandle);
IMG_BOOL OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle);
PVRSRV_ERROR OSReservePhys(IMG_CPU_PHYADDR BasePAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_VOID **ppvCpuVAddr, IMG_HANDLE *phOSMemHandle);
PVRSRV_ERROR OSUnReservePhys(IMG_VOID *pvCpuVAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle);
-#if defined(SUPPORT_CPU_CACHED_BUFFERS)
+#if defined(__linux__) && defined(__KERNEL__)
+
IMG_VOID OSFlushCPUCacheKM(IMG_VOID);
-IMG_VOID OSFlushCPUCacheRangeKM(IMG_VOID *pvRangeAddrStart,
- IMG_VOID *pvRangeAddrEnd);
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID);
+
+IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length);
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length);
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length);
+
+#else
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSFlushCPUCacheKM)
+#endif
+static INLINE IMG_VOID OSFlushCPUCacheKM(IMG_VOID) {}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSCleanCPUCacheKM)
+#endif
+static INLINE IMG_VOID OSCleanCPUCacheKM(IMG_VOID) {}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSFlushCPUCacheRangeKM)
+#endif
+static INLINE IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+ PVR_UNREFERENCED_PARAMETER(pvRangeAddrStart);
+ PVR_UNREFERENCED_PARAMETER(ui32Length);
+ return IMG_FALSE;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSCleanCPUCacheRangeKM)
+#endif
+static INLINE IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+ PVR_UNREFERENCED_PARAMETER(pvRangeAddrStart);
+ PVR_UNREFERENCED_PARAMETER(ui32Length);
+ return IMG_FALSE;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSInvalidateCPUCacheRangeKM)
#endif
+static INLINE IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+ IMG_VOID *pvRangeAddrStart,
+ IMG_UINT32 ui32Length)
+{
+ PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+ PVR_UNREFERENCED_PARAMETER(pvRangeAddrStart);
+ PVR_UNREFERENCED_PARAMETER(ui32Length);
+ return IMG_FALSE;
+}
+
+#endif
#if defined(__linux__)
PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr,
#endif
IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID);
-IMG_UINT32 OSGetCurrentThreadID( IMG_VOID );
+IMG_UINTPTR_T OSGetCurrentThreadID( IMG_VOID );
IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_SIZE_T ui32Size);
PVRSRV_ERROR OSAllocPages_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_UINT32 ui32PageSize, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phPageAlloc);
#endif
-
#if defined(__linux__)
IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_SIZE_T ui32ByteOffset);
#else
PVRSRV_ERROR OSInitEnvData(IMG_PVOID *ppvEnvSpecificData);
PVRSRV_ERROR OSDeInitEnvData(IMG_PVOID pvEnvSpecificData);
IMG_CHAR* OSStringCopy(IMG_CHAR *pszDest, const IMG_CHAR *pszSrc);
-IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_SIZE_T ui32Size, const IMG_CHAR *pszFormat, ...);
+IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_SIZE_T ui32Size, const IMG_CHAR *pszFormat, ...) IMG_FORMAT_PRINTF(3, 4);
#define OSStringLength(pszString) strlen(pszString)
PVRSRV_ERROR OSEventObjectCreate(const IMG_CHAR *pszName,
#endif
#if defined(__linux__) && defined(__KERNEL__)
+
#define OS_SUPPORTS_IN_LISR
+
static inline IMG_BOOL OSInLISR(IMG_VOID unref__ *pvSysData)
{
- return in_irq();
+ PVR_UNREFERENCED_PARAMETER(pvSysData);
+ return (in_irq()) ? IMG_TRUE : IMG_FALSE;
+}
+
+static inline IMG_VOID OSWriteMemoryBarrier(IMG_VOID)
+{
+ wmb();
+}
+
+static inline IMG_VOID OSMemoryBarrier(IMG_VOID)
+{
+ mb();
}
+
+#else
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSWriteMemoryBarrier)
+#endif
+static INLINE IMG_VOID OSWriteMemoryBarrier(IMG_VOID) { }
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSMemoryBarrier)
#endif
+static INLINE IMG_VOID OSMemoryBarrier(IMG_VOID) { }
+
+#endif
#if defined (__cplusplus)
}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef __PDUMP_INT_H__
+#define __PDUMP_INT_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#if !defined(_UITRON)
+#include "dbgdrvif.h"
+
+IMG_EXPORT IMG_VOID PDumpConnectionNotify(IMG_VOID);
+
+#endif
+
+typedef enum
+{
+
+ PDUMP_WRITE_MODE_CONTINUOUS = 0,
+
+ PDUMP_WRITE_MODE_LASTFRAME,
+
+ PDUMP_WRITE_MODE_BINCM,
+
+ PDUMP_WRITE_MODE_PERSISTENT
+} PDUMP_DDWMODE;
+
+
+IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags);
+
+IMG_UINT32 PDumpOSDebugDriverWrite( PDBG_STREAM psStream,
+ PDUMP_DDWMODE eDbgDrvWriteMode,
+ IMG_UINT8 *pui8Data,
+ IMG_UINT32 ui32BCount,
+ IMG_UINT32 ui32Level,
+ IMG_UINT32 ui32DbgDrvFlags);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif
+
#ifndef _PDUMP_KM_H_
#define _PDUMP_KM_H_
-#if (defined(LINUX) && (defined(SUPPORT_SGX) || defined(SUPPORT_MSVDX)))
-#define SGX_SUPPORT_COMMON_PDUMP
-
-#if defined(SGX_SUPPORT_COMMON_PDUMP)
-#include <pdump_osfunc.h>
-#endif
-#endif
+#include "pdump_osfunc.h"
#if defined(__cplusplus)
extern "C" {
#endif
-#define PDUMP_FLAGS_NEVER 0x08000000UL
-#define PDUMP_FLAGS_TOOUT2MEM 0x10000000UL
-#define PDUMP_FLAGS_LASTFRAME 0x20000000UL
-#define PDUMP_FLAGS_RESETLFBUFFER 0x40000000UL
-#define PDUMP_FLAGS_CONTINUOUS 0x80000000UL
+#include "pdump.h"
#define PDUMP_PD_UNIQUETAG (IMG_HANDLE)0
#define PDUMP_PT_UNIQUETAG (IMG_HANDLE)0
#define PDUMP_STREAM_DRIVERINFO 2
#define PDUMP_NUM_STREAMS 3
+#if defined(PDUMP_DEBUG_OUTFILES)
+extern IMG_UINT32 g_ui32EveryLineCounter;
+#endif
#ifndef PDUMP
#define MAKEUNIQUETAG(hMemInfo) (0)
#ifdef PDUMP
-#define MAKEUNIQUETAG(hMemInfo) (((BM_BUF *)(((PVRSRV_KERNEL_MEM_INFO *)hMemInfo)->sMemBlk.hBuffer))->pMapping)
+#define MAKEUNIQUETAG(hMemInfo) (((BM_BUF *)(((PVRSRV_KERNEL_MEM_INFO *)(hMemInfo))->sMemBlk.hBuffer))->pMapping)
IMG_IMPORT PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
IMG_UINT32 ui32Offset,
IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag);
- PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32Bytes,
- IMG_UINT32 ui32Flags,
- IMG_BOOL bInitialisePages,
- IMG_HANDLE hUniqueTag1,
- IMG_HANDLE hUniqueTag2);
+ PVRSRV_ERROR PDumpMemPDEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_BOOL bInitialisePages,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2);
+
+ PVRSRV_ERROR PDumpMemPTEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32Bytes,
+ IMG_UINT32 ui32Flags,
+ IMG_BOOL bInitialisePages,
+ IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hUniqueTag2);
IMG_VOID PDumpInitCommon(IMG_VOID);
IMG_VOID PDumpDeInitCommon(IMG_VOID);
IMG_VOID PDumpInit(IMG_VOID);
IMG_VOID PDumpDeInit(IMG_VOID);
+ IMG_BOOL PDumpIsSuspended(IMG_VOID);
PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID);
PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID);
IMG_IMPORT PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame);
IMG_IMPORT PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags);
IMG_IMPORT PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags);
- PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_UINT32 ui32RegAddr,
+ PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegAddr,
IMG_UINT32 ui32RegValue,
IMG_UINT32 ui32Flags);
- PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr,
+ PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegAddr,
IMG_UINT32 ui32RegValue,
IMG_UINT32 ui32Mask,
IMG_UINT32 ui32Flags);
- PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr,
- IMG_UINT32 ui32RegValue,
- IMG_UINT32 ui32Mask);
+ PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegAddr,
+ IMG_UINT32 ui32RegValue,
+ IMG_UINT32 ui32Mask);
- IMG_IMPORT PVRSRV_ERROR PDumpBitmapKM(IMG_CHAR *pszFileName,
+ IMG_IMPORT PVRSRV_ERROR PDumpBitmapKM(PVRSRV_DEVICE_NODE *psDeviceNode,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Width,
IMG_UINT32 ui32Height,
IMG_UINT32 ui32StrideInBytes,
IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_HANDLE hDevMemContext,
IMG_UINT32 ui32Size,
PDUMP_PIXEL_FORMAT ePixelFormat,
PDUMP_MEM_FORMAT eMemFormat,
IMG_UINT32 ui32PDumpFlags);
- IMG_IMPORT PVRSRV_ERROR PDumpReadRegKM(IMG_CHAR *pszFileName,
+ IMG_IMPORT PVRSRV_ERROR PDumpReadRegKM(IMG_CHAR *pszPDumpRegName,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_UINT32 ui32Address,
IMG_UINT32 ui32Size,
IMG_UINT32 ui32PDumpFlags);
- IMG_BOOL PDumpIsSuspended(IMG_VOID);
+ PVRSRV_ERROR PDumpRegKM(IMG_CHAR* pszPDumpRegName,
+ IMG_UINT32 dwReg,
+ IMG_UINT32 dwData);
-#if defined(SGX_SUPPORT_COMMON_PDUMP) || !defined(SUPPORT_VGX)
-
- PVRSRV_ERROR PDumpRegKM(IMG_UINT32 dwReg,
- IMG_UINT32 dwData);
- PVRSRV_ERROR PDumpComment(IMG_CHAR* pszFormat, ...);
+ PVRSRV_ERROR PDumpComment(IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(1, 2);
PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags,
IMG_CHAR* pszFormat,
- ...);
-
- PVRSRV_ERROR PDumpPDReg(IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32dwData,
- IMG_HANDLE hUniqueTag);
- PVRSRV_ERROR PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
- IMG_UINT32 ui32Data,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag);
-#else
- IMG_VOID PDumpRegKM(IMG_UINT32 dwReg,
- IMG_UINT32 dwData);
- IMG_VOID PDumpComment(IMG_CHAR* pszFormat, ...);
- IMG_VOID PDumpCommentWithFlags(IMG_UINT32 ui32Flags,
- IMG_CHAR* pszFormat,
- ...);
+ ...) IMG_FORMAT_PRINTF(2, 3);
-
- IMG_VOID PDumpPDReg(IMG_UINT32 ui32Reg,
+ PVRSRV_ERROR PDumpPDReg(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_UINT32 ui32Reg,
IMG_UINT32 ui32dwData,
IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpPDRegWithFlags(IMG_UINT32 ui32Reg,
+ PVRSRV_ERROR PDumpPDRegWithFlags(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_UINT32 ui32Reg,
IMG_UINT32 ui32Data,
IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag);
-#endif
-
- IMG_VOID PDumpMsvdxRegRead(const IMG_CHAR* const pRegRegion,
- const IMG_UINT32 dwRegOffset);
-
- IMG_VOID PDumpMsvdxRegWrite(const IMG_CHAR* const pRegRegion,
- const IMG_UINT32 dwRegOffset,
- const IMG_UINT32 dwData);
-
- PVRSRV_ERROR PDumpMsvdxRegPol(const IMG_CHAR* const pRegRegion,
- const IMG_UINT32 ui32Offset,
- const IMG_UINT32 ui32CheckFuncIdExt,
- const IMG_UINT32 ui32RequValue,
- const IMG_UINT32 ui32Enable,
- const IMG_UINT32 ui32PollCount,
- const IMG_UINT32 ui32TimeOut);
-
- PVRSRV_ERROR PDumpMsvdxWriteRef(const IMG_CHAR* const pRegRegion,
- const IMG_UINT32 ui32VLROffset,
- const IMG_UINT32 ui32Physical );
IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID);
IMG_IMPORT IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID);
IMG_UINT32 *pui32MMUContextID,
IMG_UINT32 ui32MMUType,
IMG_HANDLE hUniqueTag1,
+ IMG_HANDLE hOSMemHandle,
IMG_VOID *pvPDCPUAddr);
PVRSRV_ERROR PDumpClearMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
IMG_CHAR *pszMemSpace,
IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame);
+ PVRSRV_ERROR PDumpSaveMemKM (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32DataMaster,
+ IMG_UINT32 ui32PDumpFlags);
-#if defined(LINUX)
-#define COMMON_PDUMP_OS_SUPPORT
-#endif
-
-#if defined (COMMON_PDUMP_OS_SUPPORT) && !defined(SUPPORT_VGX)
-
- PVRSRV_ERROR PDumpTASignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
+ PVRSRV_ERROR PDumpTASignatureRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
IMG_UINT32 ui32TAKickCount,
IMG_BOOL bLastFrame,
IMG_UINT32 *pui32Registers,
IMG_UINT32 ui32NumRegisters);
- PVRSRV_ERROR PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
+ PVRSRV_ERROR PDump3DSignatureRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
+ IMG_BOOL bLastFrame,
+ IMG_UINT32 *pui32Registers,
+ IMG_UINT32 ui32NumRegisters);
- PVRSRV_ERROR PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
+ PVRSRV_ERROR PDumpCounterRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_UINT32 ui32DumpFrameNum,
IMG_BOOL bLastFrame,
IMG_UINT32 *pui32Registers,
IMG_UINT32 ui32NumRegisters);
- PVRSRV_ERROR PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32 ui32Flags);
+ PVRSRV_ERROR PDumpRegRead(IMG_CHAR *pszPDumpRegName,
+ const IMG_UINT32 dwRegOffset,
+ IMG_UINT32 ui32Flags);
- PVRSRV_ERROR PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
+ PVRSRV_ERROR PDumpCycleCountRegRead(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ const IMG_UINT32 dwRegOffset,
+ IMG_BOOL bLastFrame);
PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks);
- PVRSRV_ERROR PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_UINT32 ui32DevVAddr,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_HANDLE hOSMemHandle,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag);
- PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpMallocPages(PVRSRV_DEVICE_IDENTIFIER *psDevID,
+ IMG_UINT32 ui32DevVAddr,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32PageSize,
+ IMG_BOOL bShared,
+ IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_HANDLE hOSMemHandle,
+ IMG_UINT32 ui32Offset,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag);
PVRSRV_ERROR PDumpFreePages(struct _BM_HEAP_ *psBMHeap,
IMG_DEV_VIRTADDR sDevVAddr,
IMG_UINT32 ui32NumBytes,
IMG_UINT32 ui32PageSize,
IMG_HANDLE hUniqueTag,
IMG_BOOL bInterleaved);
- PVRSRV_ERROR PDumpFreePageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
-
- IMG_IMPORT PVRSRV_ERROR PDumpHWPerfCBKM(IMG_CHAR *pszFileName,
+ PVRSRV_ERROR PDumpFreePageTable(PVRSRV_DEVICE_IDENTIFIER *psDevID,
+ IMG_HANDLE hOSMemHandle,
+ IMG_CPU_VIRTADDR pvLinAddr,
+ IMG_UINT32 ui32NumBytes,
+ IMG_UINT32 ui32Flags,
+ IMG_HANDLE hUniqueTag);
+
+ IMG_IMPORT PVRSRV_ERROR PDumpHWPerfCBKM(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_DEV_VIRTADDR sDevBaseAddr,
IMG_UINT32 ui32Size,
IMG_UINT32 ui32PDumpFlags);
- PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
- IMG_UINT32 ui32ROffOffset,
- IMG_UINT32 ui32WPosVal,
- IMG_UINT32 ui32PacketSize,
- IMG_UINT32 ui32BufferSize,
- IMG_UINT32 ui32Flags,
- IMG_HANDLE hUniqueTag);
+ PVRSRV_ERROR PDumpSignatureBuffer(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+ IMG_CHAR *pszFileName,
+ IMG_CHAR *pszBufferType,
+ IMG_UINT32 ui32FileOffset,
+ IMG_DEV_VIRTADDR sDevBaseAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags);
-#else
- IMG_VOID PDumpTASignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_UINT32 ui32TAKickCount,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
- IMG_VOID PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
- IMG_VOID PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
- IMG_BOOL bLastFrame,
- IMG_UINT32 *pui32Registers,
- IMG_UINT32 ui32NumRegisters);
-
- IMG_VOID PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32 ui32Flags);
- IMG_VOID PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
-
- IMG_VOID PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
- IMG_VOID PDumpIDL(IMG_UINT32 ui32Clocks);
-
-
- IMG_VOID PDumpMallocPages(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_UINT32 ui32DevVAddr,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_HANDLE hOSMemHandle,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpMallocPageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
- IMG_VOID PDumpFreePages(struct _BM_HEAP_ *psBMHeap,
- IMG_DEV_VIRTADDR sDevVAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_UINT32 ui32PageSize,
- IMG_HANDLE hUniqueTag,
- IMG_BOOL bInterleaved);
- IMG_VOID PDumpFreePageTable(PVRSRV_DEVICE_TYPE eDeviceType,
- IMG_CPU_VIRTADDR pvLinAddr,
- IMG_UINT32 ui32NumBytes,
- IMG_HANDLE hUniqueTag);
-
- IMG_IMPORT IMG_VOID PDumpHWPerfCBKM(IMG_CHAR *pszFileName,
- IMG_UINT32 ui32FileOffset,
- IMG_DEV_VIRTADDR sDevBaseAddr,
- IMG_UINT32 ui32Size,
- IMG_UINT32 ui32PDumpFlags);
-
- IMG_VOID PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
+ PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,
IMG_UINT32 ui32ROffOffset,
IMG_UINT32 ui32WPosVal,
IMG_UINT32 ui32PacketSize,
IMG_UINT32 ui32Flags,
IMG_HANDLE hUniqueTag);
-#endif
+ PVRSRV_ERROR PDumpRegBasedCBP(IMG_CHAR *pszPDumpRegName,
+ IMG_UINT32 ui32RegOffset,
+ IMG_UINT32 ui32WPosVal,
+ IMG_UINT32 ui32PacketSize,
+ IMG_UINT32 ui32BufferSize,
+ IMG_UINT32 ui32Flags);
IMG_VOID PDumpVGXMemToFile(IMG_CHAR *pszFileName,
IMG_UINT32 ui32FileOffset,
IMG_VOID PDumpSuspendKM(IMG_VOID);
IMG_VOID PDumpResumeKM(IMG_VOID);
+
+ PVRSRV_ERROR PDumpStoreMemToFile(PDUMP_MMU_ATTRIB *psMMUAttrib,
+ IMG_CHAR *pszFileName,
+ IMG_UINT32 ui32FileOffset,
+ PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+ IMG_UINT32 uiAddr,
+ IMG_UINT32 ui32Size,
+ IMG_UINT32 ui32PDumpFlags,
+ IMG_HANDLE hUniqueTag);
+
#define PDUMPMEMPOL PDumpMemPolKM
#define PDUMPMEM PDumpMemKM
- #define PDUMPMEM2 PDumpMem2KM
+ #define PDUMPMEMPTENTRIES PDumpMemPTEntriesKM
+ #define PDUMPPDENTRIES PDumpMemPDEntriesKM
#define PDUMPMEMUM PDumpMemUM
#define PDUMPINIT PDumpInitCommon
#define PDUMPDEINIT PDumpDeInitCommon
#define PDUMPPDREG PDumpPDReg
#define PDUMPPDREGWITHFLAGS PDumpPDRegWithFlags
#define PDUMPCBP PDumpCBP
+ #define PDUMPREGBASEDCBP PDumpRegBasedCBP
#define PDUMPMALLOCPAGESPHYS PDumpMallocPagesPhys
#define PDUMPENDINITPHASE PDumpStopInitPhaseKM
- #define PDUMPMSVDXREGWRITE PDumpMsvdxRegWrite
- #define PDUMPMSVDXREGREAD PDumpMsvdxRegRead
- #define PDUMPMSVDXPOL PDumpMsvdxRegPol
- #define PDUMPMSVDXWRITEREF PDumpMsvdxWriteRef
#define PDUMPBITMAPKM PDumpBitmapKM
#define PDUMPDRIVERINFO PDumpDriverInfoKM
#define PDUMPIDLWITHFLAGS PDumpIDLWithFlags
#if ((defined(LINUX) || defined(GCC_IA32)) || defined(GCC_ARM))
#define PDUMPMEMPOL(args...)
#define PDUMPMEM(args...)
- #define PDUMPMEM2(args...)
+ #define PDUMPMEMPTENTRIES(args...)
+ #define PDUMPPDENTRIES(args...)
#define PDUMPMEMUM(args...)
#define PDUMPINIT(args...)
#define PDUMPDEINIT(args...)
#define PDUMPCOPYTOMEM(args...)
#define PDUMPWRITE(args...)
#define PDUMPCBP(args...)
+ #define PDUMPREGBASEDCBP(args...)
#define PDUMPCOMMENTWITHFLAGS(args...)
#define PDUMPMALLOCPAGESPHYS(args...)
#define PDUMPENDINITPHASE(args...)
*
******************************************************************************/
-#ifndef __PDUMP_OSFUNC_H__
-#define __PDUMP_OSFUNC_H__
-
#include <stdarg.h>
#if defined(__cplusplus)
#define MAX_PDUMP_STRING_LENGTH (256)
+
+
+
#define PDUMP_GET_SCRIPT_STRING() \
IMG_HANDLE hScript; \
IMG_UINT32 ui32MaxLen; \
if(eError != PVRSRV_OK) return eError;
#define PDUMP_GET_MSG_STRING() \
- IMG_HANDLE hMsg; \
+ IMG_CHAR *pszMsg; \
IMG_UINT32 ui32MaxLen; \
PVRSRV_ERROR eError; \
- eError = PDumpOSGetMessageString(&hMsg, &ui32MaxLen);\
+ eError = PDumpOSGetMessageString(&pszMsg, &ui32MaxLen);\
if(eError != PVRSRV_OK) return eError;
#define PDUMP_GET_FILE_STRING() \
eError = PDumpOSGetFilenameString(&pszFileName, &ui32MaxLenFileName);\
if(eError != PVRSRV_OK) return eError;
-
PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript, IMG_UINT32 *pui32MaxLen);
- PVRSRV_ERROR PDumpOSGetMessageString(IMG_HANDLE *phMsg, IMG_UINT32 *pui32MaxLen);
+ PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg, IMG_UINT32 *pui32MaxLen);
PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile, IMG_UINT32 *pui32MaxLen);
IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags);
-PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...);
+PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(3, 4);
-IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...);
+IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(1, 2);
-PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...);
+PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...) IMG_FORMAT_PRINTF(3, 4);
-PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszMsg, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs);
+PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszMsg, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs) IMG_FORMAT_PRINTF(3, 0);
IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax);
IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
IMG_UINT32 ui32Offset,
IMG_PUINT8 pui8LinAddr,
+ IMG_UINT32 ui32DataPageMask,
IMG_UINT32 *pui32PageOffset);
+IMG_VOID PDumpOSReleaseExecution(IMG_VOID);
+
+IMG_BOOL PDumpOSIsCaptureFrameKM(IMG_VOID);
+
+PVRSRV_ERROR PDumpOSSetFrameKM(IMG_UINT32 ui32Frame);
+
#if defined (__cplusplus)
}
#endif
-
-#endif
-
IMG_BOOL bInitProcess;
-
+#if defined(PDUMP)
+
+ IMG_BOOL bPDumpPersistent;
+#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
+
+ IMG_BOOL bPDumpActive;
+#endif
+#endif
IMG_HANDLE hOsPrivateData;
} PVRSRV_PER_PROCESS_DATA;
PVRSRV_PER_PROCESS_DATA *PVRSRVPerProcessData(IMG_UINT32 ui32PID);
-PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32 ui32PID);
+PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32 ui32PID, IMG_UINT32 ui32Flags);
IMG_VOID PVRSRVPerProcessDataDisconnect(IMG_UINT32 ui32PID);
PVRSRV_ERROR PVRSRVPerProcessDataInit(IMG_VOID);
#endif
#define UPDATE_QUEUE_ROFF(psQueue, ui32Size) \
- psQueue->ui32ReadOffset = (psQueue->ui32ReadOffset + ui32Size) \
- & (psQueue->ui32QueueSize - 1);
+ (psQueue)->ui32ReadOffset = ((psQueue)->ui32ReadOffset + (ui32Size)) \
+ & ((psQueue)->ui32QueueSize - 1);
typedef struct _COMMAND_COMPLETE_DATA_
{
#if defined(__linux__) && defined(__KERNEL__)
#include <linux/types.h>
#include <linux/seq_file.h>
-off_t
-QueuePrintQueues (IMG_CHAR * buffer, size_t size, off_t off);
-
-#ifdef PVR_PROC_USE_SEQ_FILE
void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off);
void ProcSeqShowQueue(struct seq_file *sfile,void* el);
#endif
-#endif
-
IMG_IMPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_SIZE_T ui32QueueSize,
IMG_IMPORT
IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie, IMG_BOOL bScheduleMISR);
-IMG_VOID PVRSRVCommandCompleteCallbacks(IMG_VOID);
-
IMG_IMPORT
PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32 ui32DevIndex,
PFN_CMD_PROC *ppfnCmdProcList,
#define CHECK_SPACE(total) \
{ \
- if(total<100) \
+ if((total)<100) \
return PVRSRV_ERROR_INVALID_PARAMS; \
}
#define UPDATE_SPACE(str, count, total) \
{ \
- if(count == -1) \
+ if((count) == -1) \
return PVRSRV_ERROR_INVALID_PARAMS; \
else \
{ \
- str += count; \
- total -= count; \
+ (str) += (count); \
+ (total) -= (count); \
} \
}
IMG_CHAR **ppszStr,
IMG_UINT32 *pui32StrLen);
+PVRSRV_ERROR RA_GetStatsFreeMem(RA_ARENA *pArena,
+ IMG_CHAR **ppszStr,
+ IMG_UINT32 *pui32StrLen);
+
#endif
#endif
- RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN,
+ RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN_REF,
RESMAN_TYPE_DISPLAYCLASS_DEVICE,
RESMAN_TYPE_EVENT_OBJECT,
RESMAN_TYPE_SHARED_MEM_INFO,
RESMAN_TYPE_MODIFY_SYNC_OPS,
+ RESMAN_TYPE_SYNC_INFO,
RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION
#ifdef PVR_DISABLE_LOGGING
#define PVR_LOG(X)
#else
- #define PVR_LOG(X) PVRSRVReleasePrintf X
+
+ #define PVR_LOG(X) PVRSRVReleasePrintf X;
#endif
- IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVReleasePrintf(const IMG_CHAR *pszFormat,
- ...);
+ IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVReleasePrintf(const IMG_CHAR *pszFormat, ...) IMG_FORMAT_PRINTF(1, 2);
- IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVProcessConnect(IMG_UINT32 ui32PID);
+ IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVProcessConnect(IMG_UINT32 ui32PID, IMG_UINT32 ui32Flags);
IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVProcessDisconnect(IMG_UINT32 ui32PID);
+ IMG_IMPORT IMG_VOID PVRSRVScheduleDevicesKM(IMG_VOID);
+
IMG_VOID IMG_CALLCONV PVRSRVSetDCState(IMG_UINT32 ui32State);
PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer, IMG_SIZE_T *puiBufSize, IMG_BOOL bSave);
+ IMG_VOID PVRSRVScheduleDeviceCallbacks(IMG_VOID);
+
+
#if defined (__cplusplus)
}
#endif
+
#define LOOP_UNTIL_TIMEOUT(TIMEOUT) \
{\
- IMG_UINT32 uiOffset, uiStart, uiCurrent, uiNotLastLoop; \
- for(uiOffset = 0, uiStart = OSClockus(), uiCurrent = uiStart + 1, uiNotLastLoop = 1;\
- ((uiCurrent - uiStart + uiOffset) < TIMEOUT) || uiNotLastLoop--; \
- uiCurrent = OSClockus(), \
- uiOffset = uiCurrent < uiStart ? IMG_UINT32_MAX - uiStart : uiOffset, \
+ IMG_UINT32 uiOffset, uiStart, uiCurrent; \
+ IMG_INT32 iNotLastLoop; \
+ for(uiOffset = 0, uiStart = OSClockus(), uiCurrent = uiStart + 1, iNotLastLoop = 1;\
+ ((uiCurrent - uiStart + uiOffset) < (TIMEOUT)) || iNotLastLoop--; \
+ uiCurrent = OSClockus(), \
+ uiOffset = uiCurrent < uiStart ? IMG_UINT32_MAX - uiStart : uiOffset, \
uiStart = uiCurrent < uiStart ? 0 : uiStart)
#define END_LOOP_UNTIL_TIMEOUT() \
}
+IMG_IMPORT
+const IMG_CHAR *PVRSRVGetErrorStringKM(PVRSRV_ERROR eError);
#endif
#include "ra.h"
#include "device.h"
#include "buffer_manager.h"
-
+#include "pvr_debug.h"
+#include "services.h"
+
#if defined(NO_HARDWARE) && defined(__linux__) && defined(__KERNEL__)
#include <asm/io.h>
#endif
IMG_UINT32 *pvSOCTimerRegisterKM;
IMG_VOID *pvSOCClockGateRegsBase;
IMG_UINT32 ui32SOCClockGateRegsSize;
- PFN_CMD_PROC *ppfnCmdProcList[SYS_DEVICE_COUNT];
-
-
- PCOMMAND_COMPLETE_DATA *ppsCmdCompleteData[SYS_DEVICE_COUNT];
+ struct _DEVICE_COMMAND_DATA_ *apsDeviceCommandData[SYS_DEVICE_COUNT];
IMG_BOOL bReProcessQueues;
IMG_CHAR *pszVersionString;
PVRSRV_EVENTOBJECT *psGlobalEventObject;
- IMG_BOOL bFlushAll;
-
+ PVRSRV_MISC_INFO_CPUCACHEOP_TYPE ePendingCacheOpType;
} SYS_DATA;
IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData);
#endif
-PVRSRV_ERROR SysOEMFunction ( IMG_UINT32 ui32ID,
+PVRSRV_ERROR SysOEMFunction ( IMG_UINT32 ui32ID,
IMG_VOID *pvIn,
IMG_UINT32 ulInSize,
IMG_VOID *pvOut,
#ifdef INLINE_IS_PRAGMA
#pragma inline(SysAcquireData)
#endif
-static INLINE PVRSRV_ERROR SysAcquireData(SYS_DATA **ppsSysData)
+static INLINE IMG_VOID SysAcquireData(SYS_DATA **ppsSysData)
{
*ppsSysData = gpsSysData;
- if (!gpsSysData)
- {
- return PVRSRV_ERROR_GENERIC;
- }
-
- return PVRSRV_OK;
+ PVR_ASSERT (gpsSysData != IMG_NULL);
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SysAcquireDataNoCheck)
+#endif
+static INLINE SYS_DATA * SysAcquireDataNoCheck(IMG_VOID)
+{
+
+ return gpsSysData;
}
#include "kerneldisplay.h"
#include "oemfuncs.h"
#include "sgxinfo.h"
-#include "pdump_km.h"
#include "sgxinfokm.h"
#include "syslocal.h"
#include "sysconfig.h"
+#include "ocpdefs.h"
+
+#if !defined(NO_HARDWARE) && \
+ defined(SYS_USING_INTERRUPTS) && \
+ defined(SGX530) && (SGX_CORE_REV == 125)
+#define SGX_OCP_REGS_ENABLED
+#endif
+
SYS_DATA* gpsSysData = (SYS_DATA*)IMG_NULL;
SYS_DATA gsSysData;
IMG_UINT32 OutBufLen,
IMG_UINT32 *pdwBytesTransferred);
-#if defined(DEBUG_PVR) && defined(DUMP_OMAP34xx_CLOCKS) && defined(__linux__)
+#if defined(DEBUG) && defined(DUMP_OMAP34xx_CLOCKS) && defined(__linux__)
#pragma GCC diagnostic ignored "-Wstrict-prototypes"
#include <mach/clock.h>
#endif
+#if defined(SGX_OCP_REGS_ENABLED)
+
+#define SYS_OMAP3430_OCP_REGS_SYS_PHYS_BASE (SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE + EUR_CR_OCP_REVISION)
+#define SYS_OMAP3430_OCP_REGS_SIZE 0x110
+
+static IMG_CPU_VIRTADDR gpvOCPRegsLinAddr;
+
+static PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError = EnableSGXClocks(psSysData);
+
+ if(eError == PVRSRV_OK)
+ {
+ OSWriteHWReg(gpvOCPRegsLinAddr,
+ EUR_CR_OCP_DEBUG_CONFIG - EUR_CR_OCP_REVISION,
+ EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_MASK);
+ }
+
+ return eError;
+}
+
+#else
+
static INLINE PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
{
return EnableSGXClocks(psSysData);
}
+#endif
+
static INLINE PVRSRV_ERROR EnableSystemClocksWrap(SYS_DATA *psSysData)
{
PVRSRV_ERROR eError = EnableSystemClocks(psSysData);
#endif
+#if defined(PDUMP)
+ {
+
+ static IMG_CHAR pszPDumpDevName[] = "SGXMEM";
+ gsSGXDeviceMap.pszPDumpDevName = pszPDumpDevName;
+ }
+#endif
psDeviceNode = psDeviceNode->psNext;
}
- PDUMPINIT();
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT);
-
eError = EnableSystemClocksWrap(gpsSysData);
if (eError != PVRSRV_OK)
{
PVR_UNREFERENCED_PARAMETER(psSysData);
#endif
-#if defined(SGX_OCP_REGS_ENABLED)
- OSUnMapPhysToLin(gpvOCPRegsLinAddr,
- SYS_OMAP3430_OCP_REGS_SIZE,
- PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
- IMG_NULL);
-#endif
-
if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV))
{
#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
}
}
+#if defined(SGX_OCP_REGS_ENABLED)
+ OSUnMapPhysToLin(gpvOCPRegsLinAddr,
+ SYS_OMAP3430_OCP_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+#endif
+
if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
#endif
- if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT))
- {
- PDUMPDEINIT();
- }
-
gpsSysSpecificData->ui32SysSpecificData = 0;
gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;
#define SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE 0x50000000
-#define SYS_OMAP3430_SGX_REGS_SIZE 0x10000
+
+#define SYS_OMAP3430_SGX_REGS_SIZE 0x4000
#define SYS_OMAP3430_SGX_IRQ 21
#if !defined(__SYSINFO_H__)
#define __SYSINFO_H__
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#define MAX_HW_TIME_US (1000000)
+#else
#define MAX_HW_TIME_US (500000)
+#endif
+
#define WAIT_TRY_COUNT (10000)
#define SYS_DEVICE_COUNT 3
#include <linux/version.h>
#include <linux/clk.h>
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include <linux/mutex.h>
+#else
#include <linux/spinlock.h>
+#endif
#include <asm/atomic.h>
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
IMG_UINT32 ui32SrcClockDiv;
#if defined(__linux__)
IMG_BOOL bSysClocksOneTimeInit;
- IMG_BOOL bConstraintNotificationsEnabled;
atomic_t sSGXClocksEnabled;
+#if defined(PVR_LINUX_USING_WORKQUEUES)
struct mutex sPowerLock;
+#else
+ IMG_BOOL bConstraintNotificationsEnabled;
+ spinlock_t sPowerLock;
atomic_t sPowerLockCPU;
spinlock_t sNotifyLock;
atomic_t sNotifyLockCPU;
IMG_BOOL bCallVDD2PostFunc;
-
+#endif
struct clk *psCORE_CK;
struct clk *psSGX_FCK;
struct clk *psSGX_ICK;
struct clk *psMPU_CK;
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(DEBUG) || defined(TIMING)
struct clk *psGPT11_FCK;
struct clk *psGPT11_ICK;
#endif
******************************************************************************/
#if defined(__linux__)
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include "sysutils_linux_wqueue_compat.c"
+#else
#include "sysutils_linux.c"
#endif
+#endif
#include <linux/hardirq.h>
#include <linux/spinlock.h>
#include <asm/bug.h>
-#include <linux/platform_device.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
#include <linux/semaphore.h>
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
-#include <plat/omap-pm.h>
-#else
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
+#include <plat/resource.h>
+#else
#include <mach/resource.h>
-#include <mach/omap-pm.h>
-#endif
-
+#endif
+#else
+#include <asm/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+#include <asm/arch/resource.h>
+#endif
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)) && \
+ (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
+#define CONSTRAINT_NOTIFICATIONS
+#endif
#include "sgxdefs.h"
#include "services_headers.h"
#include "sysinfo.h"
#define SGX_PARENT_CLOCK "core_ck"
#endif
-#undef SYS_SGX_CLOCK_SPEED
-#define SYS_SGX_CLOCK_SPEED sgx_clock_speed
-static int sgx_clock_speed;
-extern struct platform_device *gpsPVRLDMDev;
-
-static PVRSRV_ERROR ForceMaxSGXClocks(SYS_SPECIFIC_DATA *psSysSpecData)
-{
- PVR_UNREFERENCED_PARAMETER(psSysSpecData);
-
- /* Pin the memory bus bw to the highest value according to CORE_REV */
-#if 0
-#if defined(SGX530) && (SGX_CORE_REV == 125)
- if(cpu_is_omap3630())
- omap_pm_set_min_bus_tput(&gpsPVRLDMDev->dev, OCP_INITIATOR_AGENT, 800000);
-#else
- omap_pm_set_min_bus_tput(&gpsPVRLDMDev->dev, OCP_INITIATOR_AGENT, 664000);
-#endif
-#endif
- return PVRSRV_OK;
-}
-
-
#if !defined(PDUMP) && !defined(NO_HARDWARE)
static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
{
+ IMG_INT iCPU;
+ IMG_BOOL bLocked = IMG_FALSE;
- PVR_UNREFERENCED_PARAMETER(psSysSpecData);
- return IMG_TRUE;
+ if (!in_interrupt())
+ {
+ iCPU = get_cpu();
+ bLocked = (iCPU == atomic_read(&psSysSpecData->sPowerLockCPU));
+
+ put_cpu();
+ }
+
+ return bLocked;
}
static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
{
+ IMG_INT iCPU;
+
if (!in_interrupt())
{
- BUG_ON(in_atomic());
- mutex_lock(&psSysSpecData->sPowerLock);
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!PowerLockWrappedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sPowerLockCPU, iCPU);
}
}
{
if (!in_interrupt())
{
- BUG_ON(in_atomic());
- mutex_unlock(&psSysSpecData->sPowerLock);
- }
-}
+ PVR_ASSERT(PowerLockWrappedOnCPU(psSysSpecData));
-#else /* !defined(PDUMP) && !defined(NO_HARDWARE) */
+ atomic_set(&psSysSpecData->sPowerLockCPU, -1);
-static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
-{
- PVR_UNREFERENCED_PARAMETER(psSysSpecData);
- return IMG_FALSE;
-}
+ spin_unlock(&psSysSpecData->sPowerLock);
-static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
-{
- PVR_UNREFERENCED_PARAMETER(psSysSpecData);
-
+ put_cpu();
+ }
}
-static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
-{
- PVR_UNREFERENCED_PARAMETER(psSysSpecData);
- }
-
-#endif /* !defined(PDUMP) && !defined(NO_HARDWARE) */
PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
{
PowerLockUnwrap(psSysSpecData);
}
+#else
+static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+ return IMG_FALSE;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA unref__ *psSysData)
+{
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA unref__ *psSysData)
+{
+}
+#endif
IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
{
#endif
psTimingInfo->ui32CoreClockSpeed = rate;
psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
- psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
psTimingInfo->bEnableActivePM = IMG_TRUE;
-#else
+#else
psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+#error "SGX_DYNAMIC_TIMING_INFO must be defined for this platform"
#endif
- psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+
+static struct constraint_id cnstr_id_vdd2 = {
+ .type = RES_OPP_CO,
+ .data = (IMG_VOID *)"vdd2_opp"
+};
+
+#if !defined(PDUMP) && !defined(NO_HARDWARE)
+static inline IMG_BOOL ConstraintNotificationsEnabled(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0) && psSysSpecData->bSGXInitComplete && psSysSpecData->bConstraintNotificationsEnabled;
+
+}
+
+static IMG_BOOL NotifyLockedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU = get_cpu();
+ IMG_BOOL bLocked = (iCPU == atomic_read(&psSysSpecData->sNotifyLockCPU));
+
+ put_cpu();
+
+ return bLocked;
+}
+
+static IMG_VOID NotifyLock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+
+ BUG_ON(in_interrupt());
+
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!NotifyLockedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sNotifyLock);
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, iCPU);
}
+static IMG_VOID NotifyUnlock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ PVR_ASSERT(NotifyLockedOnCPU(psSysSpecData));
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
+
+ spin_unlock(&psSysSpecData->sNotifyLock);
+
+ put_cpu();
+}
+
+static int VDD2PostFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+
+ if (!NotifyLockedOnCPU(gpsSysSpecificData))
+ {
+ return 0;
+ }
+
+#if defined(DEBUG)
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ IMG_UINT32 rate;
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+
+ PVR_ASSERT(rate != 0);
+
+ PVR_DPF((PVR_DBG_MESSAGE, "%s: SGX clock rate: %dMHz", __FUNCTION__, HZ_TO_MHZ(rate)));
+ }
+#endif
+ if (gpsSysSpecificData->bCallVDD2PostFunc)
+ {
+ PVRSRVDevicePostClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = IMG_FALSE;
+ }
+ else
+ {
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVR_TRACE(("%s: Not calling PVR clock speed notification functions", __FUNCTION__));
+ }
+ }
+
+ NotifyUnlock(gpsSysSpecificData);
+
+ return 0;
+}
+
+static int VDD2PreFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ if (PowerLockWrappedOnCPU(gpsSysSpecificData))
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called from within a power transition. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ NotifyLock(gpsSysSpecificData);
+
+ PVR_ASSERT(!gpsSysSpecificData->bCallVDD2PostFunc);
+
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVRSRV_ERROR eError;
+
+ eError = PVRSRVDevicePreClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = (eError == PVRSRV_OK);
+
+ }
+
+ return 0;
+}
+
+static struct notifier_block sVDD2Pre = {
+ VDD2PreFunc,
+ NULL
+};
+
+static struct notifier_block sVDD2Post = {
+ VDD2PostFunc,
+ NULL
+};
+
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Registering constraint notifications"));
+
+ PVR_ASSERT(!gpsSysSpecificData->bConstraintNotificationsEnabled);
+
+ constraint_register_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_register_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_TRUE;
+ NotifyUnlock(gpsSysSpecificData);
+
+ PVR_TRACE(("VDD2 constraint notifications registered"));
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Unregistering constraint notifications"));
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_FALSE;
+ NotifyUnlock(gpsSysSpecificData);
+
+
+ constraint_unregister_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_unregister_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+}
+#else
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+}
+#endif
+#endif
+
PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
{
#if !defined(NO_HARDWARE)
SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
-
-#if 1
long lNewRate;
-#endif
+ long lRate;
IMG_INT res;
+
if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
{
return PVRSRV_OK;
PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
{
-
+
IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
}
if (res < 0)
{
PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
}
- res = clk_enable(psSysSpecData->psSGX_ICK);
+ res = clk_enable(psSysSpecData->psSGX_ICK);
if (res < 0)
{
PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
clk_disable(psSysSpecData->psSGX_FCK);
- return PVRSRV_ERROR_GENERIC;
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
}
-#if 1
- if(1){
- lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
- if (lNewRate <= 0)
- {
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
- return PVRSRV_ERROR_GENERIC;
- }
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
if (res < 0)
{
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't set SGX function clock rate (%d)", res));
- return PVRSRV_ERROR_GENERIC;
- }
- {
- static int logged;
- if (!logged) {
- printk(KERN_INFO "SGX clock rate: %ld\n", lNewRate);
- logged = 1;
- }
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
}
}
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
#endif
- ForceMaxSGXClocks(psSysSpecData);
atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
-#else /* !defined(NO_HARDWARE) */
+#else
PVR_UNREFERENCED_PARAMETER(psSysData);
-#endif /* !defined(NO_HARDWARE) */
+#endif
return PVRSRV_OK;
}
#if !defined(NO_HARDWARE)
SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
{
return;
if (psSysSpecData->psSGX_ICK)
{
- clk_disable(psSysSpecData->psSGX_ICK);
+ clk_disable(psSysSpecData->psSGX_ICK);
}
if (psSysSpecData->psSGX_FCK)
clk_disable(psSysSpecData->psSGX_FCK);
}
-#if 0
- omap_pm_set_min_bus_tput(&gpsPVRLDMDev->dev, OCP_INITIATOR_AGENT, 0);
-#endif
+
atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
#else
PVRSRV_ERROR eError;
IMG_BOOL bPowerLock;
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(DEBUG) || defined(TIMING)
IMG_INT rate;
struct clk *sys_ck;
IMG_CPU_PHYADDR TimerRegPhysBase;
{
bPowerLock = IMG_FALSE;
- sgx_clock_speed = cpu_is_omap3630() ? 200000000 : 110666666;
-
- mutex_init(&psSysSpecData->sPowerLock);
+ spin_lock_init(&psSysSpecData->sPowerLock);
atomic_set(&psSysSpecData->sPowerLockCPU, -1);
spin_lock_init(&psSysSpecData->sNotifyLock);
atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
}
psSysSpecData->psSGX_ICK = psCLK;
-#if defined(DEBUG_PVR)
+#if defined(DEBUG)
psCLK = clk_get(NULL, "mpu_ck");
if (IS_ERR(psCLK))
{
PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
goto ExitError;
}
-
+
psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
}
else
}
}
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ psSysSpecData->pVdd2Handle = constraint_get(PVRSRV_MODNAME, &cnstr_id_vdd2);
+ if (IS_ERR(psSysSpecData->pVdd2Handle))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get VDD2 constraint handle"));
+ goto ExitError;
+ }
-#if defined(DEBUG_PVR) || defined(TIMING)
+ RegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
psCLK = clk_get(NULL, "gpt11_fck");
if (IS_ERR(psCLK))
goto ExitUnRegisterConstraintNotifications;
}
psSysSpecData->psGPT11_FCK = psCLK;
-
+
psCLK = clk_get(NULL, "gpt11_ick");
if (IS_ERR(psCLK))
{
rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
-
+
res = clk_enable(psSysSpecData->psGPT11_FCK);
if (res < 0)
{
PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
goto ExitDisableGPT11FCK;
}
-
+
TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE;
pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
if(!(rate & 4))
{
PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
-
+
*pui32TimerEnable = rate | 4;
}
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
hTimerEnable);
+#endif
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ PVR_TRACE(("EnableSystemClocks: Setting SGX OPP constraint"));
+
+
+ res = constraint_set(psSysSpecData->pVdd2Handle, max_vdd2_opp);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: constraint_set failed (%d)", res));
+ goto ExitConstraintSetFailed;
+ }
#endif
eError = PVRSRV_OK;
goto Exit;
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ExitConstraintSetFailed:
+#endif
+#if defined(DEBUG) || defined(TIMING)
ExitDisableGPT11ICK:
clk_disable(psSysSpecData->psGPT11_ICK);
ExitDisableGPT11FCK:
clk_disable(psSysSpecData->psGPT11_FCK);
ExitUnRegisterConstraintNotifications:
#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
ExitError:
- eError = PVRSRV_ERROR_GENERIC;
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
Exit:
if (bPowerLock)
{
{
SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
IMG_BOOL bPowerLock;
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(DEBUG) || defined(TIMING)
IMG_CPU_PHYADDR TimerRegPhysBase;
IMG_HANDLE hTimerDisable;
IMG_UINT32 *pui32TimerDisable;
PowerLockUnwrap(psSysSpecData);
}
-#if defined(DEBUG_PVR) || defined(TIMING)
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ {
+ int res;
+
+ PVR_TRACE(("DisableSystemClocks: Removing SGX OPP constraint"));
+
+
+ res = constraint_remove(psSysSpecData->pVdd2Handle);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "DisableSystemClocks: constraint_remove failed (%d)", res));
+ }
+ }
+#endif
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
4,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
&hTimerDisable);
-
+
if (pui32TimerDisable == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
else
{
*pui32TimerDisable = 0;
-
+
OSUnMapPhysToLin(pui32TimerDisable,
4,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
clk_disable(psSysSpecData->psGPT11_FCK);
-#endif
+#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
if (bPowerLock)
{
PowerLockWrap(psSysSpecData);
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/mutex.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#if !defined(PVR_LINUX_USING_WORKQUEUES)
+#error "PVR_LINUX_USING_WORKQUEUES must be defined"
+#endif
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_lock(&psSysSpecData->sPowerLock);
+
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_unlock(&psSysSpecData->sPowerLock);
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return IMG_TRUE;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, rate, SYS_SGX_CLOCK_SPEED);
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, SYS_SGX_CLOCK_SPEED, rate);
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ rate = SYS_SGX_CLOCK_SPEED;
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+#if defined(DEBUG)
+ {
+
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ res = clk_enable(psSysSpecData->psSGX_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
+
+ clk_disable(psSysSpecData->psSGX_FCK);
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+ if (psSysSpecData->psSGX_ICK)
+ {
+ clk_disable(psSysSpecData->psSGX_ICK);
+ }
+
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ PVRSRV_ERROR eError;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ mutex_init(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ psCLK = clk_get(NULL, SGX_PARENT_CLOCK);
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psCORE_CK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_ICK = psCLK;
+
+#if defined(DEBUG)
+ psCLK = clk_get(NULL, "mpu_ck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psMPU_CK = psCLK;
+#endif
+ res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
+ goto ExitError;
+ }
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+
+#if defined(DEBUG) || defined(TIMING)
+
+ psCLK = clk_get(NULL, "gpt11_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "gpt11_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+
+ sys_ck = clk_get(NULL, "sys_ck");
+ if (IS_ERR(sys_ck))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)
+ {
+ PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));
+ res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ }
+
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+Exit:
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+#if defined(DEBUG) || defined(TIMING)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+}
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#if !defined(__OEMFUNCS_H__)\r
-#define __OEMFUNCS_H__\r
-\r
-#if defined (__cplusplus)\r
-extern "C" {\r
-#endif\r
-\r
-typedef IMG_UINT32 (*PFN_SRV_BRIDGEDISPATCH)( IMG_UINT32 Ioctl,\r
- IMG_BYTE *pInBuf,\r
- IMG_UINT32 InBufLen, \r
- IMG_BYTE *pOutBuf,\r
- IMG_UINT32 OutBufLen,\r
- IMG_UINT32 *pdwBytesTransferred);\r
-typedef struct PVRSRV_DC_OEM_JTABLE_TAG\r
-{\r
- PFN_SRV_BRIDGEDISPATCH pfnOEMBridgeDispatch;\r
- IMG_PVOID pvDummy1;\r
- IMG_PVOID pvDummy2;\r
- IMG_PVOID pvDummy3;\r
-\r
-} PVRSRV_DC_OEM_JTABLE;\r
-\r
-#define OEM_GET_EXT_FUNCS (1<<1)\r
-\r
-#if defined(__cplusplus)\r
-}\r
-#endif\r
-\r
-#endif \r
-\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__OEMFUNCS_H__)
+#define __OEMFUNCS_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef IMG_UINT32 (*PFN_SRV_BRIDGEDISPATCH)( IMG_UINT32 Ioctl,
+ IMG_BYTE *pInBuf,
+ IMG_UINT32 InBufLen,
+ IMG_BYTE *pOutBuf,
+ IMG_UINT32 OutBufLen,
+ IMG_UINT32 *pdwBytesTransferred);
+typedef struct PVRSRV_DC_OEM_JTABLE_TAG
+{
+ PFN_SRV_BRIDGEDISPATCH pfnOEMBridgeDispatch;
+ IMG_PVOID pvDummy1;
+ IMG_PVOID pvDummy2;
+ IMG_PVOID pvDummy3;
+
+} PVRSRV_DC_OEM_JTABLE;
+
+#define OEM_GET_EXT_FUNCS (1<<1)
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#include "services_headers.h"\r
-#include "kerneldisplay.h"\r
-#include "oemfuncs.h"\r
-#include "sgxinfo.h"\r
-#include "pdump_km.h"\r
-#include "sgxinfokm.h"\r
-#include "syslocal.h"\r
-#include "sysconfig.h"\r
-\r
-SYS_DATA* gpsSysData = (SYS_DATA*)IMG_NULL;\r
-SYS_DATA gsSysData;\r
-\r
-static SYS_SPECIFIC_DATA gsSysSpecificData;\r
-SYS_SPECIFIC_DATA *gpsSysSpecificData;\r
-\r
-static IMG_UINT32 gui32SGXDeviceID;\r
-static SGX_DEVICE_MAP gsSGXDeviceMap;\r
-static PVRSRV_DEVICE_NODE *gpsSGXDevNode;\r
-\r
-#define DEVICE_SGX_INTERRUPT (1 << 0)\r
-\r
-#if defined(NO_HARDWARE)\r
-static IMG_CPU_VIRTADDR gsSGXRegsCPUVAddr;\r
-#endif\r
-\r
-IMG_UINT32 PVRSRV_BridgeDispatchKM(IMG_UINT32 Ioctl,\r
- IMG_BYTE *pInBuf,\r
- IMG_UINT32 InBufLen,\r
- IMG_BYTE *pOutBuf,\r
- IMG_UINT32 OutBufLen,\r
- IMG_UINT32 *pdwBytesTransferred);\r
-\r
-static PVRSRV_ERROR SysLocateDevices(SYS_DATA *psSysData)\r
-{\r
-#if defined(NO_HARDWARE)\r
- PVRSRV_ERROR eError;\r
- IMG_CPU_PHYADDR sCpuPAddr;\r
-#endif\r
-\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
-\r
- \r
- gsSGXDeviceMap.ui32Flags = 0x0;\r
- \r
-#if defined(NO_HARDWARE)\r
- \r
- \r
- eError = OSBaseAllocContigMemory(SYS_OMAP3430_SGX_REGS_SIZE, \r
- &gsSGXRegsCPUVAddr,\r
- &sCpuPAddr);\r
- if(eError != PVRSRV_OK)\r
- {\r
- return eError;\r
- }\r
- gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;\r
- gsSGXDeviceMap.sRegsSysPBase = SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);\r
- gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;\r
-#if defined(__linux__)\r
- \r
- gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;\r
-#else\r
- \r
- gsSGXDeviceMap.pvRegsCpuVBase = IMG_NULL;\r
-#endif\r
-\r
- OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_OMAP3430_SGX_REGS_SIZE);\r
-\r
- \r
-\r
-\r
- gsSGXDeviceMap.ui32IRQ = 0;\r
-\r
-#else \r
-\r
- gsSGXDeviceMap.sRegsSysPBase.uiAddr = SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE;\r
- gsSGXDeviceMap.sRegsCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);\r
- gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;\r
-\r
- gsSGXDeviceMap.ui32IRQ = SYS_OMAP3430_SGX_IRQ;\r
-\r
-#endif \r
-\r
-\r
- \r
-\r
-\r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion)\r
-{\r
- static IMG_CHAR aszVersionString[100];\r
- SYS_DATA *psSysData;\r
- IMG_UINT32 ui32SGXRevision;\r
- IMG_INT32 i32Count;\r
-#if !defined(NO_HARDWARE)\r
- IMG_VOID *pvRegsLinAddr;\r
-\r
- pvRegsLinAddr = OSMapPhysToLin(sRegRegion,\r
- SYS_OMAP3430_SGX_REGS_SIZE,\r
- PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,\r
- IMG_NULL);\r
- if(!pvRegsLinAddr)\r
- {\r
- return IMG_NULL;\r
- }\r
-\r
- ui32SGXRevision = OSReadHWReg((IMG_PVOID)((IMG_PBYTE)pvRegsLinAddr),\r
- EUR_CR_CORE_REVISION);\r
-#else\r
- ui32SGXRevision = 0;\r
-#endif\r
-\r
- if (SysAcquireData(&psSysData) != PVRSRV_OK)\r
- {\r
- return IMG_NULL;\r
- }\r
-\r
- i32Count = OSSNPrintf(aszVersionString, 100,\r
- "SGX revision = %u.%u.%u",\r
- (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAJOR_MASK)\r
- >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),\r
- (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MINOR_MASK)\r
- >> EUR_CR_CORE_REVISION_MINOR_SHIFT),\r
- (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAINTENANCE_MASK)\r
- >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)\r
- );\r
-\r
-#if !defined(NO_HARDWARE)\r
- OSUnMapPhysToLin(pvRegsLinAddr,\r
- SYS_OMAP3430_SGX_REGS_SIZE,\r
- PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,\r
- IMG_NULL);\r
-#endif\r
-\r
- if(i32Count == -1)\r
- {\r
- return IMG_NULL;\r
- }\r
-\r
- return aszVersionString;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysInitialise(IMG_VOID)\r
-{\r
- IMG_UINT32 i;\r
- PVRSRV_ERROR eError;\r
- PVRSRV_DEVICE_NODE *psDeviceNode;\r
- IMG_CPU_PHYADDR TimerRegPhysBase;\r
-\r
-#if defined(DEBUG)\r
- PVR_DPF((PVR_DBG_WARNING,"SysInitialise: Entering..."));\r
-#endif\r
-\r
-#if !defined(SGX_DYNAMIC_TIMING_INFO)\r
- SGX_TIMING_INFORMATION* psTimingInfo;\r
-#endif\r
- gpsSysData = &gsSysData;\r
- OSMemSet(gpsSysData, 0, sizeof(SYS_DATA));\r
-\r
- gpsSysSpecificData = &gsSysSpecificData;\r
- OSMemSet(gpsSysSpecificData, 0, sizeof(SYS_SPECIFIC_DATA));\r
-\r
- gpsSysData->pvSysSpecificData = gpsSysSpecificData;\r
-\r
- eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to setup env structure"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA);\r
-\r
- gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;\r
-\r
- \r
- for(i=0; i<SYS_DEVICE_COUNT; i++)\r
- {\r
- gpsSysData->sDeviceID[i].uiID = i;\r
- gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;\r
- }\r
-\r
- gpsSysData->psDeviceNodeList = IMG_NULL;\r
- gpsSysData->psQueueList = IMG_NULL;\r
-\r
- eError = SysInitialiseCommon(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed in SysInitialiseCommon"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
-\r
- TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_REGS_SYS_PHYS_BASE;\r
- gpsSysData->pvSOCTimerRegisterKM = IMG_NULL;\r
- gpsSysData->hSOCTimerRegisterOSMemHandle = 0;\r
- OSReservePhys(TimerRegPhysBase,\r
- 4,\r
- PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,\r
- (IMG_VOID **)&gpsSysData->pvSOCTimerRegisterKM,\r
- &gpsSysData->hSOCTimerRegisterOSMemHandle);\r
-\r
-#if !defined(SGX_DYNAMIC_TIMING_INFO)\r
- \r
- psTimingInfo = &gsSGXDeviceMap.sTimingInfo;\r
- psTimingInfo->ui32CoreClockSpeed = SYS_SGX_CLOCK_SPEED;\r
- psTimingInfo->ui32HWRecoveryFreq = SYS_SGX_HWRECOVERY_TIMEOUT_FREQ; \r
- psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS; \r
- psTimingInfo->ui32uKernelFreq = SYS_SGX_PDS_TIMER_FREQ; \r
-#endif\r
-\r
- \r
-\r
- gpsSysSpecificData->ui32SrcClockDiv = 3;\r
-\r
- \r
-\r
-\r
-\r
- eError = SysLocateDevices(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to locate devices"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV);\r
-\r
- \r
-\r
-\r
- eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,\r
- DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to register device!"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_REGDEV);\r
-\r
- \r
-\r
-\r
- \r
- psDeviceNode = gpsSysData->psDeviceNodeList;\r
- while(psDeviceNode)\r
- {\r
- \r
- switch(psDeviceNode->sDevId.eDeviceType)\r
- {\r
- case PVRSRV_DEVICE_TYPE_SGX:\r
- {\r
- DEVICE_MEMORY_INFO *psDevMemoryInfo;\r
- DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;\r
-\r
- \r
-\r
-\r
- psDeviceNode->psLocalDevMemArena = IMG_NULL;\r
-\r
- \r
- psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;\r
- psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;\r
-\r
- \r
- for(i=0; i<psDevMemoryInfo->ui32HeapCount; i++)\r
- {\r
- psDeviceMemoryHeap[i].ui32Attribs |= PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;\r
- }\r
-\r
- gpsSGXDevNode = psDeviceNode;\r
- gsSysSpecificData.psSGXDevNode = psDeviceNode;\r
-\r
- break;\r
- }\r
- default:\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to find SGX device node!"));\r
- return PVRSRV_ERROR_INIT_FAILURE;\r
- }\r
-\r
- \r
- psDeviceNode = psDeviceNode->psNext;\r
- }\r
-\r
- PDUMPINIT();\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT);\r
-\r
- eError = EnableSystemClocks(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable system clocks (%d)", eError));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);\r
-\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- eError = EnableSGXClocks(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
-#endif \r
-\r
- eError = PVRSRVInitialiseDevice(gui32SGXDeviceID);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to initialise device!"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV);\r
-\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- \r
- DisableSGXClocks(gpsSysData);\r
-#endif \r
-\r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysFinalise(IMG_VOID)\r
-{\r
- PVRSRV_ERROR eError = PVRSRV_OK;\r
- \r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- eError = EnableSGXClocks(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
-#endif \r
-\r
-#if defined(SYS_USING_INTERRUPTS)\r
-\r
- eError = OSInstallMISR(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install MISR"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR);\r
-\r
- \r
- eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install ISR"));\r
- SysDeinitialise(gpsSysData);\r
- gpsSysData = IMG_NULL;\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);\r
-#endif \r
-\r
- \r
- gpsSysData->pszVersionString = SysCreateVersionString(gsSGXDeviceMap.sRegsCpuPBase);\r
- if (!gpsSysData->pszVersionString)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to create a system version string"));\r
- }\r
- else\r
- {\r
- PVR_DPF((PVR_DBG_WARNING, "SysFinalise: Version string: %s", gpsSysData->pszVersionString));\r
- }\r
-\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- \r
- DisableSGXClocks(gpsSysData);\r
-#endif \r
-\r
- gpsSysSpecificData->bSGXInitComplete = IMG_TRUE;\r
-\r
- return eError;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)\r
-{\r
- PVRSRV_ERROR eError;\r
- \r
-#if defined(SYS_USING_INTERRUPTS)\r
- if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))\r
- {\r
- eError = OSUninstallDeviceLISR(psSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallDeviceLISR failed"));\r
- return eError;\r
- }\r
- }\r
-\r
- if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR))\r
- {\r
- eError = OSUninstallMISR(psSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));\r
- return eError;\r
- }\r
- }\r
-#else\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
-#endif \r
-\r
- if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV))\r
- {\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- PVR_ASSERT(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS));\r
- \r
- eError = EnableSGXClocks(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: EnableSGXClocks failed"));\r
- return eError;\r
- }\r
-#endif \r
-\r
- \r
- eError = PVRSRVDeinitialiseDevice (gui32SGXDeviceID);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));\r
- return eError;\r
- }\r
- }\r
- \r
- \r
-\r
- if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))\r
- {\r
- DisableSystemClocks(gpsSysData);\r
- }\r
-\r
- if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA))\r
- { \r
- eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));\r
- return eError;\r
- }\r
- }\r
-\r
- if(gpsSysData->pvSOCTimerRegisterKM)\r
- {\r
- OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM,\r
- 4,\r
- PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,\r
- gpsSysData->hSOCTimerRegisterOSMemHandle);\r
- }\r
-\r
- SysDeinitialiseCommon(gpsSysData);\r
-\r
-#if defined(NO_HARDWARE)\r
- if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))\r
- {\r
- \r
- OSBaseFreeContigMemory(SYS_OMAP3430_SGX_REGS_SIZE, gsSGXRegsCPUVAddr, gsSGXDeviceMap.sRegsCpuPBase);\r
- }\r
-#endif\r
-\r
- \r
- if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT))\r
- {\r
- PDUMPDEINIT();\r
- }\r
-\r
- gpsSysSpecificData->ui32SysSpecificData = 0;\r
- gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;\r
-\r
- gpsSysData = IMG_NULL;\r
-\r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE eDeviceType,\r
- IMG_VOID **ppvDeviceMap)\r
-{\r
-\r
- switch(eDeviceType)\r
- {\r
- case PVRSRV_DEVICE_TYPE_SGX:\r
- {\r
- \r
- *ppvDeviceMap = (IMG_VOID*)&gsSGXDeviceMap;\r
-\r
- break;\r
- }\r
- default:\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysGetDeviceMemoryMap: unsupported device type"));\r
- }\r
- }\r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,\r
- IMG_CPU_PHYADDR CpuPAddr)\r
-{\r
- IMG_DEV_PHYADDR DevPAddr;\r
-\r
- PVR_UNREFERENCED_PARAMETER(eDeviceType);\r
-\r
- \r
- DevPAddr.uiAddr = CpuPAddr.uiAddr;\r
- \r
- return DevPAddr;\r
-}\r
-\r
-IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr (IMG_SYS_PHYADDR sys_paddr)\r
-{\r
- IMG_CPU_PHYADDR cpu_paddr;\r
-\r
- \r
- cpu_paddr.uiAddr = sys_paddr.uiAddr;\r
- return cpu_paddr;\r
-}\r
-\r
-IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr (IMG_CPU_PHYADDR cpu_paddr)\r
-{\r
- IMG_SYS_PHYADDR sys_paddr;\r
-\r
- \r
- sys_paddr.uiAddr = cpu_paddr.uiAddr;\r
- return sys_paddr;\r
-}\r
-\r
-\r
-IMG_DEV_PHYADDR SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr)\r
-{\r
- IMG_DEV_PHYADDR DevPAddr;\r
-\r
- PVR_UNREFERENCED_PARAMETER(eDeviceType);\r
-\r
- \r
- DevPAddr.uiAddr = SysPAddr.uiAddr;\r
-\r
- return DevPAddr;\r
-}\r
-\r
-\r
-IMG_SYS_PHYADDR SysDevPAddrToSysPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_DEV_PHYADDR DevPAddr)\r
-{\r
- IMG_SYS_PHYADDR SysPAddr;\r
-\r
- PVR_UNREFERENCED_PARAMETER(eDeviceType);\r
-\r
- \r
- SysPAddr.uiAddr = DevPAddr.uiAddr;\r
-\r
- return SysPAddr;\r
-}\r
-\r
-\r
-IMG_VOID SysRegisterExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(psDeviceNode);\r
-}\r
-\r
-\r
-IMG_VOID SysRemoveExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(psDeviceNode);\r
-}\r
-\r
-\r
-IMG_UINT32 SysGetInterruptSource(SYS_DATA *psSysData,\r
- PVRSRV_DEVICE_NODE *psDeviceNode)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
-#if defined(NO_HARDWARE)\r
- \r
- return 0xFFFFFFFF;\r
-#else\r
- \r
- return psDeviceNode->ui32SOCInterruptBit;\r
-#endif\r
-}\r
-\r
-\r
-IMG_VOID SysClearInterrupts(SYS_DATA* psSysData, IMG_UINT32 ui32ClearBits)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
- PVR_UNREFERENCED_PARAMETER(ui32ClearBits);\r
-\r
- \r
- OSReadHWReg(((PVRSRV_SGXDEV_INFO *)gpsSGXDevNode->pvDevice)->pvRegsBaseKM,\r
- EUR_CR_EVENT_HOST_CLEAR);\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysSystemPrePowerState(PVR_POWER_STATE eNewPowerState)\r
-{\r
- PVRSRV_ERROR eError = PVRSRV_OK;\r
-\r
- if (eNewPowerState == PVRSRV_POWER_STATE_D3)\r
- {\r
- PVR_TRACE(("SysSystemPrePowerState: Entering state D3"));\r
-\r
-#if defined(SYS_USING_INTERRUPTS)\r
- if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))\r
- {\r
-#if defined(SYS_CUSTOM_POWERLOCK_WRAP)\r
- IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);\r
-#endif\r
- eError = OSUninstallDeviceLISR(gpsSysData);\r
-#if defined(SYS_CUSTOM_POWERLOCK_WRAP)\r
- if (bWrapped)\r
- {\r
- UnwrapSystemPowerChange(&gsSysSpecificData);\r
- }\r
-#endif\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSUninstallDeviceLISR failed (%d)", eError));\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);\r
- SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);\r
- }\r
-#endif\r
-\r
- if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))\r
- {\r
- DisableSystemClocks(gpsSysData);\r
-\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);\r
- SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);\r
- }\r
- }\r
-\r
- return eError;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysSystemPostPowerState(PVR_POWER_STATE eNewPowerState)\r
-{\r
- PVRSRV_ERROR eError = PVRSRV_OK;\r
-\r
- if (eNewPowerState == PVRSRV_POWER_STATE_D0)\r
- {\r
- PVR_TRACE(("SysSystemPostPowerState: Entering state D0"));\r
-\r
- if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS))\r
- {\r
- eError = EnableSystemClocks(gpsSysData);\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: EnableSystemClocks failed (%d)", eError));\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);\r
- SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);\r
- }\r
-\r
-#if defined(SYS_USING_INTERRUPTS)\r
- if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))\r
- {\r
-#if defined(SYS_CUSTOM_POWERLOCK_WRAP)\r
- IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);\r
-#endif\r
-\r
- eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);\r
-#if defined(SYS_CUSTOM_POWERLOCK_WRAP)\r
- if (bWrapped)\r
- {\r
- UnwrapSystemPowerChange(&gsSysSpecificData);\r
- }\r
-#endif\r
- if (eError != PVRSRV_OK)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallDeviceLISR failed to install ISR (%d)", eError));\r
- return eError;\r
- }\r
- SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);\r
- SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);\r
- }\r
-#endif\r
- }\r
- return eError;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysDevicePrePowerState(IMG_UINT32 ui32DeviceIndex,\r
- PVR_POWER_STATE eNewPowerState,\r
- PVR_POWER_STATE eCurrentPowerState)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);\r
-\r
- if (ui32DeviceIndex != gui32SGXDeviceID)\r
- {\r
- return PVRSRV_OK;\r
- }\r
-\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- if (eNewPowerState == PVRSRV_POWER_STATE_D3)\r
- {\r
- PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePrePowerState: SGX Entering state D3"));\r
- DisableSGXClocks(gpsSysData);\r
- PVRSRVSetDCState(DC_STATE_SUSPEND_COMMANDS);\r
- }\r
-#else \r
- PVR_UNREFERENCED_PARAMETER(eNewPowerState );\r
-#endif \r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysDevicePostPowerState(IMG_UINT32 ui32DeviceIndex,\r
- PVR_POWER_STATE eNewPowerState,\r
- PVR_POWER_STATE eCurrentPowerState)\r
-{\r
- PVRSRV_ERROR eError = PVRSRV_OK;\r
-\r
- PVR_UNREFERENCED_PARAMETER(eNewPowerState);\r
-\r
- if (ui32DeviceIndex != gui32SGXDeviceID)\r
- {\r
- return eError;\r
- }\r
-\r
-#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- if (eCurrentPowerState == PVRSRV_POWER_STATE_D3)\r
- {\r
- PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePostPowerState: SGX Leaving state D3"));\r
- PVRSRVSetDCState(DC_STATE_RESUME_COMMANDS);\r
- eError = EnableSGXClocks(gpsSysData);\r
- }\r
-#else \r
- PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);\r
-#endif \r
-\r
- return eError;\r
-}\r
-\r
-\r
-PVRSRV_ERROR SysOEMFunction ( IMG_UINT32 ui32ID,\r
- IMG_VOID *pvIn,\r
- IMG_UINT32 ulInSize,\r
- IMG_VOID *pvOut,\r
- IMG_UINT32 ulOutSize)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(ui32ID);\r
- PVR_UNREFERENCED_PARAMETER(pvIn);\r
- PVR_UNREFERENCED_PARAMETER(ulInSize);\r
- PVR_UNREFERENCED_PARAMETER(pvOut);\r
- PVR_UNREFERENCED_PARAMETER(ulOutSize);\r
-\r
- if ((ui32ID == OEM_GET_EXT_FUNCS) &&\r
- (ulOutSize == sizeof(PVRSRV_DC_OEM_JTABLE)))\r
- {\r
- \r
- PVRSRV_DC_OEM_JTABLE *psOEMJTable = (PVRSRV_DC_OEM_JTABLE*) pvOut;\r
- psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;\r
- return PVRSRV_OK;\r
- }\r
-\r
- return PVRSRV_ERROR_INVALID_PARAMS;\r
-}\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include "services_headers.h"
+#include "kerneldisplay.h"
+#include "oemfuncs.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+#include "sysconfig.h"
+
+#include "ocpdefs.h"
+
+#if !defined(NO_HARDWARE) && \
+ defined(SYS_USING_INTERRUPTS) && \
+ defined(SGX530) && (SGX_CORE_REV == 125)
+#define SGX_OCP_REGS_ENABLED
+#endif
+
+SYS_DATA* gpsSysData = (SYS_DATA*)IMG_NULL;
+SYS_DATA gsSysData;
+
+static SYS_SPECIFIC_DATA gsSysSpecificData;
+SYS_SPECIFIC_DATA *gpsSysSpecificData;
+
+static IMG_UINT32 gui32SGXDeviceID;
+static SGX_DEVICE_MAP gsSGXDeviceMap;
+static PVRSRV_DEVICE_NODE *gpsSGXDevNode;
+
+#define DEVICE_SGX_INTERRUPT (1 << 0)
+
+#if defined(NO_HARDWARE)
+static IMG_CPU_VIRTADDR gsSGXRegsCPUVAddr;
+#endif
+
+IMG_UINT32 PVRSRV_BridgeDispatchKM(IMG_UINT32 Ioctl,
+ IMG_BYTE *pInBuf,
+ IMG_UINT32 InBufLen,
+ IMG_BYTE *pOutBuf,
+ IMG_UINT32 OutBufLen,
+ IMG_UINT32 *pdwBytesTransferred);
+
+#if defined(DEBUG) && defined(DUMP_OMAP34xx_CLOCKS) && defined(__linux__)
+
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+#include <mach/clock.h>
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
+#include <../mach-omap2/clock_34xx.h>
+#define ONCHIP_CLKS onchip_clks
+#else
+#include <../mach-omap2/clock34xx.h>
+#define ONCHIP_CLKS onchip_34xx_clks
+#endif
+
+static void omap3_clk_recalc(struct clk *clk) {}
+static void omap3_followparent_recalc(struct clk *clk) {}
+static void omap3_propagate_rate(struct clk *clk) {}
+static void omap3_table_recalc(struct clk *clk) {}
+static long omap3_round_to_table_rate(struct clk *clk, unsigned long rate) { return 0; }
+static int omap3_select_table_rate(struct clk *clk, unsigned long rate) { return 0; }
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+static void omap3_dpll_recalc(struct clk *clk, unsigned long parent_rate,
+ u8 rate_storage) {}
+static void omap3_clkoutx2_recalc(struct clk *clk, unsigned long parent_rate,
+ u8 rate_storage) {}
+static void omap3_dpll_allow_idle(struct clk *clk) {}
+static void omap3_dpll_deny_idle(struct clk *clk) {}
+static u32 omap3_dpll_autoidle_read(struct clk *clk) { return 0; }
+static int omap3_noncore_dpll_enable(struct clk *clk) { return 0; }
+static void omap3_noncore_dpll_disable(struct clk *clk) {}
+static int omap3_noncore_dpll_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+static int omap3_core_dpll_m2_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+void followparent_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+long omap2_dpll_round_rate(struct clk *clk, unsigned long target_rate) { return 0; }
+void omap2_clksel_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+long omap2_clksel_round_rate(struct clk *clk, unsigned long target_rate) { return 0; }
+int omap2_clksel_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+void omap2_fixed_divisor_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+void omap2_init_clksel_parent(struct clk *clk) {}
+#endif
+
+static void dump_omap34xx_clocks(void)
+{
+ struct clk **c;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
+ struct vdd_prcm_config *t1 = vdd1_rate_table;
+ struct vdd_prcm_config *t2 = vdd2_rate_table;
+
+ t1 = t1;
+ t2 = t2;
+#else
+
+ omap3_dpll_allow_idle(0);
+ omap3_dpll_deny_idle(0);
+ omap3_dpll_autoidle_read(0);
+ omap3_clk_recalc(0);
+ omap3_followparent_recalc(0);
+ omap3_propagate_rate(0);
+ omap3_table_recalc(0);
+ omap3_round_to_table_rate(0, 0);
+ omap3_select_table_rate(0, 0);
+#endif
+
+ for(c = ONCHIP_CLKS; c < ONCHIP_CLKS + ARRAY_SIZE(ONCHIP_CLKS); c++)
+ {
+ struct clk *cp = *c, *copy;
+ unsigned long rate;
+ copy = clk_get(NULL, cp->name);
+ if(!copy)
+ continue;
+ rate = clk_get_rate(copy);
+ if (rate < 1000000)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: clock %s is %lu KHz (%lu Hz)", __func__, cp->name, rate/1000, rate));
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: clock %s is %lu MHz (%lu Hz)", __func__, cp->name, rate/1000000, rate));
+ }
+ }
+}
+
+#else
+
+static INLINE void dump_omap34xx_clocks(void) {}
+
+#endif
+
+#if defined(SGX_OCP_REGS_ENABLED)
+
+#define SYS_OMAP3430_OCP_REGS_SYS_PHYS_BASE (SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE + EUR_CR_OCP_REVISION)
+#define SYS_OMAP3430_OCP_REGS_SIZE 0x110
+
+static IMG_CPU_VIRTADDR gpvOCPRegsLinAddr;
+
+static PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError = EnableSGXClocks(psSysData);
+
+ if(eError == PVRSRV_OK)
+ {
+ OSWriteHWReg(gpvOCPRegsLinAddr,
+ EUR_CR_OCP_DEBUG_CONFIG - EUR_CR_OCP_REVISION,
+ EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_MASK);
+ }
+
+ return eError;
+}
+
+#else
+
+static INLINE PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
+{
+ return EnableSGXClocks(psSysData);
+}
+
+#endif
+
+static INLINE PVRSRV_ERROR EnableSystemClocksWrap(SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError = EnableSystemClocks(psSysData);
+
+#if !defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if(eError == PVRSRV_OK)
+ {
+
+ EnableSGXClocksWrap(psSysData);
+ }
+#endif
+
+ return eError;
+}
+
+static PVRSRV_ERROR SysLocateDevices(SYS_DATA *psSysData)
+{
+#if defined(NO_HARDWARE)
+ PVRSRV_ERROR eError;
+ IMG_CPU_PHYADDR sCpuPAddr;
+#endif
+
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+
+
+ gsSGXDeviceMap.ui32Flags = 0x0;
+
+#if defined(NO_HARDWARE)
+
+
+ eError = OSBaseAllocContigMemory(SYS_OMAP3430_SGX_REGS_SIZE,
+ &gsSGXRegsCPUVAddr,
+ &sCpuPAddr);
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+ gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
+ gsSGXDeviceMap.sRegsSysPBase = SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);
+ gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;
+#if defined(__linux__)
+
+ gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
+#else
+
+ gsSGXDeviceMap.pvRegsCpuVBase = IMG_NULL;
+#endif
+
+ OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_OMAP3430_SGX_REGS_SIZE);
+
+
+
+
+ gsSGXDeviceMap.ui32IRQ = 0;
+
+#else
+
+ gsSGXDeviceMap.sRegsSysPBase.uiAddr = SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE;
+ gsSGXDeviceMap.sRegsCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);
+ gsSGXDeviceMap.ui32RegsSize = SYS_OMAP3430_SGX_REGS_SIZE;
+
+ gsSGXDeviceMap.ui32IRQ = SYS_OMAP3430_SGX_IRQ;
+
+#endif
+
+#if defined(PDUMP)
+ {
+
+ static IMG_CHAR pszPDumpDevName[] = "SGXMEM";
+ gsSGXDeviceMap.pszPDumpDevName = pszPDumpDevName;
+ }
+#endif
+
+
+
+
+ return PVRSRV_OK;
+}
+
+
+IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion)
+{
+ static IMG_CHAR aszVersionString[100];
+ SYS_DATA *psSysData;
+ IMG_UINT32 ui32SGXRevision;
+ IMG_INT32 i32Count;
+#if !defined(NO_HARDWARE)
+ IMG_VOID *pvRegsLinAddr;
+
+ pvRegsLinAddr = OSMapPhysToLin(sRegRegion,
+ SYS_OMAP3430_SGX_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+ if(!pvRegsLinAddr)
+ {
+ return IMG_NULL;
+ }
+
+ ui32SGXRevision = OSReadHWReg((IMG_PVOID)((IMG_PBYTE)pvRegsLinAddr),
+ EUR_CR_CORE_REVISION);
+#else
+ ui32SGXRevision = 0;
+#endif
+
+ SysAcquireData(&psSysData);
+
+ i32Count = OSSNPrintf(aszVersionString, 100,
+ "SGX revision = %u.%u.%u",
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAJOR_MASK)
+ >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MINOR_MASK)
+ >> EUR_CR_CORE_REVISION_MINOR_SHIFT),
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
+ >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
+ );
+
+#if !defined(NO_HARDWARE)
+ OSUnMapPhysToLin(pvRegsLinAddr,
+ SYS_OMAP3430_SGX_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+#endif
+
+ if(i32Count == -1)
+ {
+ return IMG_NULL;
+ }
+
+ return aszVersionString;
+}
+
+
+PVRSRV_ERROR SysInitialise(IMG_VOID)
+{
+ IMG_UINT32 i;
+ PVRSRV_ERROR eError;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+ SGX_TIMING_INFORMATION* psTimingInfo;
+#endif
+ gpsSysData = &gsSysData;
+ OSMemSet(gpsSysData, 0, sizeof(SYS_DATA));
+
+ gpsSysSpecificData = &gsSysSpecificData;
+ OSMemSet(gpsSysSpecificData, 0, sizeof(SYS_SPECIFIC_DATA));
+
+ gpsSysData->pvSysSpecificData = gpsSysSpecificData;
+
+ eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to setup env structure"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA);
+
+ gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;
+
+
+ for(i=0; i<SYS_DEVICE_COUNT; i++)
+ {
+ gpsSysData->sDeviceID[i].uiID = i;
+ gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;
+ }
+
+ gpsSysData->psDeviceNodeList = IMG_NULL;
+ gpsSysData->psQueueList = IMG_NULL;
+
+ eError = SysInitialiseCommon(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed in SysInitialiseCommon"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_REGS_SYS_PHYS_BASE;
+ gpsSysData->pvSOCTimerRegisterKM = IMG_NULL;
+ gpsSysData->hSOCTimerRegisterOSMemHandle = 0;
+ OSReservePhys(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,
+ (IMG_VOID **)&gpsSysData->pvSOCTimerRegisterKM,
+ &gpsSysData->hSOCTimerRegisterOSMemHandle);
+
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+
+ psTimingInfo = &gsSGXDeviceMap.sTimingInfo;
+ psTimingInfo->ui32CoreClockSpeed = SYS_SGX_CLOCK_SPEED;
+ psTimingInfo->ui32HWRecoveryFreq = SYS_SGX_HWRECOVERY_TIMEOUT_FREQ;
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+ psTimingInfo->ui32uKernelFreq = SYS_SGX_PDS_TIMER_FREQ;
+#endif
+
+
+
+ gpsSysSpecificData->ui32SrcClockDiv = 3;
+
+
+
+
+
+ eError = SysLocateDevices(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to locate devices"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV);
+
+#if defined(SGX_OCP_REGS_ENABLED)
+ {
+ IMG_SYS_PHYADDR sOCPRegsSysPBase;
+ IMG_CPU_PHYADDR sOCPRegsCpuPBase;
+
+ sOCPRegsSysPBase.uiAddr = SYS_OMAP3430_OCP_REGS_SYS_PHYS_BASE;
+ sOCPRegsCpuPBase = SysSysPAddrToCpuPAddr(sOCPRegsSysPBase);
+
+ gpvOCPRegsLinAddr = OSMapPhysToLin(sOCPRegsCpuPBase,
+ SYS_OMAP3430_OCP_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+
+ if (gpvOCPRegsLinAddr == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to map OCP registers"));
+ return PVRSRV_ERROR_BAD_MAPPING;
+ }
+ }
+#endif
+
+
+
+
+ eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,
+ DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to register device!"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_REGDEV);
+
+
+
+
+
+ psDeviceNode = gpsSysData->psDeviceNodeList;
+ while(psDeviceNode)
+ {
+
+ switch(psDeviceNode->sDevId.eDeviceType)
+ {
+ case PVRSRV_DEVICE_TYPE_SGX:
+ {
+ DEVICE_MEMORY_INFO *psDevMemoryInfo;
+ DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+
+
+
+
+ psDeviceNode->psLocalDevMemArena = IMG_NULL;
+
+
+ psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
+ psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
+
+
+ for(i=0; i<psDevMemoryInfo->ui32HeapCount; i++)
+ {
+ psDeviceMemoryHeap[i].ui32Attribs |= PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
+ }
+
+ gpsSGXDevNode = psDeviceNode;
+ gsSysSpecificData.psSGXDevNode = psDeviceNode;
+
+ break;
+ }
+ default:
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to find SGX device node!"));
+ return PVRSRV_ERROR_INIT_FAILURE;
+ }
+
+
+ psDeviceNode = psDeviceNode->psNext;
+ }
+
+ eError = EnableSystemClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable system clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+#endif
+
+ dump_omap34xx_clocks();
+
+ eError = PVRSRVInitialiseDevice(gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to initialise device!"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV);
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+
+ DisableSGXClocks(gpsSysData);
+#endif
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysFinalise(IMG_VOID)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+#endif
+
+#if defined(SYS_USING_INTERRUPTS)
+
+ eError = OSInstallMISR(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install MISR"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR);
+
+
+ eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install ISR"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+#endif
+
+
+ gpsSysData->pszVersionString = SysCreateVersionString(gsSGXDeviceMap.sRegsCpuPBase);
+ if (!gpsSysData->pszVersionString)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to create a system version string"));
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_WARNING, "SysFinalise: Version string: %s", gpsSysData->pszVersionString));
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+
+ DisableSGXClocks(gpsSysData);
+#endif
+
+ gpsSysSpecificData->bSGXInitComplete = IMG_TRUE;
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError;
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))
+ {
+ eError = OSUninstallDeviceLISR(psSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallDeviceLISR failed"));
+ return eError;
+ }
+ }
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR))
+ {
+ eError = OSUninstallMISR(psSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));
+ return eError;
+ }
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV))
+ {
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ PVR_ASSERT(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS));
+
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: EnableSGXClocks failed"));
+ return eError;
+ }
+#endif
+
+
+ eError = PVRSRVDeinitialiseDevice (gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
+ return eError;
+ }
+ }
+
+#if defined(SGX_OCP_REGS_ENABLED)
+ OSUnMapPhysToLin(gpvOCPRegsLinAddr,
+ SYS_OMAP3430_OCP_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+#endif
+
+
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
+ {
+ DisableSystemClocks(gpsSysData);
+ }
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA))
+ {
+ eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));
+ return eError;
+ }
+ }
+
+ if(gpsSysData->pvSOCTimerRegisterKM)
+ {
+ OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM,
+ 4,
+ PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,
+ gpsSysData->hSOCTimerRegisterOSMemHandle);
+ }
+
+ SysDeinitialiseCommon(gpsSysData);
+
+#if defined(NO_HARDWARE)
+ if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))
+ {
+
+ OSBaseFreeContigMemory(SYS_OMAP3430_SGX_REGS_SIZE, gsSGXRegsCPUVAddr, gsSGXDeviceMap.sRegsCpuPBase);
+ }
+#endif
+
+
+ gpsSysSpecificData->ui32SysSpecificData = 0;
+ gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;
+
+ gpsSysData = IMG_NULL;
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_VOID **ppvDeviceMap)
+{
+
+ switch(eDeviceType)
+ {
+ case PVRSRV_DEVICE_TYPE_SGX:
+ {
+
+ *ppvDeviceMap = (IMG_VOID*)&gsSGXDeviceMap;
+
+ break;
+ }
+ default:
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysGetDeviceMemoryMap: unsupported device type"));
+ }
+ }
+ return PVRSRV_OK;
+}
+
+
+IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_PHYADDR CpuPAddr)
+{
+ IMG_DEV_PHYADDR DevPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ DevPAddr.uiAddr = CpuPAddr.uiAddr;
+
+ return DevPAddr;
+}
+
+IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr (IMG_SYS_PHYADDR sys_paddr)
+{
+ IMG_CPU_PHYADDR cpu_paddr;
+
+
+ cpu_paddr.uiAddr = sys_paddr.uiAddr;
+ return cpu_paddr;
+}
+
+IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr (IMG_CPU_PHYADDR cpu_paddr)
+{
+ IMG_SYS_PHYADDR sys_paddr;
+
+
+ sys_paddr.uiAddr = cpu_paddr.uiAddr;
+ return sys_paddr;
+}
+
+
+IMG_DEV_PHYADDR SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr)
+{
+ IMG_DEV_PHYADDR DevPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ DevPAddr.uiAddr = SysPAddr.uiAddr;
+
+ return DevPAddr;
+}
+
+
+IMG_SYS_PHYADDR SysDevPAddrToSysPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_DEV_PHYADDR DevPAddr)
+{
+ IMG_SYS_PHYADDR SysPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ SysPAddr.uiAddr = DevPAddr.uiAddr;
+
+ return SysPAddr;
+}
+
+
+IMG_VOID SysRegisterExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+}
+
+
+IMG_VOID SysRemoveExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+}
+
+
+IMG_UINT32 SysGetInterruptSource(SYS_DATA *psSysData,
+ PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#if defined(NO_HARDWARE)
+
+ return 0xFFFFFFFF;
+#else
+
+ return psDeviceNode->ui32SOCInterruptBit;
+#endif
+}
+
+
+IMG_VOID SysClearInterrupts(SYS_DATA* psSysData, IMG_UINT32 ui32ClearBits)
+{
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+ PVR_UNREFERENCED_PARAMETER(ui32ClearBits);
+
+
+ OSReadHWReg(((PVRSRV_SGXDEV_INFO *)gpsSGXDevNode->pvDevice)->pvRegsBaseKM,
+ EUR_CR_EVENT_HOST_CLEAR);
+}
+
+
+PVRSRV_ERROR SysSystemPrePowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if (eNewPowerState == PVRSRV_SYS_POWER_STATE_D3)
+ {
+ PVR_TRACE(("SysSystemPrePowerState: Entering state D3"));
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))
+ {
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);
+#endif
+ eError = OSUninstallDeviceLISR(gpsSysData);
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ if (bWrapped)
+ {
+ UnwrapSystemPowerChange(&gsSysSpecificData);
+ }
+#endif
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSUninstallDeviceLISR failed (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+ }
+#endif
+
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
+ {
+ DisableSystemClocks(gpsSysData);
+
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+ }
+ }
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if (eNewPowerState == PVRSRV_SYS_POWER_STATE_D0)
+ {
+ PVR_TRACE(("SysSystemPostPowerState: Entering state D0"));
+
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS))
+ {
+ eError = EnableSystemClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: EnableSystemClocksWrap failed (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
+ }
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))
+ {
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);
+#endif
+
+ eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ if (bWrapped)
+ {
+ UnwrapSystemPowerChange(&gsSysSpecificData);
+ }
+#endif
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallDeviceLISR failed to install ISR (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
+ }
+#endif
+ }
+ return eError;
+}
+
+
+PVRSRV_ERROR SysDevicePrePowerState(IMG_UINT32 ui32DeviceIndex,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
+ PVRSRV_DEV_POWER_STATE eCurrentPowerState)
+{
+ PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
+
+ if (ui32DeviceIndex != gui32SGXDeviceID)
+ {
+ return PVRSRV_OK;
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if (eNewPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+ {
+ PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePrePowerState: SGX Entering state D3"));
+ DisableSGXClocks(gpsSysData);
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(eNewPowerState );
+#endif
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysDevicePostPowerState(IMG_UINT32 ui32DeviceIndex,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
+ PVRSRV_DEV_POWER_STATE eCurrentPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ PVR_UNREFERENCED_PARAMETER(eNewPowerState);
+
+ if (ui32DeviceIndex != gui32SGXDeviceID)
+ {
+ return eError;
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+ {
+ PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePostPowerState: SGX Leaving state D3"));
+ eError = EnableSGXClocksWrap(gpsSysData);
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
+#endif
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysOEMFunction ( IMG_UINT32 ui32ID,
+ IMG_VOID *pvIn,
+ IMG_UINT32 ulInSize,
+ IMG_VOID *pvOut,
+ IMG_UINT32 ulOutSize)
+{
+ PVR_UNREFERENCED_PARAMETER(ui32ID);
+ PVR_UNREFERENCED_PARAMETER(pvIn);
+ PVR_UNREFERENCED_PARAMETER(ulInSize);
+ PVR_UNREFERENCED_PARAMETER(pvOut);
+ PVR_UNREFERENCED_PARAMETER(ulOutSize);
+
+ if ((ui32ID == OEM_GET_EXT_FUNCS) &&
+ (ulOutSize == sizeof(PVRSRV_DC_OEM_JTABLE)))
+ {
+
+ PVRSRV_DC_OEM_JTABLE *psOEMJTable = (PVRSRV_DC_OEM_JTABLE*) pvOut;
+ psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;
+ return PVRSRV_OK;
+ }
+
+ return PVRSRV_ERROR_INVALID_PARAMS;
+}
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#if !defined(__SOCCONFIG_H__)\r
-#define __SOCCONFIG_H__\r
-\r
-#include "syscommon.h"\r
-\r
-#define VS_PRODUCT_NAME "OMAP3630"\r
-\r
-#define SYS_SGX_CLOCK_SPEED 200000000\r
-#define SYS_SGX_HWRECOVERY_TIMEOUT_FREQ (100) \r
-#define SYS_SGX_PDS_TIMER_FREQ (1000) \r
-#define SYS_SGX_ACTIVE_POWER_LATENCY_MS (1)\r
-\r
-\r
-#define SYS_OMAP3430_VDD2_OPP3_SGX_CLOCK_SPEED SYS_SGX_CLOCK_SPEED\r
-#define SYS_OMAP3430_VDD2_OPP2_SGX_CLOCK_SPEED (SYS_SGX_CLOCK_SPEED / 2)\r
-\r
-#define SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE 0x50000000\r
-#define SYS_OMAP3430_SGX_REGS_SIZE 0x10000\r
-\r
-#define SYS_OMAP3430_SGX_IRQ 21\r
-\r
-#define SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE 0x48088024\r
-#define SYS_OMAP3430_GP11TIMER_REGS_SYS_PHYS_BASE 0x48088028\r
-#define SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE 0x48088040\r
-\r
- \r
-#endif \r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SOCCONFIG_H__)
+#define __SOCCONFIG_H__
+
+#include "syscommon.h"
+
+#define VS_PRODUCT_NAME "OMAP3"
+
+#if defined(SGX530) && (SGX_CORE_REV == 125)
+#define SYS_SGX_CLOCK_SPEED 200000000
+#else
+#define SYS_SGX_CLOCK_SPEED 110666666
+#endif
+
+#define SYS_SGX_HWRECOVERY_TIMEOUT_FREQ (100)
+#define SYS_SGX_PDS_TIMER_FREQ (1000)
+
+#if !defined(SYS_SGX_ACTIVE_POWER_LATENCY_MS)
+#define SYS_SGX_ACTIVE_POWER_LATENCY_MS (1)
+#endif
+
+
+#define SYS_OMAP3430_SGX_REGS_SYS_PHYS_BASE 0x50000000
+
+#define SYS_OMAP3430_SGX_REGS_SIZE 0x10000
+
+#define SYS_OMAP3430_SGX_IRQ 21
+
+#define SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE 0x48088024
+#define SYS_OMAP3430_GP11TIMER_REGS_SYS_PHYS_BASE 0x48088028
+#define SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE 0x48088040
+
+
+#endif
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#if !defined(__SYSINFO_H__)\r
-#define __SYSINFO_H__\r
-\r
-#define MAX_HW_TIME_US (500000)\r
-#define WAIT_TRY_COUNT (10000)\r
-\r
-typedef enum _SYS_DEVICE_TYPE_\r
-{\r
- SYS_DEVICE_SGX = 0,\r
-\r
- SYS_DEVICE_FORCE_I16 = 0x7fff\r
-\r
-} SYS_DEVICE_TYPE;\r
-\r
-#define SYS_DEVICE_COUNT 3 \r
-\r
-#define PRM_REG32(offset) (offset)\r
-#define CM_REG32(offset) (offset)\r
-\r
-#define CM_FCLKEN_SGX CM_REG32(0xB00)\r
-#define CM_FCLKEN_SGX_EN_3D 0x00000002\r
-\r
-#define CM_ICLKEN_SGX CM_REG32(0xB10)\r
-#define CM_ICLKEN_SGX_EN_SGX 0x00000001\r
-\r
-#define CM_IDLEST_SGX CM_REG32(0xB20)\r
-#define CM_IDLEST_SGX_ST_SGX 0x00000001\r
-\r
-#define CM_CLKSEL_SGX CM_REG32(0xB40)\r
-#define CM_CLKSEL_SGX_MASK 0x0000000f\r
-#define CM_CLKSEL_SGX_L3DIV3 0x00000000\r
-#define CM_CLKSEL_SGX_L3DIV4 0x00000001\r
-#define CM_CLKSEL_SGX_L3DIV6 0x00000002\r
-#define CM_CLKSEL_SGX_96M 0x00000003\r
-\r
-#define CM_SLEEPDEP_SGX CM_REG32(0xB44)\r
-#define CM_CLKSTCTRL_SGX CM_REG32(0xB48)\r
-#define CM_CLKSTCTRL_SGX_AUTOSTATE 0x00008001\r
-\r
-#define CM_CLKSTST_SGX CM_REG32(0xB4C)\r
-#define CM_CLKSTST_SGX_STATUS_VALID 0x00000001\r
-\r
-#define RM_RSTST_SGX PRM_REG32(0xB58)\r
-#define RM_RSTST_SGX_RST_MASK 0x0000000F\r
-#define RM_RSTST_SGX_COREDOMAINWKUP_RST 0x00000008\r
-#define RM_RSTST_SGX_DOMAINWKUP_RST 0x00000004\r
-#define RM_RSTST_SGX_GLOBALWARM_RST 0x00000002\r
-#define RM_RSTST_SGX_GLOBALCOLD_RST 0x00000001\r
-\r
-#define PM_WKDEP_SGX PRM_REG32(0xBC8)\r
-#define PM_WKDEP_SGX_EN_WAKEUP 0x00000010\r
-#define PM_WKDEP_SGX_EN_MPU 0x00000002\r
-#define PM_WKDEP_SGX_EN_CORE 0x00000001\r
-\r
-#define PM_PWSTCTRL_SGX PRM_REG32(0xBE0)\r
-#define PM_PWSTCTRL_SGX_POWERSTATE_MASK 0x00000003\r
-#define PM_PWSTCTRL_SGX_OFF 0x00000000\r
-#define PM_PWSTCTRL_SGX_RETENTION 0x00000001\r
-#define PM_PWSTCTRL_SGX_ON 0x00000003\r
-\r
-#define PM_PWSTST_SGX PRM_REG32(0xBE4)\r
-#define PM_PWSTST_SGX_INTRANSITION 0x00100000\r
-#define PM_PWSTST_SGX_CLKACTIVITY 0x00080000\r
-#define PM_PWSTST_SGX_POWERSTATE_MASK 0x00000003\r
-#define PM_PWSTST_SGX_OFF 0x00000003\r
-#define PM_PWSTST_SGX_RETENTION 0x00000001\r
-#define PM_PWSTST_SGX_ON 0x00000000\r
-\r
-#define PM_PREPWSTST_SGX PRM_REG32(0xBE8)\r
-\r
-\r
-#endif \r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SYSINFO_H__)
+#define __SYSINFO_H__
+
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#define MAX_HW_TIME_US (1000000)
+#else
+#define MAX_HW_TIME_US (500000)
+#endif
+
+#define WAIT_TRY_COUNT (10000)
+
+#define SYS_DEVICE_COUNT 3
+
+#endif
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#if !defined(__SYSLOCAL_H__)\r
-#define __SYSLOCAL_H__\r
-\r
-#if defined(__linux__)\r
-\r
-#include <linux/version.h>\r
-#include <linux/clk.h>\r
-#include <linux/spinlock.h>\r
-#include <asm/atomic.h>\r
-\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))\r
-#include <linux/semaphore.h>\r
-#include <linux/resource.h>\r
-#else \r
-#include <asm/semaphore.h>\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))\r
-#include <asm/arch/resource.h>\r
-#endif \r
-#endif \r
-\r
-#endif \r
-\r
-#if defined (__cplusplus)\r
-extern "C" {\r
-#endif\r
-\r
- \r
- \r
-IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion);\r
-\r
-IMG_VOID DisableSystemClocks(SYS_DATA *psSysData);\r
-PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData);\r
-\r
-IMG_VOID DisableSGXClocks(SYS_DATA *psSysData);\r
-PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData);\r
-\r
-#define SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS 0x00000001\r
-#define SYS_SPECIFIC_DATA_ENABLE_LISR 0x00000002\r
-#define SYS_SPECIFIC_DATA_ENABLE_MISR 0x00000004\r
-#define SYS_SPECIFIC_DATA_ENABLE_ENVDATA 0x00000008\r
-#define SYS_SPECIFIC_DATA_ENABLE_LOCDEV 0x00000010\r
-#define SYS_SPECIFIC_DATA_ENABLE_REGDEV 0x00000020\r
-#define SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT 0x00000040\r
-#define SYS_SPECIFIC_DATA_ENABLE_INITDEV 0x00000080\r
-#define SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV 0x00000100\r
-\r
-#define SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR 0x00000200\r
-#define SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS 0x00000400\r
-\r
-#define SYS_SPECIFIC_DATA_SET(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData |= (flag)))\r
-\r
-#define SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData &= ~(flag)))\r
-\r
-#define SYS_SPECIFIC_DATA_TEST(psSysSpecData, flag) (((psSysSpecData)->ui32SysSpecificData & (flag)) != 0)\r
- \r
-typedef struct _SYS_SPECIFIC_DATA_TAG_\r
-{\r
- IMG_UINT32 ui32SysSpecificData;\r
- PVRSRV_DEVICE_NODE *psSGXDevNode;\r
- IMG_BOOL bSGXInitComplete;\r
-#if !defined(__linux__)\r
- IMG_BOOL bSGXClocksEnabled;\r
-#endif\r
- IMG_UINT32 ui32SrcClockDiv;\r
-#if defined(__linux__)\r
- IMG_BOOL bSysClocksOneTimeInit;\r
- IMG_BOOL bConstraintNotificationsEnabled;\r
- atomic_t sSGXClocksEnabled;\r
- spinlock_t sPowerLock;\r
- atomic_t sPowerLockCPU;\r
- spinlock_t sNotifyLock;\r
- atomic_t sNotifyLockCPU;\r
- IMG_BOOL bCallVDD2PostFunc;\r
-\r
- struct clk *psCORE_CK;\r
- struct clk *psSGX_FCK;\r
- struct clk *psSGX_ICK;\r
- struct clk *psMPU_CK;\r
-#if defined(DEBUG) || defined(TIMING)\r
- struct clk *psGPT11_FCK;\r
- struct clk *psGPT11_ICK;\r
-#endif\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)) \r
- struct constraint_handle *pVdd2Handle;\r
-#endif \r
-#endif \r
-} SYS_SPECIFIC_DATA;\r
-\r
-extern SYS_SPECIFIC_DATA *gpsSysSpecificData;\r
-\r
-#if defined(SYS_CUSTOM_POWERLOCK_WRAP)\r
-IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);\r
-IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);\r
-#endif\r
-\r
-#if defined(__cplusplus)\r
-}\r
-#endif\r
-\r
-#endif \r
-\r
-\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SYSLOCAL_H__)
+#define __SYSLOCAL_H__
+
+#if defined(__linux__)
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include <linux/mutex.h>
+#else
+#include <linux/spinlock.h>
+#endif
+#include <asm/atomic.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#include <linux/semaphore.h>
+#include <linux/resource.h>
+#else
+#include <asm/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+#include <asm/arch/resource.h>
+#endif
+#endif
+
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion);
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData);
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData);
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData);
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData);
+
+#define SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS 0x00000001
+#define SYS_SPECIFIC_DATA_ENABLE_LISR 0x00000002
+#define SYS_SPECIFIC_DATA_ENABLE_MISR 0x00000004
+#define SYS_SPECIFIC_DATA_ENABLE_ENVDATA 0x00000008
+#define SYS_SPECIFIC_DATA_ENABLE_LOCDEV 0x00000010
+#define SYS_SPECIFIC_DATA_ENABLE_REGDEV 0x00000020
+#define SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT 0x00000040
+#define SYS_SPECIFIC_DATA_ENABLE_INITDEV 0x00000080
+#define SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV 0x00000100
+
+#define SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR 0x00000200
+#define SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS 0x00000400
+
+#define SYS_SPECIFIC_DATA_SET(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData |= (flag)))
+
+#define SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData &= ~(flag)))
+
+#define SYS_SPECIFIC_DATA_TEST(psSysSpecData, flag) (((psSysSpecData)->ui32SysSpecificData & (flag)) != 0)
+
+typedef struct _SYS_SPECIFIC_DATA_TAG_
+{
+ IMG_UINT32 ui32SysSpecificData;
+ PVRSRV_DEVICE_NODE *psSGXDevNode;
+ IMG_BOOL bSGXInitComplete;
+#if !defined(__linux__)
+ IMG_BOOL bSGXClocksEnabled;
+#endif
+ IMG_UINT32 ui32SrcClockDiv;
+#if defined(__linux__)
+ IMG_BOOL bSysClocksOneTimeInit;
+ atomic_t sSGXClocksEnabled;
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+ struct mutex sPowerLock;
+#else
+ IMG_BOOL bConstraintNotificationsEnabled;
+ spinlock_t sPowerLock;
+ atomic_t sPowerLockCPU;
+ spinlock_t sNotifyLock;
+ atomic_t sNotifyLockCPU;
+ IMG_BOOL bCallVDD2PostFunc;
+#endif
+ struct clk *psCORE_CK;
+ struct clk *psSGX_FCK;
+ struct clk *psSGX_ICK;
+ struct clk *psMPU_CK;
+#if defined(DEBUG) || defined(TIMING)
+ struct clk *psGPT11_FCK;
+ struct clk *psGPT11_ICK;
+#endif
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+ struct constraint_handle *pVdd2Handle;
+#endif
+#endif
+} SYS_SPECIFIC_DATA;
+
+extern SYS_SPECIFIC_DATA *gpsSysSpecificData;
+
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+
+
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- * \r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- * \r
- * This program is distributed in the hope it will be useful but, except \r
- * as otherwise stated in writing, without any warranty; without even the \r
- * implied warranty of merchantability or fitness for a particular purpose. \r
- * See the GNU General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- * \r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK \r
- *\r
- ******************************************************************************/\r
-\r
-#if defined(__linux__)\r
-#include "sysutils_linux.c"\r
-#endif\r
-\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if defined(__linux__)
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include "sysutils_linux_wqueue_compat.c"
+#else
+#include "sysutils_linux.c"
+#endif
+#endif
+
-/**********************************************************************\r
- *\r
- * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.\r
- *\r
- * This program is free software; you can redistribute it and/or modify it\r
- * under the terms and conditions of the GNU General Public License,\r
- * version 2, as published by the Free Software Foundation.\r
- *\r
- * This program is distributed in the hope it will be useful but, except\r
- * as otherwise stated in writing, without any warranty; without even the\r
- * implied warranty of merchantability or fitness for a particular purpose.\r
- * See the GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License along with\r
- * this program; if not, write to the Free Software Foundation, Inc.,\r
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.\r
- *\r
- * The full GNU General Public License is included in this distribution in\r
- * the file called "COPYING".\r
- *\r
- * Contact Information:\r
- * Imagination Technologies Ltd. <gpl-support@imgtec.com>\r
- * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK\r
- *\r
- ******************************************************************************/\r
-\r
-#include <linux/version.h>\r
-#include <linux/clk.h>\r
-#include <linux/err.h>\r
-#include <linux/hardirq.h>\r
-#include <linux/spinlock.h>\r
-#include <asm/bug.h>\r
-#include <linux/platform_device.h>\r
-\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,33))\r
-#include <linux/semaphore.h>\r
-#include <asm-generic/resource.h>\r
-#include <plat/omap-pm.h>\r
-#else\r
-\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))\r
-#include <linux/semaphore.h>\r
-#include <plat/resource.h>\r
-#include <plat/omap-pm.h>\r
-#else\r
-\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))\r
-#include <linux/semaphore.h>\r
-#include <mach/resource.h>\r
-#include <mach/omap-pm.h>\r
-#else\r
-#include <asm/semaphore.h>\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))\r
-#include <asm/arch/resource.h>\r
-#endif\r
-#endif\r
-#endif\r
-#endif\r
-\r
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27)) && \\r
- (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,29))\r
-#define CONSTRAINT_NOTIFICATIONS\r
-#endif\r
-#include "sgxdefs.h"\r
-#include "services_headers.h"\r
-#include "sysinfo.h"\r
-#include "sgxapi_km.h"\r
-#include "sysconfig.h"\r
-#include "sgxinfokm.h"\r
-#include "syslocal.h"\r
-void set_vdd2_constraint(void);\r
-void remove_vdd2_constraint(void);\r
-#define ONE_MHZ 1000000\r
-#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)\r
-\r
-#if defined(SUPPORT_OMAP3630_SGXFCLK_96M)\r
-#define SGX_PARENT_CLOCK "cm_96m_fck"\r
-#elif defined(SUPPORT_OMAP3630_SGXFCLK_192M)\r
-#define SGX_PARENT_CLOCK "omap_192m_alwon_ck"\r
-#elif defined(SUPPORT_OMAP3630_SGXFCLK_corex2)\r
-#define SGX_PARENT_CLOCK "corex2_fck"\r
-#else\r
-#define SGX_PARENT_CLOCK "core_ck"\r
-#endif\r
-\r
-#if !defined(PDUMP) && !defined(NO_HARDWARE)\r
-struct sgx_platform_data {\r
- void(*set_min_bus_tput)(struct device *dev, u8 agent_id, unsigned long r);\r
-};\r
-\r
-static struct sgx_platform_data pdata = {\r
-\r
- //.set_min_bus_tput = &omap_pm_set_min_bus_tput,\r
- .set_min_bus_tput = NULL,\r
-};\r
-\r
-static struct platform_device sgx_dev = {\r
- .name = "sgx_dev",\r
- .id = 1,\r
- .dev.platform_data = &pdata,\r
-};\r
-void set_vdd2_constraint(void)\r
-{\r
- if(pdata.set_min_bus_tput){\r
- pdata.set_min_bus_tput(&(sgx_dev.dev), OCP_INITIATOR_AGENT,800000);\r
- }\r
-}\r
-\r
-void remove_vdd2_constraint(void)\r
-{\r
- if(pdata.set_min_bus_tput)\r
- pdata.set_min_bus_tput(&(sgx_dev.dev), OCP_INITIATOR_AGENT, 0);\r
-\r
-}\r
-#endif\r
-#if !defined(PDUMP) && !defined(NO_HARDWARE)\r
-static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- IMG_INT iCPU;\r
- IMG_BOOL bLocked = IMG_FALSE;\r
-\r
- if (!in_interrupt())\r
- {\r
- iCPU = get_cpu();\r
- bLocked = (iCPU == atomic_read(&psSysSpecData->sPowerLockCPU));\r
-\r
- put_cpu();\r
- }\r
-\r
- return bLocked;\r
-}\r
-\r
-static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- IMG_INT iCPU;\r
-\r
- if (!in_interrupt())\r
- {\r
-\r
- iCPU = get_cpu();\r
-\r
-\r
- PVR_ASSERT(iCPU != -1);\r
-\r
- PVR_ASSERT(!PowerLockWrappedOnCPU(psSysSpecData));\r
-\r
- spin_lock(&psSysSpecData->sPowerLock);\r
-\r
- atomic_set(&psSysSpecData->sPowerLockCPU, iCPU);\r
- }\r
-}\r
-\r
-static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- if (!in_interrupt())\r
- {\r
- PVR_ASSERT(PowerLockWrappedOnCPU(psSysSpecData));\r
-\r
- atomic_set(&psSysSpecData->sPowerLockCPU, -1);\r
-\r
- spin_unlock(&psSysSpecData->sPowerLock);\r
-\r
- put_cpu();\r
- }\r
-}\r
-\r
-PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)\r
-{\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
-\r
- PowerLockWrap(psSysSpecData);\r
-\r
- return PVRSRV_OK;\r
-}\r
-\r
-IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)\r
-{\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
-\r
- PowerLockUnwrap(psSysSpecData);\r
-}\r
-#else\r
-static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA unref__ *psSysSpecData)\r
-{\r
- return IMG_FALSE;\r
-}\r
-\r
-static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)\r
-{\r
-}\r
-\r
-static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)\r
-{\r
-}\r
-\r
-PVRSRV_ERROR SysPowerLockWrap(SYS_DATA unref__ *psSysData)\r
-{\r
- return PVRSRV_OK;\r
-}\r
-\r
-IMG_VOID SysPowerLockUnwrap(SYS_DATA unref__ *psSysData)\r
-{\r
-}\r
-#endif\r
-\r
-IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- IMG_BOOL bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);\r
-\r
- if (bPowerLock)\r
- {\r
- PowerLockUnwrap(psSysSpecData);\r
- }\r
-\r
- return bPowerLock;\r
-}\r
-\r
-IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- PowerLockWrap(psSysSpecData);\r
-}\r
-\r
-static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)\r
-{\r
- if (rate1 >= rate2)\r
- {\r
- return val * (rate1 / rate2);\r
- }\r
-\r
- return val / (rate2 / rate1);\r
-}\r
-\r
-static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)\r
-{\r
- return scale_by_rate(val, rate, SYS_SGX_CLOCK_SPEED);\r
-}\r
-\r
-static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)\r
-{\r
- return scale_by_rate(val, SYS_SGX_CLOCK_SPEED, rate);\r
-}\r
-\r
-IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)\r
-{\r
- IMG_UINT32 rate;\r
-\r
-#if defined(NO_HARDWARE)\r
- rate = SYS_SGX_CLOCK_SPEED;\r
-#else\r
- PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);\r
-\r
- rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);\r
- PVR_ASSERT(rate != 0);\r
-#endif\r
- psTimingInfo->ui32CoreClockSpeed = rate;\r
- psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);\r
- psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);\r
- psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;\r
-}\r
-\r
-#if defined(CONSTRAINT_NOTIFICATIONS)\r
-#if !defined(SGX_DYNAMIC_TIMING_INFO)\r
-#error "SGX_DYNAMIC_TIMING_INFO must be defined for this platform"\r
-#endif\r
-\r
-#if !defined(PDUMP) && !defined(NO_HARDWARE)\r
-static inline IMG_BOOL ConstraintNotificationsEnabled(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- return (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0) && psSysSpecData->bSGXInitComplete && psSysSpecData->bConstraintNotificationsEnabled;\r
-\r
-}\r
-\r
-static IMG_BOOL NotifyLockedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- IMG_INT iCPU = get_cpu();\r
- IMG_BOOL bLocked = (iCPU == atomic_read(&psSysSpecData->sNotifyLockCPU));\r
-\r
- put_cpu();\r
-\r
- return bLocked;\r
-}\r
-\r
-static IMG_VOID NotifyLock(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- IMG_INT iCPU;\r
-\r
- BUG_ON(in_interrupt());\r
-\r
-\r
- iCPU = get_cpu();\r
-\r
-\r
- PVR_ASSERT(iCPU != -1);\r
-\r
- PVR_ASSERT(!NotifyLockedOnCPU(psSysSpecData));\r
-\r
- spin_lock(&psSysSpecData->sNotifyLock);\r
-\r
- atomic_set(&psSysSpecData->sNotifyLockCPU, iCPU);\r
-\r
-}\r
-\r
-static IMG_VOID NotifyUnlock(SYS_SPECIFIC_DATA *psSysSpecData)\r
-{\r
- PVR_ASSERT(NotifyLockedOnCPU(psSysSpecData));\r
-\r
- atomic_set(&psSysSpecData->sNotifyLockCPU, -1);\r
-\r
- spin_unlock(&psSysSpecData->sNotifyLock);\r
-\r
- put_cpu();\r
-}\r
-\r
-static IMG_INT VDD2PostFunc(struct notifier_block *n, IMG_UINT32 event, IMG_VOID *ptr)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(n);\r
- PVR_UNREFERENCED_PARAMETER(event);\r
- PVR_UNREFERENCED_PARAMETER(ptr);\r
-\r
- if (in_interrupt())\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "%s Called in interrupt context. Ignoring.", __FUNCTION__));\r
- return 0;\r
- }\r
-\r
-\r
- if (!NotifyLockedOnCPU(gpsSysSpecificData))\r
- {\r
- return 0;\r
- }\r
-\r
-#if defined(DEBUG)\r
- if (ConstraintNotificationsEnabled(gpsSysSpecificData))\r
- {\r
- IMG_UINT32 rate;\r
-\r
- rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);\r
-\r
- PVR_ASSERT(rate != 0);\r
-\r
- PVR_DPF((PVR_DBG_MESSAGE, "%s: SGX clock rate: %dMHz", __FUNCTION__, HZ_TO_MHZ(rate)));\r
- }\r
-#endif\r
- if (gpsSysSpecificData->bCallVDD2PostFunc)\r
- {\r
- PVRSRVDevicePostClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);\r
-\r
- gpsSysSpecificData->bCallVDD2PostFunc = IMG_FALSE;\r
- }\r
- else\r
- {\r
- if (ConstraintNotificationsEnabled(gpsSysSpecificData))\r
- {\r
- PVR_TRACE(("%s: Not calling PVR clock speed notification functions", __FUNCTION__));\r
- }\r
- }\r
-\r
- NotifyUnlock(gpsSysSpecificData);\r
-\r
- return 0;\r
-}\r
-\r
-static IMG_INT VDD2PreFunc(struct notifier_block *n, IMG_UINT32 event, IMG_VOID *ptr)\r
-{\r
- PVR_UNREFERENCED_PARAMETER(n);\r
- PVR_UNREFERENCED_PARAMETER(event);\r
- PVR_UNREFERENCED_PARAMETER(ptr);\r
-\r
- if (in_interrupt())\r
- {\r
- PVR_DPF((PVR_DBG_WARNING, "%s Called in interrupt context. Ignoring.", __FUNCTION__));\r
- return 0;\r
- }\r
-\r
- if (PowerLockWrappedOnCPU(gpsSysSpecificData))\r
- {\r
- PVR_DPF((PVR_DBG_WARNING, "%s Called from within a power transition. Ignoring.", __FUNCTION__));\r
- return 0;\r
- }\r
-\r
- NotifyLock(gpsSysSpecificData);\r
-\r
- PVR_ASSERT(!gpsSysSpecificData->bCallVDD2PostFunc);\r
-\r
- if (ConstraintNotificationsEnabled(gpsSysSpecificData))\r
- {\r
- PVRSRV_ERROR eError;\r
-\r
- eError = PVRSRVDevicePreClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);\r
-\r
- gpsSysSpecificData->bCallVDD2PostFunc = (eError == PVRSRV_OK);\r
-\r
- }\r
-\r
- return 0;\r
-}\r
-static IMG_VOID RegisterConstraintNotifications(IMG_VOID)\r
-{\r
- PVR_TRACE(("Registering constraint notifications"));\r
-\r
- PVR_ASSERT(!gpsSysSpecificData->bConstraintNotificationsEnabled);\r
-\r
-\r
- NotifyLock(gpsSysSpecificData);\r
- gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_TRUE;\r
- NotifyUnlock(gpsSysSpecificData);\r
-\r
- PVR_TRACE(("VDD2 constraint notifications registered"));\r
-}\r
-\r
-static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)\r
-{\r
- PVR_TRACE(("Unregistering constraint notifications"));\r
-\r
-\r
- NotifyLock(gpsSysSpecificData);\r
- gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_FALSE;\r
- NotifyUnlock(gpsSysSpecificData);\r
-\r
-}\r
-#else\r
-static IMG_VOID RegisterConstraintNotifications(IMG_VOID)\r
-{\r
-}\r
-\r
-static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)\r
-{\r
-}\r
-#endif\r
-#endif\r
-\r
-PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)\r
-{\r
-#if !defined(NO_HARDWARE)\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
- long lNewRate;\r
- IMG_INT res;\r
-\r
-\r
- if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)\r
- {\r
- return PVRSRV_OK;\r
- }\r
-\r
- PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));\r
-\r
-#if defined(DEBUG)\r
- {\r
-\r
- IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);\r
- PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));\r
- }\r
-#endif\r
-\r
- res = clk_enable(psSysSpecData->psSGX_FCK);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));\r
- return PVRSRV_ERROR_GENERIC;\r
- }\r
-\r
- res = clk_enable(psSysSpecData->psSGX_ICK);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));\r
-\r
- clk_disable(psSysSpecData->psSGX_FCK);\r
- return PVRSRV_ERROR_GENERIC;\r
- }\r
-\r
- lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);\r
- //PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: New SGX Func Clk = (%d)", lNewRate));\r
- if (lNewRate <= 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));\r
- return PVRSRV_ERROR_GENERIC;\r
- }\r
-\r
- res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't set SGX function clock rate (%d)", res));\r
- return PVRSRV_ERROR_GENERIC;\r
- }\r
-\r
-\r
-#if defined(DEBUG)\r
- {\r
-\r
- IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);\r
- PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));\r
- }\r
-#endif\r
-\r
- set_vdd2_constraint();\r
-\r
- lNewRate = clk_get_rate(psSysSpecData->psSGX_FCK);\r
- atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);\r
- //PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Final SGX Func Clk = (%d)", lNewRate));\r
-\r
-#else\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
-#endif\r
- return PVRSRV_OK;\r
-}\r
-\r
-\r
-IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)\r
-{\r
-#if !defined(NO_HARDWARE)\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
-\r
- if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)\r
- {\r
- return;\r
- }\r
-\r
- PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));\r
-\r
- if (psSysSpecData->psSGX_ICK)\r
- {\r
- clk_disable(psSysSpecData->psSGX_ICK);\r
- }\r
-\r
- if (psSysSpecData->psSGX_FCK)\r
- {\r
- clk_disable(psSysSpecData->psSGX_FCK);\r
- }\r
-\r
- remove_vdd2_constraint();\r
-\r
- atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);\r
-\r
-#else\r
- PVR_UNREFERENCED_PARAMETER(psSysData);\r
-#endif\r
-}\r
-\r
-PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)\r
-{\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
- struct clk *psCLK;\r
- IMG_INT res;\r
- PVRSRV_ERROR eError;\r
- IMG_BOOL bPowerLock;\r
-\r
-#if defined(DEBUG) || defined(TIMING)\r
- IMG_INT rate;\r
- struct clk *sys_ck;\r
- IMG_CPU_PHYADDR TimerRegPhysBase;\r
- IMG_HANDLE hTimerEnable;\r
- IMG_UINT32 *pui32TimerEnable;\r
-\r
-#endif\r
-\r
- PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));\r
-\r
- if (!psSysSpecData->bSysClocksOneTimeInit)\r
- {\r
- bPowerLock = IMG_FALSE;\r
-\r
- spin_lock_init(&psSysSpecData->sPowerLock);\r
- atomic_set(&psSysSpecData->sPowerLockCPU, -1);\r
- spin_lock_init(&psSysSpecData->sNotifyLock);\r
- atomic_set(&psSysSpecData->sNotifyLockCPU, -1);\r
-\r
- atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);\r
-\r
- psCLK = clk_get(NULL, SGX_PARENT_CLOCK);\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));\r
- goto ExitError;\r
- }\r
- psSysSpecData->psCORE_CK = psCLK;\r
-\r
- psCLK = clk_get(NULL, "sgx_fck");\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));\r
- goto ExitError;\r
- }\r
- psSysSpecData->psSGX_FCK = psCLK;\r
-\r
- psCLK = clk_get(NULL, "sgx_ick");\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));\r
- goto ExitError;\r
- }\r
- psSysSpecData->psSGX_ICK = psCLK;\r
-\r
-#if defined(DEBUG)\r
- psCLK = clk_get(NULL, "mpu_ck");\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));\r
- goto ExitError;\r
- }\r
- psSysSpecData->psMPU_CK = psCLK;\r
-#endif\r
- res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));\r
- goto ExitError;\r
- }\r
-\r
- psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;\r
- }\r
- else\r
- {\r
-\r
- bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);\r
- if (bPowerLock)\r
- {\r
- PowerLockUnwrap(psSysSpecData);\r
- }\r
- }\r
-\r
-#if defined(CONSTRAINT_NOTIFICATIONS)\r
-\r
- RegisterConstraintNotifications();\r
-#endif\r
-\r
-#if defined(DEBUG) || defined(TIMING)\r
-\r
- psCLK = clk_get(NULL, "gpt11_fck");\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));\r
- goto ExitUnRegisterConstraintNotifications;\r
- }\r
- psSysSpecData->psGPT11_FCK = psCLK;\r
-\r
- psCLK = clk_get(NULL, "gpt11_ick");\r
- if (IS_ERR(psCLK))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));\r
- goto ExitUnRegisterConstraintNotifications;\r
- }\r
- psSysSpecData->psGPT11_ICK = psCLK;\r
-\r
- sys_ck = clk_get(NULL, "sys_ck");\r
- if (IS_ERR(sys_ck))\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));\r
- goto ExitUnRegisterConstraintNotifications;\r
- }\r
-\r
- if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)\r
- {\r
- PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));\r
- res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));\r
- goto ExitUnRegisterConstraintNotifications;\r
- }\r
- }\r
-\r
- rate = clk_get_rate(psSysSpecData->psGPT11_FCK);\r
- PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));\r
-\r
- res = clk_enable(psSysSpecData->psGPT11_FCK);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));\r
- goto ExitUnRegisterConstraintNotifications;\r
- }\r
-\r
- res = clk_enable(psSysSpecData->psGPT11_ICK);\r
- if (res < 0)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));\r
- goto ExitDisableGPT11FCK;\r
- }\r
-\r
-\r
- TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE;\r
- pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- &hTimerEnable);\r
-\r
- if (pui32TimerEnable == IMG_NULL)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));\r
- goto ExitDisableGPT11ICK;\r
- }\r
-\r
- rate = *pui32TimerEnable;\r
- if(!(rate & 4))\r
- {\r
- PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));\r
-\r
-\r
- *pui32TimerEnable = rate | 4;\r
- }\r
-\r
- OSUnMapPhysToLin(pui32TimerEnable,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- hTimerEnable);\r
-\r
-\r
- TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;\r
- pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- &hTimerEnable);\r
-\r
- if (pui32TimerEnable == IMG_NULL)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));\r
- goto ExitDisableGPT11ICK;\r
- }\r
-\r
-\r
- *pui32TimerEnable = 3;\r
-\r
- OSUnMapPhysToLin(pui32TimerEnable,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- hTimerEnable);\r
-\r
-#endif\r
-\r
- eError = PVRSRV_OK;\r
- goto Exit;\r
-\r
-#if defined(DEBUG) || defined(TIMING)\r
-ExitDisableGPT11ICK:\r
- clk_disable(psSysSpecData->psGPT11_ICK);\r
-ExitDisableGPT11FCK:\r
- clk_disable(psSysSpecData->psGPT11_FCK);\r
-ExitUnRegisterConstraintNotifications:\r
-#endif\r
-#if defined(CONSTRAINT_NOTIFICATIONS)\r
- UnRegisterConstraintNotifications();\r
-\r
-#endif\r
-ExitError:\r
- eError = PVRSRV_ERROR_GENERIC;\r
-Exit:\r
- if (bPowerLock)\r
- {\r
- PowerLockWrap(psSysSpecData);\r
- }\r
-\r
-#if !defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)\r
- if (eError == PVRSRV_OK)\r
- {\r
-\r
- eError = EnableSGXClocks(psSysData);\r
- }\r
-#endif\r
- return eError;\r
-}\r
-\r
-IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)\r
-{\r
- SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;\r
- IMG_BOOL bPowerLock;\r
-#if defined(DEBUG) || defined(TIMING)\r
- IMG_CPU_PHYADDR TimerRegPhysBase;\r
- IMG_HANDLE hTimerDisable;\r
- IMG_UINT32 *pui32TimerDisable;\r
-#endif\r
-\r
- PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));\r
-\r
- DisableSGXClocks(psSysData);\r
-\r
- bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);\r
- if (bPowerLock)\r
- {\r
-\r
- PowerLockUnwrap(psSysSpecData);\r
- }\r
-\r
-#if defined(CONSTRAINT_NOTIFICATIONS)\r
- UnRegisterConstraintNotifications();\r
-#endif\r
-\r
-#if defined(DEBUG) || defined(TIMING)\r
-\r
- TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;\r
- pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- &hTimerDisable);\r
-\r
- if (pui32TimerDisable == IMG_NULL)\r
- {\r
- PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));\r
- }\r
- else\r
- {\r
- *pui32TimerDisable = 0;\r
-\r
- OSUnMapPhysToLin(pui32TimerDisable,\r
- 4,\r
- PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,\r
- hTimerDisable);\r
- }\r
-\r
- clk_disable(psSysSpecData->psGPT11_ICK);\r
-\r
- clk_disable(psSysSpecData->psGPT11_FCK);\r
-\r
-#endif\r
- if (bPowerLock)\r
- {\r
- PowerLockWrap(psSysSpecData);\r
- }\r
-}\r
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/spinlock.h>
+#include <asm/bug.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#include <linux/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
+#include <plat/resource.h>
+#else
+#include <mach/resource.h>
+#endif
+#else
+#include <asm/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+#include <asm/arch/resource.h>
+#endif
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)) && \
+ (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
+#define CONSTRAINT_NOTIFICATIONS
+#endif
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+#if !defined(PDUMP) && !defined(NO_HARDWARE)
+static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+ IMG_BOOL bLocked = IMG_FALSE;
+
+ if (!in_interrupt())
+ {
+ iCPU = get_cpu();
+ bLocked = (iCPU == atomic_read(&psSysSpecData->sPowerLockCPU));
+
+ put_cpu();
+ }
+
+ return bLocked;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+
+ if (!in_interrupt())
+ {
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!PowerLockWrappedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sPowerLockCPU, iCPU);
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ PVR_ASSERT(PowerLockWrappedOnCPU(psSysSpecData));
+
+ atomic_set(&psSysSpecData->sPowerLockCPU, -1);
+
+ spin_unlock(&psSysSpecData->sPowerLock);
+
+ put_cpu();
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+#else
+static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+ return IMG_FALSE;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA unref__ *psSysData)
+{
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA unref__ *psSysData)
+{
+}
+#endif
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_BOOL bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+
+ if (bPowerLock)
+ {
+ PowerLockUnwrap(psSysSpecData);
+ }
+
+ return bPowerLock;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ PowerLockWrap(psSysSpecData);
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, rate, SYS_SGX_CLOCK_SPEED);
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, SYS_SGX_CLOCK_SPEED, rate);
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ rate = SYS_SGX_CLOCK_SPEED;
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+#error "SGX_DYNAMIC_TIMING_INFO must be defined for this platform"
+#endif
+
+static struct constraint_id cnstr_id_vdd2 = {
+ .type = RES_OPP_CO,
+ .data = (IMG_VOID *)"vdd2_opp"
+};
+
+#if !defined(PDUMP) && !defined(NO_HARDWARE)
+static inline IMG_BOOL ConstraintNotificationsEnabled(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0) && psSysSpecData->bSGXInitComplete && psSysSpecData->bConstraintNotificationsEnabled;
+
+}
+
+static IMG_BOOL NotifyLockedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU = get_cpu();
+ IMG_BOOL bLocked = (iCPU == atomic_read(&psSysSpecData->sNotifyLockCPU));
+
+ put_cpu();
+
+ return bLocked;
+}
+
+static IMG_VOID NotifyLock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+
+ BUG_ON(in_interrupt());
+
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!NotifyLockedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sNotifyLock);
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, iCPU);
+}
+
+static IMG_VOID NotifyUnlock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ PVR_ASSERT(NotifyLockedOnCPU(psSysSpecData));
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
+
+ spin_unlock(&psSysSpecData->sNotifyLock);
+
+ put_cpu();
+}
+
+static int VDD2PostFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+
+ if (!NotifyLockedOnCPU(gpsSysSpecificData))
+ {
+ return 0;
+ }
+
+#if defined(DEBUG)
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ IMG_UINT32 rate;
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+
+ PVR_ASSERT(rate != 0);
+
+ PVR_DPF((PVR_DBG_MESSAGE, "%s: SGX clock rate: %dMHz", __FUNCTION__, HZ_TO_MHZ(rate)));
+ }
+#endif
+ if (gpsSysSpecificData->bCallVDD2PostFunc)
+ {
+ PVRSRVDevicePostClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = IMG_FALSE;
+ }
+ else
+ {
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVR_TRACE(("%s: Not calling PVR clock speed notification functions", __FUNCTION__));
+ }
+ }
+
+ NotifyUnlock(gpsSysSpecificData);
+
+ return 0;
+}
+
+static int VDD2PreFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ if (PowerLockWrappedOnCPU(gpsSysSpecificData))
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called from within a power transition. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ NotifyLock(gpsSysSpecificData);
+
+ PVR_ASSERT(!gpsSysSpecificData->bCallVDD2PostFunc);
+
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVRSRV_ERROR eError;
+
+ eError = PVRSRVDevicePreClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = (eError == PVRSRV_OK);
+
+ }
+
+ return 0;
+}
+
+static struct notifier_block sVDD2Pre = {
+ VDD2PreFunc,
+ NULL
+};
+
+static struct notifier_block sVDD2Post = {
+ VDD2PostFunc,
+ NULL
+};
+
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Registering constraint notifications"));
+
+ PVR_ASSERT(!gpsSysSpecificData->bConstraintNotificationsEnabled);
+
+ constraint_register_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_register_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_TRUE;
+ NotifyUnlock(gpsSysSpecificData);
+
+ PVR_TRACE(("VDD2 constraint notifications registered"));
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Unregistering constraint notifications"));
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_FALSE;
+ NotifyUnlock(gpsSysSpecificData);
+
+
+ constraint_unregister_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_unregister_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+}
+#else
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+}
+#endif
+#endif
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+#if defined(DEBUG)
+ {
+
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ res = clk_enable(psSysSpecData->psSGX_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
+
+ clk_disable(psSysSpecData->psSGX_FCK);
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+ if (psSysSpecData->psSGX_ICK)
+ {
+ clk_disable(psSysSpecData->psSGX_ICK);
+ }
+
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ PVRSRV_ERROR eError;
+ IMG_BOOL bPowerLock;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ bPowerLock = IMG_FALSE;
+
+ spin_lock_init(&psSysSpecData->sPowerLock);
+ atomic_set(&psSysSpecData->sPowerLockCPU, -1);
+ spin_lock_init(&psSysSpecData->sNotifyLock);
+ atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ psCLK = clk_get(NULL, SGX_PARENT_CLOCK);
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psCORE_CK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_ICK = psCLK;
+
+#if defined(DEBUG)
+ psCLK = clk_get(NULL, "mpu_ck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psMPU_CK = psCLK;
+#endif
+ res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
+ goto ExitError;
+ }
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+ else
+ {
+
+ bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+ if (bPowerLock)
+ {
+ PowerLockUnwrap(psSysSpecData);
+ }
+ }
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ psSysSpecData->pVdd2Handle = constraint_get(PVRSRV_MODNAME, &cnstr_id_vdd2);
+ if (IS_ERR(psSysSpecData->pVdd2Handle))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get VDD2 constraint handle"));
+ goto ExitError;
+ }
+
+ RegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+
+ psCLK = clk_get(NULL, "gpt11_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "gpt11_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+
+ sys_ck = clk_get(NULL, "sys_ck");
+ if (IS_ERR(sys_ck))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)
+ {
+ PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));
+ res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ }
+
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ PVR_TRACE(("EnableSystemClocks: Setting SGX OPP constraint"));
+
+
+ res = constraint_set(psSysSpecData->pVdd2Handle, max_vdd2_opp);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: constraint_set failed (%d)", res));
+ goto ExitConstraintSetFailed;
+ }
+#endif
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ExitConstraintSetFailed:
+#endif
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+Exit:
+ if (bPowerLock)
+ {
+ PowerLockWrap(psSysSpecData);
+ }
+
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_BOOL bPowerLock;
+#if defined(DEBUG) || defined(TIMING)
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+ bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+ if (bPowerLock)
+ {
+
+ PowerLockUnwrap(psSysSpecData);
+ }
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ {
+ int res;
+
+ PVR_TRACE(("DisableSystemClocks: Removing SGX OPP constraint"));
+
+
+ res = constraint_remove(psSysSpecData->pVdd2Handle);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "DisableSystemClocks: constraint_remove failed (%d)", res));
+ }
+ }
+#endif
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
+ if (bPowerLock)
+ {
+ PowerLockWrap(psSysSpecData);
+ }
+}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/mutex.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#if !defined(PVR_LINUX_USING_WORKQUEUES)
+#error "PVR_LINUX_USING_WORKQUEUES must be defined"
+#endif
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_lock(&psSysSpecData->sPowerLock);
+
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_unlock(&psSysSpecData->sPowerLock);
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return IMG_TRUE;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, rate, SYS_SGX_CLOCK_SPEED);
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, SYS_SGX_CLOCK_SPEED, rate);
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ rate = SYS_SGX_CLOCK_SPEED;
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+#if defined(DEBUG)
+ {
+
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ res = clk_enable(psSysSpecData->psSGX_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
+
+ clk_disable(psSysSpecData->psSGX_FCK);
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+ if (psSysSpecData->psSGX_ICK)
+ {
+ clk_disable(psSysSpecData->psSGX_ICK);
+ }
+
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ PVRSRV_ERROR eError;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ mutex_init(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ psCLK = clk_get(NULL, SGX_PARENT_CLOCK);
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psCORE_CK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_ICK = psCLK;
+
+#if defined(DEBUG)
+ psCLK = clk_get(NULL, "mpu_ck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psMPU_CK = psCLK;
+#endif
+ res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
+ goto ExitError;
+ }
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+
+#if defined(DEBUG) || defined(TIMING)
+
+ psCLK = clk_get(NULL, "gpt11_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "gpt11_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+
+ sys_ck = clk_get(NULL, "sys_ck");
+ if (IS_ERR(sys_ck))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)
+ {
+ PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));
+ res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ }
+
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+Exit:
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+#if defined(DEBUG) || defined(TIMING)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_OMAP3430_GP11TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__OEMFUNCS_H__)
+#define __OEMFUNCS_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef IMG_UINT32 (*PFN_SRV_BRIDGEDISPATCH)( IMG_UINT32 Ioctl,
+ IMG_BYTE *pInBuf,
+ IMG_UINT32 InBufLen,
+ IMG_BYTE *pOutBuf,
+ IMG_UINT32 OutBufLen,
+ IMG_UINT32 *pdwBytesTransferred);
+typedef struct PVRSRV_DC_OEM_JTABLE_TAG
+{
+ PFN_SRV_BRIDGEDISPATCH pfnOEMBridgeDispatch;
+ IMG_PVOID pvDummy1;
+ IMG_PVOID pvDummy2;
+ IMG_PVOID pvDummy3;
+
+} PVRSRV_DC_OEM_JTABLE;
+
+#define OEM_GET_EXT_FUNCS (1<<1)
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include "services_headers.h"
+#include "kerneldisplay.h"
+#include "oemfuncs.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+#include "sysconfig.h"
+
+#include "ocpdefs.h"
+
+#if !defined(NO_HARDWARE) && \
+ defined(SYS_USING_INTERRUPTS) && \
+ defined(SGX530) && (SGX_CORE_REV == 125)
+#define SGX_OCP_REGS_ENABLED
+#endif
+
+SYS_DATA* gpsSysData = (SYS_DATA*)IMG_NULL;
+SYS_DATA gsSysData;
+
+static SYS_SPECIFIC_DATA gsSysSpecificData;
+SYS_SPECIFIC_DATA *gpsSysSpecificData;
+
+static IMG_UINT32 gui32SGXDeviceID;
+static SGX_DEVICE_MAP gsSGXDeviceMap;
+static PVRSRV_DEVICE_NODE *gpsSGXDevNode;
+
+#define DEVICE_SGX_INTERRUPT (1 << 0)
+
+#if defined(NO_HARDWARE)
+static IMG_CPU_VIRTADDR gsSGXRegsCPUVAddr;
+#endif
+
+IMG_UINT32 PVRSRV_BridgeDispatchKM(IMG_UINT32 Ioctl,
+ IMG_BYTE *pInBuf,
+ IMG_UINT32 InBufLen,
+ IMG_BYTE *pOutBuf,
+ IMG_UINT32 OutBufLen,
+ IMG_UINT32 *pdwBytesTransferred);
+
+#if defined(DEBUG) && defined(DUMP_OMAP34xx_CLOCKS) && defined(__linux__)
+
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+#include <mach/clock.h>
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
+#include <../mach-omap2/clock_34xx.h>
+#define ONCHIP_CLKS onchip_clks
+#else
+#include <../mach-omap2/clock34xx.h>
+#define ONCHIP_CLKS onchip_34xx_clks
+#endif
+
+static void omap3_clk_recalc(struct clk *clk) {}
+static void omap3_followparent_recalc(struct clk *clk) {}
+static void omap3_propagate_rate(struct clk *clk) {}
+static void omap3_table_recalc(struct clk *clk) {}
+static long omap3_round_to_table_rate(struct clk *clk, unsigned long rate) { return 0; }
+static int omap3_select_table_rate(struct clk *clk, unsigned long rate) { return 0; }
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+static void omap3_dpll_recalc(struct clk *clk, unsigned long parent_rate,
+ u8 rate_storage) {}
+static void omap3_clkoutx2_recalc(struct clk *clk, unsigned long parent_rate,
+ u8 rate_storage) {}
+static void omap3_dpll_allow_idle(struct clk *clk) {}
+static void omap3_dpll_deny_idle(struct clk *clk) {}
+static u32 omap3_dpll_autoidle_read(struct clk *clk) { return 0; }
+static int omap3_noncore_dpll_enable(struct clk *clk) { return 0; }
+static void omap3_noncore_dpll_disable(struct clk *clk) {}
+static int omap3_noncore_dpll_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+static int omap3_core_dpll_m2_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+void followparent_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+long omap2_dpll_round_rate(struct clk *clk, unsigned long target_rate) { return 0; }
+void omap2_clksel_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+long omap2_clksel_round_rate(struct clk *clk, unsigned long target_rate) { return 0; }
+int omap2_clksel_set_rate(struct clk *clk, unsigned long rate) { return 0; }
+void omap2_fixed_divisor_recalc(struct clk *clk, unsigned long new_parent_rate,
+ u8 rate_storage) {}
+void omap2_init_clksel_parent(struct clk *clk) {}
+#endif
+
+static void dump_omap34xx_clocks(void)
+{
+ struct clk **c;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
+ struct vdd_prcm_config *t1 = vdd1_rate_table;
+ struct vdd_prcm_config *t2 = vdd2_rate_table;
+
+ t1 = t1;
+ t2 = t2;
+#else
+
+ omap3_dpll_allow_idle(0);
+ omap3_dpll_deny_idle(0);
+ omap3_dpll_autoidle_read(0);
+ omap3_clk_recalc(0);
+ omap3_followparent_recalc(0);
+ omap3_propagate_rate(0);
+ omap3_table_recalc(0);
+ omap3_round_to_table_rate(0, 0);
+ omap3_select_table_rate(0, 0);
+#endif
+
+ for(c = ONCHIP_CLKS; c < ONCHIP_CLKS + ARRAY_SIZE(ONCHIP_CLKS); c++)
+ {
+ struct clk *cp = *c, *copy;
+ unsigned long rate;
+ copy = clk_get(NULL, cp->name);
+ if(!copy)
+ continue;
+ rate = clk_get_rate(copy);
+ if (rate < 1000000)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: clock %s is %lu KHz (%lu Hz)", __func__, cp->name, rate/1000, rate));
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s: clock %s is %lu MHz (%lu Hz)", __func__, cp->name, rate/1000000, rate));
+ }
+ }
+}
+
+#else
+
+static INLINE void dump_omap34xx_clocks(void) {}
+
+#endif
+
+#if defined(SGX_OCP_REGS_ENABLED)
+
+#define SYS_TI81xx_OCP_REGS_SYS_PHYS_BASE (SYS_TI81xx_SGX_REGS_SYS_PHYS_BASE + EUR_CR_OCP_REVISION)
+#define SYS_TI81xx_OCP_REGS_SIZE 0x110
+
+static IMG_CPU_VIRTADDR gpvOCPRegsLinAddr;
+
+static PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError = EnableSGXClocks(psSysData);
+
+ if(eError == PVRSRV_OK)
+ {
+ OSWriteHWReg(gpvOCPRegsLinAddr,
+ EUR_CR_OCP_DEBUG_CONFIG - EUR_CR_OCP_REVISION,
+ EUR_CR_OCP_DEBUG_CONFIG_THALIA_INT_BYPASS_MASK);
+ }
+
+ return eError;
+}
+
+#else
+
+static INLINE PVRSRV_ERROR EnableSGXClocksWrap(SYS_DATA *psSysData)
+{
+ return EnableSGXClocks(psSysData);
+}
+
+#endif
+
+static INLINE PVRSRV_ERROR EnableSystemClocksWrap(SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError = EnableSystemClocks(psSysData);
+
+#if !defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if(eError == PVRSRV_OK)
+ {
+
+ EnableSGXClocksWrap(psSysData);
+ }
+#endif
+
+ return eError;
+}
+
+static PVRSRV_ERROR SysLocateDevices(SYS_DATA *psSysData)
+{
+#if defined(NO_HARDWARE)
+ PVRSRV_ERROR eError;
+ IMG_CPU_PHYADDR sCpuPAddr;
+#endif
+
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+
+
+ gsSGXDeviceMap.ui32Flags = 0x0;
+
+#if defined(NO_HARDWARE)
+
+
+ eError = OSBaseAllocContigMemory(SYS_TI81xx_SGX_REGS_SIZE,
+ &gsSGXRegsCPUVAddr,
+ &sCpuPAddr);
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+ gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
+ gsSGXDeviceMap.sRegsSysPBase = SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);
+ gsSGXDeviceMap.ui32RegsSize = SYS_TI81xx_SGX_REGS_SIZE;
+#if defined(__linux__)
+
+ gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
+#else
+
+ gsSGXDeviceMap.pvRegsCpuVBase = IMG_NULL;
+#endif
+
+ OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_TI81xx_SGX_REGS_SIZE);
+
+
+
+
+ gsSGXDeviceMap.ui32IRQ = 0;
+
+#else
+
+ gsSGXDeviceMap.sRegsSysPBase.uiAddr = SYS_TI81xx_SGX_REGS_SYS_PHYS_BASE;
+ gsSGXDeviceMap.sRegsCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);
+ gsSGXDeviceMap.ui32RegsSize = SYS_TI81xx_SGX_REGS_SIZE;
+
+ gsSGXDeviceMap.ui32IRQ = SYS_TI81xx_SGX_IRQ;
+
+#endif
+
+#if defined(PDUMP)
+ {
+
+ static IMG_CHAR pszPDumpDevName[] = "SGXMEM";
+ gsSGXDeviceMap.pszPDumpDevName = pszPDumpDevName;
+ }
+#endif
+
+
+
+
+ return PVRSRV_OK;
+}
+
+
+IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion)
+{
+ static IMG_CHAR aszVersionString[100];
+ SYS_DATA *psSysData;
+ IMG_UINT32 ui32SGXRevision;
+ IMG_INT32 i32Count;
+#if !defined(NO_HARDWARE)
+ IMG_VOID *pvRegsLinAddr;
+
+ pvRegsLinAddr = OSMapPhysToLin(sRegRegion,
+ SYS_TI81xx_SGX_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+ if(!pvRegsLinAddr)
+ {
+ return IMG_NULL;
+ }
+
+ ui32SGXRevision = OSReadHWReg((IMG_PVOID)((IMG_PBYTE)pvRegsLinAddr),
+ EUR_CR_CORE_REVISION);
+#else
+ ui32SGXRevision = 0;
+#endif
+
+ SysAcquireData(&psSysData);
+
+ i32Count = OSSNPrintf(aszVersionString, 100,
+ "SGX revision = %u.%u.%u",
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAJOR_MASK)
+ >> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MINOR_MASK)
+ >> EUR_CR_CORE_REVISION_MINOR_SHIFT),
+ (IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
+ >> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
+ );
+
+#if !defined(NO_HARDWARE)
+ OSUnMapPhysToLin(pvRegsLinAddr,
+ SYS_TI81xx_SGX_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+#endif
+
+ if(i32Count == -1)
+ {
+ return IMG_NULL;
+ }
+
+ return aszVersionString;
+}
+
+
+PVRSRV_ERROR SysInitialise(IMG_VOID)
+{
+ IMG_UINT32 i;
+ PVRSRV_ERROR eError;
+ PVRSRV_DEVICE_NODE *psDeviceNode;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+ SGX_TIMING_INFORMATION* psTimingInfo;
+#endif
+ gpsSysData = &gsSysData;
+ OSMemSet(gpsSysData, 0, sizeof(SYS_DATA));
+
+ gpsSysSpecificData = &gsSysSpecificData;
+ OSMemSet(gpsSysSpecificData, 0, sizeof(SYS_SPECIFIC_DATA));
+
+ gpsSysData->pvSysSpecificData = gpsSysSpecificData;
+
+ eError = OSInitEnvData(&gpsSysData->pvEnvSpecificData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to setup env structure"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA);
+
+ gpsSysData->ui32NumDevices = SYS_DEVICE_COUNT;
+
+
+ for(i=0; i<SYS_DEVICE_COUNT; i++)
+ {
+ gpsSysData->sDeviceID[i].uiID = i;
+ gpsSysData->sDeviceID[i].bInUse = IMG_FALSE;
+ }
+
+ gpsSysData->psDeviceNodeList = IMG_NULL;
+ gpsSysData->psQueueList = IMG_NULL;
+
+ eError = SysInitialiseCommon(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed in SysInitialiseCommon"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_REGS_SYS_PHYS_BASE;
+ gpsSysData->pvSOCTimerRegisterKM = IMG_NULL;
+ gpsSysData->hSOCTimerRegisterOSMemHandle = 0;
+ OSReservePhys(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,
+ (IMG_VOID **)&gpsSysData->pvSOCTimerRegisterKM,
+ &gpsSysData->hSOCTimerRegisterOSMemHandle);
+
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+
+ psTimingInfo = &gsSGXDeviceMap.sTimingInfo;
+ if(cpu_is_ti816x())
+ {
+ psTimingInfo->ui32CoreClockSpeed = SYS_389x_SGX_CLOCK_SPEED;
+ }
+ else
+ {
+ psTimingInfo->ui32CoreClockSpeed = SYS_387x_SGX_CLOCK_SPEED;
+ }
+
+ psTimingInfo->ui32HWRecoveryFreq = SYS_SGX_HWRECOVERY_TIMEOUT_FREQ;
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+ psTimingInfo->ui32uKernelFreq = SYS_SGX_PDS_TIMER_FREQ;
+#endif
+
+
+
+ gpsSysSpecificData->ui32SrcClockDiv = 3;
+
+
+
+
+
+ eError = SysLocateDevices(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to locate devices"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV);
+
+#if defined(SGX_OCP_REGS_ENABLED)
+ {
+ IMG_SYS_PHYADDR sOCPRegsSysPBase;
+ IMG_CPU_PHYADDR sOCPRegsCpuPBase;
+
+ sOCPRegsSysPBase.uiAddr = SYS_TI81xx_OCP_REGS_SYS_PHYS_BASE;
+ sOCPRegsCpuPBase = SysSysPAddrToCpuPAddr(sOCPRegsSysPBase);
+
+ gpvOCPRegsLinAddr = OSMapPhysToLin(sOCPRegsCpuPBase,
+ SYS_TI81xx_OCP_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+
+ if (gpvOCPRegsLinAddr == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to map OCP registers"));
+ return PVRSRV_ERROR_BAD_MAPPING;
+ }
+ }
+#endif
+
+
+
+
+ eError = PVRSRVRegisterDevice(gpsSysData, SGXRegisterDevice,
+ DEVICE_SGX_INTERRUPT, &gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to register device!"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_REGDEV);
+
+
+
+
+
+ psDeviceNode = gpsSysData->psDeviceNodeList;
+ while(psDeviceNode)
+ {
+
+ switch(psDeviceNode->sDevId.eDeviceType)
+ {
+ case PVRSRV_DEVICE_TYPE_SGX:
+ {
+ DEVICE_MEMORY_INFO *psDevMemoryInfo;
+ DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+
+
+
+
+ psDeviceNode->psLocalDevMemArena = IMG_NULL;
+
+
+ psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
+ psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
+
+
+ for(i=0; i<psDevMemoryInfo->ui32HeapCount; i++)
+ {
+ psDeviceMemoryHeap[i].ui32Attribs |= PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG;
+ }
+
+ gpsSGXDevNode = psDeviceNode;
+ gsSysSpecificData.psSGXDevNode = psDeviceNode;
+
+ break;
+ }
+ default:
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to find SGX device node!"));
+ return PVRSRV_ERROR_INIT_FAILURE;
+ }
+
+
+ psDeviceNode = psDeviceNode->psNext;
+ }
+
+ eError = EnableSystemClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable system clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+#endif
+
+ dump_omap34xx_clocks();
+
+ eError = PVRSRVInitialiseDevice(gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to initialise device!"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV);
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+
+ DisableSGXClocks(gpsSysData);
+#endif
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysFinalise(IMG_VOID)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysInitialise: Failed to Enable SGX clocks (%d)", eError));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+#endif
+
+#if defined(SYS_USING_INTERRUPTS)
+
+ eError = OSInstallMISR(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install MISR"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR);
+
+
+ eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to install ISR"));
+ (IMG_VOID)SysDeinitialise(gpsSysData);
+ gpsSysData = IMG_NULL;
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+#endif
+
+
+ gpsSysData->pszVersionString = SysCreateVersionString(gsSGXDeviceMap.sRegsCpuPBase);
+ if (!gpsSysData->pszVersionString)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysFinalise: Failed to create a system version string"));
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_WARNING, "SysFinalise: Version string: %s", gpsSysData->pszVersionString));
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+
+ DisableSGXClocks(gpsSysData);
+#endif
+
+ gpsSysSpecificData->bSGXInitComplete = IMG_TRUE;
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)
+{
+ PVRSRV_ERROR eError;
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))
+ {
+ eError = OSUninstallDeviceLISR(psSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallDeviceLISR failed"));
+ return eError;
+ }
+ }
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_MISR))
+ {
+ eError = OSUninstallMISR(psSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));
+ return eError;
+ }
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_INITDEV))
+ {
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ PVR_ASSERT(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS));
+
+ eError = EnableSGXClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: EnableSGXClocks failed"));
+ return eError;
+ }
+#endif
+
+
+ eError = PVRSRVDeinitialiseDevice (gui32SGXDeviceID);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
+ return eError;
+ }
+ }
+
+#if defined(SGX_OCP_REGS_ENABLED)
+ OSUnMapPhysToLin(gpvOCPRegsLinAddr,
+ SYS_TI81xx_OCP_REGS_SIZE,
+ PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
+ IMG_NULL);
+#endif
+
+
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
+ {
+ DisableSystemClocks(gpsSysData);
+ }
+
+ if (SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_ENVDATA))
+ {
+ eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));
+ return eError;
+ }
+ }
+
+ if(gpsSysData->pvSOCTimerRegisterKM)
+ {
+ OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM,
+ 4,
+ PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,
+ gpsSysData->hSOCTimerRegisterOSMemHandle);
+ }
+
+ SysDeinitialiseCommon(gpsSysData);
+
+#if defined(NO_HARDWARE)
+ if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))
+ {
+
+ OSBaseFreeContigMemory(SYS_TI81xx_SGX_REGS_SIZE, gsSGXRegsCPUVAddr, gsSGXDeviceMap.sRegsCpuPBase);
+ }
+#endif
+
+
+ gpsSysSpecificData->ui32SysSpecificData = 0;
+ gpsSysSpecificData->bSGXInitComplete = IMG_FALSE;
+
+ gpsSysData = IMG_NULL;
+
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_VOID **ppvDeviceMap)
+{
+
+ switch(eDeviceType)
+ {
+ case PVRSRV_DEVICE_TYPE_SGX:
+ {
+
+ *ppvDeviceMap = (IMG_VOID*)&gsSGXDeviceMap;
+
+ break;
+ }
+ default:
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysGetDeviceMemoryMap: unsupported device type"));
+ }
+ }
+ return PVRSRV_OK;
+}
+
+
+IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+ IMG_CPU_PHYADDR CpuPAddr)
+{
+ IMG_DEV_PHYADDR DevPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ DevPAddr.uiAddr = CpuPAddr.uiAddr;
+
+ return DevPAddr;
+}
+
+IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr (IMG_SYS_PHYADDR sys_paddr)
+{
+ IMG_CPU_PHYADDR cpu_paddr;
+
+
+ cpu_paddr.uiAddr = sys_paddr.uiAddr;
+ return cpu_paddr;
+}
+
+IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr (IMG_CPU_PHYADDR cpu_paddr)
+{
+ IMG_SYS_PHYADDR sys_paddr;
+
+
+ sys_paddr.uiAddr = cpu_paddr.uiAddr;
+ return sys_paddr;
+}
+
+
+IMG_DEV_PHYADDR SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr)
+{
+ IMG_DEV_PHYADDR DevPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ DevPAddr.uiAddr = SysPAddr.uiAddr;
+
+ return DevPAddr;
+}
+
+
+IMG_SYS_PHYADDR SysDevPAddrToSysPAddr(PVRSRV_DEVICE_TYPE eDeviceType, IMG_DEV_PHYADDR DevPAddr)
+{
+ IMG_SYS_PHYADDR SysPAddr;
+
+ PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+
+ SysPAddr.uiAddr = DevPAddr.uiAddr;
+
+ return SysPAddr;
+}
+
+
+IMG_VOID SysRegisterExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+}
+
+
+IMG_VOID SysRemoveExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+}
+
+
+IMG_UINT32 SysGetInterruptSource(SYS_DATA *psSysData,
+ PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#if defined(NO_HARDWARE)
+
+ return 0xFFFFFFFF;
+#else
+
+ return psDeviceNode->ui32SOCInterruptBit;
+#endif
+}
+
+
+IMG_VOID SysClearInterrupts(SYS_DATA* psSysData, IMG_UINT32 ui32ClearBits)
+{
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+ PVR_UNREFERENCED_PARAMETER(ui32ClearBits);
+
+
+ OSReadHWReg(((PVRSRV_SGXDEV_INFO *)gpsSGXDevNode->pvDevice)->pvRegsBaseKM,
+ EUR_CR_EVENT_HOST_CLEAR);
+}
+
+
+PVRSRV_ERROR SysSystemPrePowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if (eNewPowerState == PVRSRV_SYS_POWER_STATE_D3)
+ {
+ PVR_TRACE(("SysSystemPrePowerState: Entering state D3"));
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))
+ {
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);
+#endif
+ eError = OSUninstallDeviceLISR(gpsSysData);
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ if (bWrapped)
+ {
+ UnwrapSystemPowerChange(&gsSysSpecificData);
+ }
+#endif
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSUninstallDeviceLISR failed (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+ }
+#endif
+
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
+ {
+ DisableSystemClocks(gpsSysData);
+
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+ }
+ }
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ if (eNewPowerState == PVRSRV_SYS_POWER_STATE_D0)
+ {
+ PVR_TRACE(("SysSystemPostPowerState: Entering state D0"));
+
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS))
+ {
+ eError = EnableSystemClocksWrap(gpsSysData);
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: EnableSystemClocksWrap failed (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
+ }
+
+#if defined(SYS_USING_INTERRUPTS)
+ if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))
+ {
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);
+#endif
+
+ eError = OSInstallDeviceLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ, "SGX ISR", gpsSGXDevNode);
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+ if (bWrapped)
+ {
+ UnwrapSystemPowerChange(&gsSysSpecificData);
+ }
+#endif
+ if (eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallDeviceLISR failed to install ISR (%d)", eError));
+ return eError;
+ }
+ SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
+ SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
+ }
+#endif
+ }
+ return eError;
+}
+
+
+PVRSRV_ERROR SysDevicePrePowerState(IMG_UINT32 ui32DeviceIndex,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
+ PVRSRV_DEV_POWER_STATE eCurrentPowerState)
+{
+ PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
+
+ if (ui32DeviceIndex != gui32SGXDeviceID)
+ {
+ return PVRSRV_OK;
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if (eNewPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+ {
+ PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePrePowerState: SGX Entering state D3"));
+ DisableSGXClocks(gpsSysData);
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(eNewPowerState );
+#endif
+ return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SysDevicePostPowerState(IMG_UINT32 ui32DeviceIndex,
+ PVRSRV_DEV_POWER_STATE eNewPowerState,
+ PVRSRV_DEV_POWER_STATE eCurrentPowerState)
+{
+ PVRSRV_ERROR eError = PVRSRV_OK;
+
+ PVR_UNREFERENCED_PARAMETER(eNewPowerState);
+
+ if (ui32DeviceIndex != gui32SGXDeviceID)
+ {
+ return eError;
+ }
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ if (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+ {
+ PVR_DPF((PVR_DBG_MESSAGE, "SysDevicePostPowerState: SGX Leaving state D3"));
+ eError = EnableSGXClocksWrap(gpsSysData);
+ }
+#else
+ PVR_UNREFERENCED_PARAMETER(eCurrentPowerState);
+#endif
+
+ return eError;
+}
+
+
+PVRSRV_ERROR SysOEMFunction ( IMG_UINT32 ui32ID,
+ IMG_VOID *pvIn,
+ IMG_UINT32 ulInSize,
+ IMG_VOID *pvOut,
+ IMG_UINT32 ulOutSize)
+{
+ PVR_UNREFERENCED_PARAMETER(ui32ID);
+ PVR_UNREFERENCED_PARAMETER(pvIn);
+ PVR_UNREFERENCED_PARAMETER(ulInSize);
+ PVR_UNREFERENCED_PARAMETER(pvOut);
+ PVR_UNREFERENCED_PARAMETER(ulOutSize);
+
+ if ((ui32ID == OEM_GET_EXT_FUNCS) &&
+ (ulOutSize == sizeof(PVRSRV_DC_OEM_JTABLE)))
+ {
+
+ PVRSRV_DC_OEM_JTABLE *psOEMJTable = (PVRSRV_DC_OEM_JTABLE*) pvOut;
+ psOEMJTable->pfnOEMBridgeDispatch = &PVRSRV_BridgeDispatchKM;
+ return PVRSRV_OK;
+ }
+
+ return PVRSRV_ERROR_INVALID_PARAMS;
+}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SOCCONFIG_H__)
+#define __SOCCONFIG_H__
+
+#include "syscommon.h"
+
+#define VS_PRODUCT_NAME "TI81xx"
+
+//#define SYS_SGX_CLOCK_SPEED 200000000
+#define SYS_387x_SGX_CLOCK_SPEED 200000000
+#define SYS_389x_SGX_CLOCK_SPEED 333000000
+
+#define SYS_SGX_HWRECOVERY_TIMEOUT_FREQ (100)
+#define SYS_SGX_PDS_TIMER_FREQ (1000)
+
+#if !defined(SYS_SGX_ACTIVE_POWER_LATENCY_MS)
+#define SYS_SGX_ACTIVE_POWER_LATENCY_MS (1)
+#endif
+
+
+#define SYS_TI81xx_SGX_REGS_SYS_PHYS_BASE 0x56000000
+
+#define SYS_TI81xx_SGX_REGS_SIZE 0x10000
+
+#define SYS_TI81xx_SGX_IRQ 37
+
+#define SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE 0x48048038
+#define SYS_TI81xx_GP7TIMER_REGS_SYS_PHYS_BASE 0x4804803C
+#define SYS_TI81xx_GP7TIMER_TSICR_SYS_PHYS_BASE 0x48048054
+
+#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SYSINFO_H__)
+#define __SYSINFO_H__
+
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#define MAX_HW_TIME_US (1000000)
+#else
+#define MAX_HW_TIME_US (500000)
+#endif
+
+#define WAIT_TRY_COUNT (10000)
+
+#define SYS_DEVICE_COUNT 3
+
+#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if !defined(__SYSLOCAL_H__)
+#define __SYSLOCAL_H__
+
+#if defined(__linux__)
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include <linux/mutex.h>
+#else
+#include <linux/spinlock.h>
+#endif
+#include <asm/atomic.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#include <linux/semaphore.h>
+#include <linux/resource.h>
+#else
+#include <asm/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+#include <asm/arch/resource.h>
+#endif
+#endif
+
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+
+IMG_CHAR *SysCreateVersionString(IMG_CPU_PHYADDR sRegRegion);
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData);
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData);
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData);
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData);
+
+#define SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS 0x00000001
+#define SYS_SPECIFIC_DATA_ENABLE_LISR 0x00000002
+#define SYS_SPECIFIC_DATA_ENABLE_MISR 0x00000004
+#define SYS_SPECIFIC_DATA_ENABLE_ENVDATA 0x00000008
+#define SYS_SPECIFIC_DATA_ENABLE_LOCDEV 0x00000010
+#define SYS_SPECIFIC_DATA_ENABLE_REGDEV 0x00000020
+#define SYS_SPECIFIC_DATA_ENABLE_PDUMPINIT 0x00000040
+#define SYS_SPECIFIC_DATA_ENABLE_INITDEV 0x00000080
+#define SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV 0x00000100
+
+#define SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR 0x00000200
+#define SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS 0x00000400
+
+#define SYS_SPECIFIC_DATA_SET(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData |= (flag)))
+
+#define SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, flag) ((IMG_VOID)((psSysSpecData)->ui32SysSpecificData &= ~(flag)))
+
+#define SYS_SPECIFIC_DATA_TEST(psSysSpecData, flag) (((psSysSpecData)->ui32SysSpecificData & (flag)) != 0)
+
+typedef struct _SYS_SPECIFIC_DATA_TAG_
+{
+ IMG_UINT32 ui32SysSpecificData;
+ PVRSRV_DEVICE_NODE *psSGXDevNode;
+ IMG_BOOL bSGXInitComplete;
+#if !defined(__linux__)
+ IMG_BOOL bSGXClocksEnabled;
+#endif
+ IMG_UINT32 ui32SrcClockDiv;
+#if defined(__linux__)
+ IMG_BOOL bSysClocksOneTimeInit;
+ atomic_t sSGXClocksEnabled;
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+ struct mutex sPowerLock;
+#else
+ IMG_BOOL bConstraintNotificationsEnabled;
+ spinlock_t sPowerLock;
+ atomic_t sPowerLockCPU;
+ spinlock_t sNotifyLock;
+ atomic_t sNotifyLockCPU;
+ IMG_BOOL bCallVDD2PostFunc;
+#endif
+ struct clk *psCORE_CK;
+ struct clk *psSGX_FCK;
+ struct clk *psSGX_ICK;
+ struct clk *psMPU_CK;
+#if defined(DEBUG) || defined(TIMING)
+ struct clk *psGPT11_FCK;
+ struct clk *psGPT11_ICK;
+#endif
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+ struct constraint_handle *pVdd2Handle;
+#endif
+#endif
+} SYS_SPECIFIC_DATA;
+
+extern SYS_SPECIFIC_DATA *gpsSysSpecificData;
+
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData);
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#if defined(__linux__)
+#if defined(PVR_LINUX_USING_WORKQUEUES)
+#include "sysutils_linux_wqueue_compat.c"
+#else
+#include "sysutils_linux.c"
+#endif
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/spinlock.h>
+#include <asm/bug.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+#include <linux/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31))
+//#include <plat/resource.h>
+#include <plat/omap-pm.h>
+#else
+#include <mach/resource.h>
+#endif
+#else
+#include <asm/semaphore.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+#include <asm/arch/resource.h>
+#endif
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)) && \
+ (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27))
+#define CONSTRAINT_NOTIFICATIONS
+#endif
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+//#define DEBUG
+#if !defined(PDUMP) && !defined(NO_HARDWARE)
+static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+ IMG_BOOL bLocked = IMG_FALSE;
+
+ if (!in_interrupt())
+ {
+ iCPU = get_cpu();
+ bLocked = (iCPU == atomic_read(&psSysSpecData->sPowerLockCPU));
+
+ put_cpu();
+ }
+
+ return bLocked;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+
+ if (!in_interrupt())
+ {
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!PowerLockWrappedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sPowerLockCPU, iCPU);
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ PVR_ASSERT(PowerLockWrappedOnCPU(psSysSpecData));
+
+ atomic_set(&psSysSpecData->sPowerLockCPU, -1);
+
+ spin_unlock(&psSysSpecData->sPowerLock);
+
+ put_cpu();
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+#else
+static IMG_BOOL PowerLockWrappedOnCPU(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+ return IMG_FALSE;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA unref__ *psSysSpecData)
+{
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA unref__ *psSysData)
+{
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA unref__ *psSysData)
+{
+}
+#endif
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_BOOL bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+
+ if (bPowerLock)
+ {
+ PowerLockUnwrap(psSysSpecData);
+ }
+
+ return bPowerLock;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ PowerLockWrap(psSysSpecData);
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+
+ if(cpu_is_ti816x())
+ {
+ return scale_by_rate(val, rate, SYS_389x_SGX_CLOCK_SPEED);
+ }
+ else
+ {
+ return scale_by_rate(val, rate, SYS_387x_SGX_CLOCK_SPEED);
+ }
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ if(cpu_is_ti816x())
+ {
+ return scale_by_rate(val, SYS_389x_SGX_CLOCK_SPEED, rate);
+ }
+ else
+ {
+ return scale_by_rate(val, SYS_387x_SGX_CLOCK_SPEED, rate);
+ }
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ if(cpu_is_ti816x())
+ {
+ rate = SYS_389x_SGX_CLOCK_SPEED;
+ }
+ else
+ {
+ rate = SYS_387x_SGX_CLOCK_SPEED;
+ }
+
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+#error "SGX_DYNAMIC_TIMING_INFO must be defined for this platform"
+#endif
+
+static struct constraint_id cnstr_id_vdd2 = {
+ .type = RES_OPP_CO,
+ .data = (IMG_VOID *)"vdd2_opp"
+};
+
+#if !defined(PDUMP) && !defined(NO_HARDWARE)
+static inline IMG_BOOL ConstraintNotificationsEnabled(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0) && psSysSpecData->bSGXInitComplete && psSysSpecData->bConstraintNotificationsEnabled;
+
+}
+
+static IMG_BOOL NotifyLockedOnCPU(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU = get_cpu();
+ IMG_BOOL bLocked = (iCPU == atomic_read(&psSysSpecData->sNotifyLockCPU));
+
+ put_cpu();
+
+ return bLocked;
+}
+
+static IMG_VOID NotifyLock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ IMG_INT iCPU;
+
+ BUG_ON(in_interrupt());
+
+
+ iCPU = get_cpu();
+
+
+ PVR_ASSERT(iCPU != -1);
+
+ PVR_ASSERT(!NotifyLockedOnCPU(psSysSpecData));
+
+ spin_lock(&psSysSpecData->sNotifyLock);
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, iCPU);
+}
+
+static IMG_VOID NotifyUnlock(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ PVR_ASSERT(NotifyLockedOnCPU(psSysSpecData));
+
+ atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
+
+ spin_unlock(&psSysSpecData->sNotifyLock);
+
+ put_cpu();
+}
+
+static int VDD2PostFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_ERROR, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+
+ if (!NotifyLockedOnCPU(gpsSysSpecificData))
+ {
+ return 0;
+ }
+
+#if defined(DEBUG)
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ IMG_UINT32 rate;
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+
+ PVR_ASSERT(rate != 0);
+
+ PVR_DPF((PVR_DBG_MESSAGE, "%s: SGX clock rate: %dMHz", __FUNCTION__, HZ_TO_MHZ(rate)));
+ }
+#endif
+ if (gpsSysSpecificData->bCallVDD2PostFunc)
+ {
+ PVRSRVDevicePostClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = IMG_FALSE;
+ }
+ else
+ {
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVR_TRACE(("%s: Not calling PVR clock speed notification functions", __FUNCTION__));
+ }
+ }
+
+ NotifyUnlock(gpsSysSpecificData);
+
+ return 0;
+}
+
+static int VDD2PreFunc(struct notifier_block *n, unsigned long event, IMG_VOID *ptr)
+{
+ PVR_UNREFERENCED_PARAMETER(n);
+ PVR_UNREFERENCED_PARAMETER(event);
+ PVR_UNREFERENCED_PARAMETER(ptr);
+
+ if (in_interrupt())
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called in interrupt context. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ if (PowerLockWrappedOnCPU(gpsSysSpecificData))
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s Called from within a power transition. Ignoring.", __FUNCTION__));
+ return 0;
+ }
+
+ NotifyLock(gpsSysSpecificData);
+
+ PVR_ASSERT(!gpsSysSpecificData->bCallVDD2PostFunc);
+
+ if (ConstraintNotificationsEnabled(gpsSysSpecificData))
+ {
+ PVRSRV_ERROR eError;
+
+ eError = PVRSRVDevicePreClockSpeedChange(gpsSysSpecificData->psSGXDevNode->sDevId.ui32DeviceIndex, IMG_TRUE, IMG_NULL);
+
+ gpsSysSpecificData->bCallVDD2PostFunc = (eError == PVRSRV_OK);
+
+ }
+
+ return 0;
+}
+
+static struct notifier_block sVDD2Pre = {
+ VDD2PreFunc,
+ NULL
+};
+
+static struct notifier_block sVDD2Post = {
+ VDD2PostFunc,
+ NULL
+};
+
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Registering constraint notifications"));
+
+ PVR_ASSERT(!gpsSysSpecificData->bConstraintNotificationsEnabled);
+
+ constraint_register_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_register_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_TRUE;
+ NotifyUnlock(gpsSysSpecificData);
+
+ PVR_TRACE(("VDD2 constraint notifications registered"));
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+ PVR_TRACE(("Unregistering constraint notifications"));
+
+
+ NotifyLock(gpsSysSpecificData);
+ gpsSysSpecificData->bConstraintNotificationsEnabled = IMG_FALSE;
+ NotifyUnlock(gpsSysSpecificData);
+
+
+ constraint_unregister_pre_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Pre,
+ max_vdd2_opp+1);
+
+ constraint_unregister_post_notification(gpsSysSpecificData->pVdd2Handle, &sVDD2Post,
+ max_vdd2_opp+1);
+}
+#else
+static IMG_VOID RegisterConstraintNotifications(IMG_VOID)
+{
+}
+
+static IMG_VOID UnRegisterConstraintNotifications(IMG_VOID)
+{
+}
+#endif
+#endif
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+#if 0
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+#endif
+
+// IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+// PVR_TRACE((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ PVRSRV_ERROR eError;
+ IMG_BOOL bPowerLock;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ bPowerLock = IMG_FALSE;
+
+ spin_lock_init(&psSysSpecData->sPowerLock);
+ atomic_set(&psSysSpecData->sPowerLockCPU, -1);
+ spin_lock_init(&psSysSpecData->sNotifyLock);
+ atomic_set(&psSysSpecData->sNotifyLockCPU, -1);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ psCLK = clk_get(NULL, "sgx_ck");
+
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+ else
+ {
+
+ bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+ if (bPowerLock)
+ {
+ PowerLockUnwrap(psSysSpecData);
+ }
+ }
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ psSysSpecData->pVdd2Handle = constraint_get(PVRSRV_MODNAME, &cnstr_id_vdd2);
+ if (IS_ERR(psSysSpecData->pVdd2Handle))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get VDD2 constraint handle"));
+ goto ExitError;
+ }
+
+ RegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+ if(cpu_is_ti816x()) {
+ psCLK = clk_get(NULL, "gpt6_fck");
+ } else {
+ psCLK = clk_get(NULL, "gpt7_fck");
+ }
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ if(cpu_is_ti816x()) {
+ psCLK = clk_get(NULL, "gpt6_ick");
+ } else {
+ psCLK = clk_get(NULL, "gpt7_ick");
+ }
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ PVR_TRACE(("EnableSystemClocks: Setting SGX OPP constraint"));
+
+
+ res = constraint_set(psSysSpecData->pVdd2Handle, max_vdd2_opp);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: constraint_set failed (%d)", res));
+ goto ExitConstraintSetFailed;
+ }
+#endif
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ExitConstraintSetFailed:
+#endif
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
+Exit:
+ if (bPowerLock)
+ {
+ PowerLockWrap(psSysSpecData);
+ }
+
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_BOOL bPowerLock;
+#if defined(DEBUG) || defined(TIMING)
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+ bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+ if (bPowerLock)
+ {
+
+ PowerLockUnwrap(psSysSpecData);
+ }
+
+#if defined(PDUMP) && !defined(NO_HARDWARE) && defined(CONSTRAINT_NOTIFICATIONS)
+ {
+ int res;
+
+ PVR_TRACE(("DisableSystemClocks: Removing SGX OPP constraint"));
+
+
+ res = constraint_remove(psSysSpecData->pVdd2Handle);
+ if (res != 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "DisableSystemClocks: constraint_remove failed (%d)", res));
+ }
+ }
+#endif
+
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ UnRegisterConstraintNotifications();
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+#if defined(CONSTRAINT_NOTIFICATIONS)
+ constraint_put(psSysSpecData->pVdd2Handle);
+#endif
+ if (bPowerLock)
+ {
+ PowerLockWrap(psSysSpecData);
+ }
+}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/mutex.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#if !defined(PVR_LINUX_USING_WORKQUEUES)
+#error "PVR_LINUX_USING_WORKQUEUES must be defined"
+#endif
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_lock(&psSysSpecData->sPowerLock);
+
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_unlock(&psSysSpecData->sPowerLock);
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return IMG_TRUE;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ if(cpu_is_ti816x())
+ {
+ return scale_by_rate(val, rate, SYS_389x_SGX_CLOCK_SPEED);
+ }
+ else
+ {
+
+ return scale_by_rate(val, rate, SYS_387x_SGX_CLOCK_SPEED);
+ }
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ if(cpu_is_ti816x())
+ {
+ return scale_by_rate(val, SYS_389x_SGX_CLOCK_SPEED, rate);
+ }
+ else
+ {
+ return scale_by_rate(val, SYS_387x_SGX_CLOCK_SPEED, rate);
+ }
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ if(cpu_is_ti816x())
+ {
+ rate = SYS_389x_SGX_CLOCK_SPEED;
+ }
+ else
+ {
+ rate = SYS_387x_SGX_CLOCK_SPEED;
+ }
+
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+#if defined(DEBUG)
+ {
+
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+/*
+ res = clk_enable(psSysSpecData->psSGX_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
+
+ clk_disable(psSysSpecData->psSGX_FCK);
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+*/
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+/* if (psSysSpecData->psSGX_ICK)
+ {
+ clk_disable(psSysSpecData->psSGX_ICK);
+ }
+*/
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ IMG_BOOL bPowerLock;
+ PVRSRV_ERROR eError;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ mutex_init(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ // if(cpu_is_ti816x())
+ // {
+ psCLK = clk_get(NULL, "sgx_ck");
+ // } else {
+ // psCLK = clk_get(NULL, "gfx_fck");
+ // }
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+/* else
+ {
+
+ bPowerLock = PowerLockWrappedOnCPU(psSysSpecData);
+ if (bPowerLock)
+ {
+ PowerLockUnwrap(psSysSpecData);
+ }
+ }
+
+*/
+
+/*
+ psCLK = clk_get(NULL, SGX_PARENT_CLOCK);
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psCORE_CK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_ICK = psCLK;
+
+#if defined(DEBUG)
+ psCLK = clk_get(NULL, "mpu_ck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psMPU_CK = psCLK;
+#endif
+ res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
+ goto ExitError;
+ }
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+*/
+#if defined(DEBUG) || defined(TIMING)
+ if(cpu_is_ti816x()) {
+ psCLK = clk_get(NULL, "gpt6_fck");
+ } else {
+ psCLK = clk_get(NULL, "gpt7_fck");
+ }
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ if(cpu_is_ti816x()) {
+ psCLK = clk_get(NULL, "gpt6_ick");
+ } else {
+ psCLK = clk_get(NULL, "gpt7_ick");
+ }
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+/*
+ sys_ck = clk_get(NULL, "sys_ck");
+ if (IS_ERR(sys_ck))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)
+ {
+ PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));
+ res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ }
+*/
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+Exit:
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+#if defined(DEBUG) || defined(TIMING)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+}
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/mutex.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sysinfo.h"
+#include "sgxapi_km.h"
+#include "sysconfig.h"
+#include "sgxinfokm.h"
+#include "syslocal.h"
+
+#if !defined(PVR_LINUX_USING_WORKQUEUES)
+#error "PVR_LINUX_USING_WORKQUEUES must be defined"
+#endif
+
+#define ONE_MHZ 1000000
+#define HZ_TO_MHZ(m) ((m) / ONE_MHZ)
+
+#if defined(SUPPORT_OMAP3430_SGXFCLK_96M)
+#define SGX_PARENT_CLOCK "cm_96m_fck"
+#else
+#define SGX_PARENT_CLOCK "core_ck"
+#endif
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_lock(&psSysSpecData->sPowerLock);
+
+ }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ if (!in_interrupt())
+ {
+ mutex_unlock(&psSysSpecData->sPowerLock);
+ }
+}
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockWrap(psSysSpecData);
+
+ return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+ PowerLockUnwrap(psSysSpecData);
+}
+
+IMG_BOOL WrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+ return IMG_TRUE;
+}
+
+IMG_VOID UnwrapSystemPowerChange(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+}
+
+static inline IMG_UINT32 scale_by_rate(IMG_UINT32 val, IMG_UINT32 rate1, IMG_UINT32 rate2)
+{
+ if (rate1 >= rate2)
+ {
+ return val * (rate1 / rate2);
+ }
+
+ return val / (rate2 / rate1);
+}
+
+static inline IMG_UINT32 scale_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, rate, SYS_SGX_CLOCK_SPEED);
+}
+
+static inline IMG_UINT32 scale_inv_prop_to_SGX_clock(IMG_UINT32 val, IMG_UINT32 rate)
+{
+ return scale_by_rate(val, SYS_SGX_CLOCK_SPEED, rate);
+}
+
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psTimingInfo)
+{
+ IMG_UINT32 rate;
+
+#if defined(NO_HARDWARE)
+ rate = SYS_SGX_CLOCK_SPEED;
+#else
+ PVR_ASSERT(atomic_read(&gpsSysSpecificData->sSGXClocksEnabled) != 0);
+
+ rate = clk_get_rate(gpsSysSpecificData->psSGX_FCK);
+ PVR_ASSERT(rate != 0);
+#endif
+ psTimingInfo->ui32CoreClockSpeed = rate;
+ psTimingInfo->ui32HWRecoveryFreq = scale_prop_to_SGX_clock(SYS_SGX_HWRECOVERY_TIMEOUT_FREQ, rate);
+ psTimingInfo->ui32uKernelFreq = scale_prop_to_SGX_clock(SYS_SGX_PDS_TIMER_FREQ, rate);
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT)
+ psTimingInfo->bEnableActivePM = IMG_TRUE;
+#else
+ psTimingInfo->bEnableActivePM = IMG_FALSE;
+#endif
+ psTimingInfo->ui32ActivePowManLatencyms = SYS_SGX_ACTIVE_POWER_LATENCY_MS;
+}
+
+PVRSRV_ERROR EnableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ long lNewRate;
+ long lRate;
+ IMG_INT res;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+ {
+ return PVRSRV_OK;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+#if defined(DEBUG)
+ {
+
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psMPU_CK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: CPU Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+ res = clk_enable(psSysSpecData->psSGX_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX functional clock (%d)", res));
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ res = clk_enable(psSysSpecData->psSGX_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't enable SGX interface clock (%d)", res));
+
+ clk_disable(psSysSpecData->psSGX_FCK);
+ return PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK;
+ }
+
+ lNewRate = clk_round_rate(psSysSpecData->psSGX_FCK, SYS_SGX_CLOCK_SPEED + ONE_MHZ);
+ if (lNewRate <= 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSGXClocks: Couldn't round SGX functional clock rate"));
+ return PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE;
+ }
+
+
+ lRate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ if (lRate != lNewRate)
+ {
+ res = clk_set_rate(psSysSpecData->psSGX_FCK, lNewRate);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_WARNING, "EnableSGXClocks: Couldn't set SGX functional clock rate (%d)", res));
+ }
+ }
+
+#if defined(DEBUG)
+ {
+ IMG_UINT32 rate = clk_get_rate(psSysSpecData->psSGX_FCK);
+ PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: SGX Functional Clock is %dMhz", HZ_TO_MHZ(rate)));
+ }
+#endif
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+ return PVRSRV_OK;
+}
+
+
+IMG_VOID DisableSGXClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_HARDWARE)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+
+
+ if (atomic_read(&psSysSpecData->sSGXClocksEnabled) == 0)
+ {
+ return;
+ }
+
+ PVR_DPF((PVR_DBG_MESSAGE, "DisableSGXClocks: Disabling SGX Clocks"));
+
+ if (psSysSpecData->psSGX_ICK)
+ {
+ clk_disable(psSysSpecData->psSGX_ICK);
+ }
+
+ if (psSysSpecData->psSGX_FCK)
+ {
+ clk_disable(psSysSpecData->psSGX_FCK);
+ }
+
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+#else
+ PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif
+}
+
+PVRSRV_ERROR EnableSystemClocks(SYS_DATA *psSysData)
+{
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ struct clk *psCLK;
+ IMG_INT res;
+ PVRSRV_ERROR eError;
+
+#if defined(DEBUG) || defined(TIMING)
+ IMG_INT rate;
+ struct clk *sys_ck;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerEnable;
+ IMG_UINT32 *pui32TimerEnable;
+
+#endif
+
+ PVR_TRACE(("EnableSystemClocks: Enabling System Clocks"));
+
+ if (!psSysSpecData->bSysClocksOneTimeInit)
+ {
+ mutex_init(&psSysSpecData->sPowerLock);
+
+ atomic_set(&psSysSpecData->sSGXClocksEnabled, 0);
+
+ psCLK = clk_get(NULL, SGX_PARENT_CLOCK);
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get Core Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psCORE_CK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSsystemClocks: Couldn't get SGX Functional Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "sgx_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get SGX Interface Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psSGX_ICK = psCLK;
+
+#if defined(DEBUG)
+ psCLK = clk_get(NULL, "mpu_ck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get MPU Clock"));
+ goto ExitError;
+ }
+ psSysSpecData->psMPU_CK = psCLK;
+#endif
+ res = clk_set_parent(psSysSpecData->psSGX_FCK, psSysSpecData->psCORE_CK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set SGX parent clock (%d)", res));
+ goto ExitError;
+ }
+
+ psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+ }
+
+#if defined(DEBUG) || defined(TIMING)
+
+ psCLK = clk_get(NULL, "gpt11_fck");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 functional clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_FCK = psCLK;
+
+ psCLK = clk_get(NULL, "gpt11_ick");
+ if (IS_ERR(psCLK))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get GPTIMER11 interface clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ psSysSpecData->psGPT11_ICK = psCLK;
+
+ sys_ck = clk_get(NULL, "sys_ck");
+ if (IS_ERR(sys_ck))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't get System clock"));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ if(clk_get_parent(psSysSpecData->psGPT11_FCK) != sys_ck)
+ {
+ PVR_TRACE(("Setting GPTIMER11 parent to System Clock"));
+ res = clk_set_parent(psSysSpecData->psGPT11_FCK, sys_ck);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't set GPTIMER11 parent clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+ }
+
+ rate = clk_get_rate(psSysSpecData->psGPT11_FCK);
+ PVR_TRACE(("GPTIMER11 clock is %dMHz", HZ_TO_MHZ(rate)));
+
+ res = clk_enable(psSysSpecData->psGPT11_FCK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 functional clock (%d)", res));
+ goto ExitUnRegisterConstraintNotifications;
+ }
+
+ res = clk_enable(psSysSpecData->psGPT11_ICK);
+ if (res < 0)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: Couldn't enable GPTIMER11 interface clock (%d)", res));
+ goto ExitDisableGPT11FCK;
+ }
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_TSICR_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+ rate = *pui32TimerEnable;
+ if(!(rate & 4))
+ {
+ PVR_TRACE(("Setting GPTIMER11 mode to posted (currently is non-posted)"));
+
+
+ *pui32TimerEnable = rate | 4;
+ }
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerEnable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerEnable);
+
+ if (pui32TimerEnable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "EnableSystemClocks: OSMapPhysToLin failed"));
+ goto ExitDisableGPT11ICK;
+ }
+
+
+ *pui32TimerEnable = 3;
+
+ OSUnMapPhysToLin(pui32TimerEnable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerEnable);
+
+#endif
+
+ eError = PVRSRV_OK;
+ goto Exit;
+
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ clk_disable(psSysSpecData->psGPT11_ICK);
+ExitDisableGPT11FCK:
+ clk_disable(psSysSpecData->psGPT11_FCK);
+ExitUnRegisterConstraintNotifications:
+#endif
+ExitError:
+ eError = PVRSRV_ERROR_DISABLE_CLOCK_FAILURE;
+Exit:
+ return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+#if defined(DEBUG) || defined(TIMING)
+ SYS_SPECIFIC_DATA *psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
+ IMG_CPU_PHYADDR TimerRegPhysBase;
+ IMG_HANDLE hTimerDisable;
+ IMG_UINT32 *pui32TimerDisable;
+#endif
+
+ PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+
+ DisableSGXClocks(psSysData);
+
+#if defined(DEBUG) || defined(TIMING)
+
+ TimerRegPhysBase.uiAddr = SYS_TI81xx_GP7TIMER_ENABLE_SYS_PHYS_BASE;
+ pui32TimerDisable = OSMapPhysToLin(TimerRegPhysBase,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ &hTimerDisable);
+
+ if (pui32TimerDisable == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DisableSystemClocks: OSMapPhysToLin failed"));
+ }
+ else
+ {
+ *pui32TimerDisable = 0;
+
+ OSUnMapPhysToLin(pui32TimerDisable,
+ 4,
+ PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+ hTimerDisable);
+ }
+
+ clk_disable(psSysSpecData->psGPT11_ICK);
+
+ clk_disable(psSysSpecData->psGPT11_FCK);
+
+#endif
+}
#include "dbgdriv.h"
#include "hotkey.h"
#include "hostfunc.h"
+#include "pvr_debug.h"
ExtDBGDrivGetStreamOffset,
ExtDBGDrivSetStreamOffset,
ExtDBGDrivIsLastCaptureFrame,
- ExtDBGDrivWaitForEvent
+ ExtDBGDrivWaitForEvent,
+ ExtDBGDrivSetConnectNotifier,
+ ExtDBGDrivWritePersist
};
+static IMG_UINT32 DBGDrivWritePersist(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level);
+static IMG_VOID InvalidateAllStreams(IMG_VOID);
+
+
+DBGKM_CONNECT_NOTIFIER g_fnDBGKMNotifier;
+
+IMG_VOID IMG_CALLCONV ExtDBGDrivSetConnectNotifier(DBGKM_CONNECT_NOTIFIER fn_notifier)
+{
+
+ g_fnDBGKMNotifier = fn_notifier;
+}
IMG_VOID * IMG_CALLCONV ExtDBGDrivCreateStream(IMG_CHAR * pszName, IMG_UINT32 ui32CapMode, IMG_UINT32 ui32OutMode, IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size)
{
HostAquireMutex(g_pvAPIMutex);
pvRet=DBGDrivFindStream(pszName, bResetStream);
+ if(g_fnDBGKMNotifier.pfnConnectNotifier)
+ {
+ g_fnDBGKMNotifier.pfnConnectNotifier();
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "pfnConnectNotifier not initialised.\n"));
+ }
HostReleaseMutex(g_pvAPIMutex);
return ui32Ret;
}
+IMG_UINT32 IMG_CALLCONV ExtDBGDrivWritePersist(PDBG_STREAM psStream,IMG_UINT8 *pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
+{
+ IMG_UINT32 ui32Ret;
+
+
+ HostAquireMutex(g_pvAPIMutex);
+
+ ui32Ret=DBGDrivWritePersist(psStream, pui8InBuf, ui32InBuffSize, ui32Level);
+ if(ui32Ret==0xFFFFFFFFU)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "An error occurred in DBGDrivWritePersist."));
+ }
+
+
+ HostReleaseMutex(g_pvAPIMutex);
+
+ return ui32Ret;
+}
+
IMG_UINT32 IMG_CALLCONV ExtDBGDrivWriteStringCM(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
{
IMG_UINT32 ui32Ret;
}
-IMG_BOOL StreamValid(PDBG_STREAM psStream)
+static IMG_BOOL StreamValid(PDBG_STREAM psStream)
{
PDBG_STREAM psThis;
while (psThis)
{
- if (psStream && (psThis == psStream))
+ if (psStream && (psThis == psStream) )
{
return(IMG_TRUE);
}
}
-void Write(PDBG_STREAM psStream,IMG_UINT8 * pui8Data,IMG_UINT32 ui32InBuffSize)
+static IMG_BOOL StreamValidForRead(PDBG_STREAM psStream)
+{
+ if( StreamValid(psStream) &&
+ ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_WRITEONLY) == 0) )
+ {
+ return(IMG_TRUE);
+ }
+
+ return(IMG_FALSE);
+}
+
+static IMG_BOOL StreamValidForWrite(PDBG_STREAM psStream)
+{
+ if( StreamValid(psStream) &&
+ ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_READONLY) == 0) )
+ {
+ return(IMG_TRUE);
+ }
+
+ return(IMG_FALSE);
+}
+
+
+static void Write(PDBG_STREAM psStream,IMG_PUINT8 pui8Data,IMG_UINT32 ui32InBuffSize)
{
+ if (!psStream->bCircularAllowed)
+ {
+
+ }
+
if ((psStream->ui32WPtr + ui32InBuffSize) > psStream->ui32Size)
- {
+ {
+
IMG_UINT32 ui32B1 = psStream->ui32Size - psStream->ui32WPtr;
IMG_UINT32 ui32B2 = ui32InBuffSize - ui32B1;
- HostMemCopy((IMG_VOID *)(psStream->ui32Base + psStream->ui32WPtr),
- (IMG_VOID *) pui8Data,
+ HostMemCopy((IMG_PVOID)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32WPtr),
+ (IMG_PVOID) pui8Data,
ui32B1);
- HostMemCopy((IMG_VOID *)psStream->ui32Base,
- (IMG_VOID *)((IMG_UINT32) pui8Data + ui32B1),
+ HostMemCopy(psStream->pvBase,
+ (IMG_PVOID)(pui8Data + ui32B1),
ui32B2);
}
else
{
- HostMemCopy((IMG_VOID *)(psStream->ui32Base + psStream->ui32WPtr),
- (IMG_VOID *) pui8Data,
+ HostMemCopy((IMG_PVOID)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32WPtr),
+ (IMG_PVOID) pui8Data,
ui32InBuffSize);
psStream->ui32WPtr += ui32InBuffSize;
void MonoOut(IMG_CHAR * pszString,IMG_BOOL bNewLine)
{
+#if defined (_WIN64)
+ PVR_UNREFERENCED_PARAMETER(pszString);
+ PVR_UNREFERENCED_PARAMETER(bNewLine);
+
+#else
IMG_UINT32 i;
IMG_CHAR * pScreen;
HostMemSet((IMG_VOID *)(DBGDRIV_MONOBASE + (160 * (g_ui32MonoLines - 1))),0,160);
}
+#endif
}
+static IMG_UINT32 WriteExpandingBuffer(PDBG_STREAM psStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize)
+{
+ IMG_UINT ui32Space;
+
-void AppendName(IMG_CHAR * pszOut,IMG_CHAR * pszBase,IMG_CHAR * pszName)
-{
- IMG_UINT32 i;
- IMG_UINT32 ui32Off;
+ ui32Space = SpaceInStream(psStream);
- i = 0;
+
- while (pszBase[i] != 0)
+ if ((psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
{
- pszOut[i] = pszBase[i];
- i++;
+ PVR_DPF((PVR_DBG_ERROR, "WriteExpandingBuffer: buffer %x is disabled", (IMG_UINTPTR_T) psStream));
+ return(0);
}
- ui32Off = i;
- i = 0;
+
- while (pszName[i] != 0)
+ if (psStream->psCtrl->ui32Flags & DEBUG_FLAGS_NO_BUF_EXPANDSION)
{
- pszOut[ui32Off+i] = pszName[i];
- i++;
+
+
+
+ if (ui32Space < 32)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "WriteExpandingBuffer: buffer %x is full and isn't expandable", (IMG_UINTPTR_T) psStream));
+ return(0);
+ }
}
+ else
+ {
+ if ((ui32Space < 32) || (ui32Space <= (ui32InBuffSize + 4)))
+ {
+ IMG_UINT32 ui32NewBufSize;
- pszOut[ui32Off+i] = pszName[i];
-}
+
+
+ ui32NewBufSize = 2 * psStream->ui32Size;
+
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Expanding buffer size = %x, new size = %x",
+ psStream->ui32Size, ui32NewBufSize));
+
+ if (ui32InBuffSize > psStream->ui32Size)
+ {
+ ui32NewBufSize += ui32InBuffSize;
+ }
+
+
+ if (!ExpandStreamBuffer(psStream,ui32NewBufSize))
+ {
+ if (ui32Space < 32)
+ {
+ if(psStream->bCircularAllowed)
+ {
+ return(0);
+ }
+ else
+ {
+
+ PVR_DPF((PVR_DBG_ERROR, "WriteExpandingBuffer: Unable to expand %x. Out of memory.", (IMG_UINTPTR_T) psStream));
+ InvalidateAllStreams();
+ return (0xFFFFFFFFUL);
+ }
+ }
+ }
+
+
+
+ ui32Space = SpaceInStream(psStream);
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Expanded buffer, free space = %x",
+ ui32Space));
+ }
+ }
+
+
+
+ if (ui32Space <= (ui32InBuffSize + 4))
+ {
+ ui32InBuffSize = ui32Space - 4;
+ }
+
+
+
+ Write(psStream,pui8InBuf,ui32InBuffSize);
+
+#if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
+ if (ui32InBuffSize)
+ {
+ HostSignalEvent(DBG_EVENT_STREAM_DATA);
+ }
+#endif
+ return(ui32InBuffSize);
+}
IMG_VOID * IMG_CALLCONV DBGDrivCreateStream(IMG_CHAR * pszName,
IMG_UINT32 ui32CapMode,
IMG_UINT32 ui32Flags,
IMG_UINT32 ui32Size)
{
- PDBG_STREAM psStream;
+ PDBG_STREAM psStream;
PDBG_STREAM psInitStream;
PDBG_LASTFRAME_BUFFER psLFBuffer;
+ PDBG_STREAM_CONTROL psCtrl;
IMG_UINT32 ui32Off;
IMG_VOID * pvBase;
+ static IMG_CHAR pszNameInitSuffix[] = "_Init";
+ IMG_UINT32 ui32OffSuffix;
psStream = HostNonPageablePageAlloc(1);
psInitStream = HostNonPageablePageAlloc(1);
psLFBuffer = HostNonPageablePageAlloc(1);
+ psCtrl = HostNonPageablePageAlloc(1);
if (
(!psStream) ||
(!psInitStream) ||
- (!psLFBuffer)
+ (!psLFBuffer) ||
+ (!psCtrl)
)
{
PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc control structs\n\r"));
}
+ psCtrl->ui32Flags = ui32Flags;
+ psCtrl->ui32CapMode = ui32CapMode;
+ psCtrl->ui32OutMode = ui32OutMode;
+ psCtrl->ui32DebugLevel = DEBUG_LEVEL_0;
+ psCtrl->ui32DefaultMode = ui32CapMode;
+ psCtrl->ui32Start = 0;
+ psCtrl->ui32End = 0;
+ psCtrl->ui32Current = 0;
+ psCtrl->ui32SampleRate = 1;
+ psCtrl->bInitPhaseComplete = IMG_FALSE;
+
+
psStream->psNext = 0;
- psStream->ui32Flags = ui32Flags;
- psStream->ui32Base = (IMG_UINT32)pvBase;
+ psStream->pvBase = pvBase;
+ psStream->psCtrl = psCtrl;
psStream->ui32Size = ui32Size * 4096UL;
psStream->ui32RPtr = 0;
psStream->ui32WPtr = 0;
psStream->ui32DataWritten = 0;
- psStream->ui32CapMode = ui32CapMode;
- psStream->ui32OutMode = ui32OutMode;
- psStream->ui32DebugLevel = DEBUG_LEVEL_0;
- psStream->ui32DefaultMode = ui32CapMode;
- psStream->ui32Start = 0;
- psStream->ui32End = 0;
- psStream->ui32Current = 0;
- psStream->ui32SampleRate = 1;
- psStream->ui32Access = 0;
- psStream->ui32Timeout = 0;
psStream->ui32Marker = 0;
- psStream->bInitPhaseComplete = IMG_FALSE;
+ psStream->bCircularAllowed = IMG_TRUE;
+ psStream->ui32InitPhaseWOff = 0;
+
+
if ((ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc InitStream buffer\n\r"));
- if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
- HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
+ HostNonPageablePageFree(psStream->pvBase);
}
else
{
- HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
+ HostPageablePageFree(psStream->pvBase);
}
HostNonPageablePageFree(psStream);
return((IMG_VOID *) 0);
}
+
psInitStream->psNext = 0;
- psInitStream->ui32Flags = ui32Flags;
- psInitStream->ui32Base = (IMG_UINT32)pvBase;
+ psInitStream->pvBase = pvBase;
+ psInitStream->psCtrl = psCtrl;
psInitStream->ui32Size = ui32Size * 4096UL;
psInitStream->ui32RPtr = 0;
psInitStream->ui32WPtr = 0;
psInitStream->ui32DataWritten = 0;
- psInitStream->ui32CapMode = ui32CapMode;
- psInitStream->ui32OutMode = ui32OutMode;
- psInitStream->ui32DebugLevel = DEBUG_LEVEL_0;
- psInitStream->ui32DefaultMode = ui32CapMode;
- psInitStream->ui32Start = 0;
- psInitStream->ui32End = 0;
- psInitStream->ui32Current = 0;
- psInitStream->ui32SampleRate = 1;
- psInitStream->ui32Access = 0;
- psInitStream->ui32Timeout = 0;
psInitStream->ui32Marker = 0;
- psInitStream->bInitPhaseComplete = IMG_FALSE;
+ psInitStream->bCircularAllowed = IMG_FALSE;
+ psInitStream->ui32InitPhaseWOff = 0;
+
+
psStream->psInitStream = psInitStream;
do
{
psStream->szName[ui32Off] = pszName[ui32Off];
-
+ psInitStream->szName[ui32Off] = pszName[ui32Off];
ui32Off++;
}
while ((pszName[ui32Off] != 0) && (ui32Off < (4096UL - sizeof(DBG_STREAM))));
-
psStream->szName[ui32Off] = pszName[ui32Off];
+ ui32OffSuffix = 0;
+ do
+ {
+ psInitStream->szName[ui32Off] = pszNameInitSuffix[ui32OffSuffix];
+ ui32Off++;
+ ui32OffSuffix++;
+ }
+ while ( (pszNameInitSuffix[ui32OffSuffix] != 0) &&
+ (ui32Off < (4096UL - sizeof(DBG_STREAM))));
+ psInitStream->szName[ui32Off] = pszNameInitSuffix[ui32OffSuffix];
+
+
+
psStream->psNext = g_psStreamList;
g_psStreamList = psStream;
psLFBuffer->psNext = g_psLFBufferList;
g_psLFBufferList = psLFBuffer;
-
+ AddSIDEntry(psStream);
+
return((IMG_VOID *) psStream);
}
return;
}
+ RemoveSIDEntry(psStream);
+
psLFBuffer = FindLFBuf(psStream);
}
- if (psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
{
DeactivateHotKeys();
}
- if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
- HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
- HostNonPageablePageFree((IMG_VOID *)psStream->psInitStream->ui32Base);
+ HostNonPageablePageFree(psStream->psCtrl);
+ HostNonPageablePageFree(psStream->pvBase);
+ HostNonPageablePageFree(psStream->psInitStream->pvBase);
}
else
{
- HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
- HostPageablePageFree((IMG_VOID *)psStream->psInitStream->ui32Base);
+ HostNonPageablePageFree(psStream->psCtrl);
+ HostPageablePageFree(psStream->pvBase);
+ HostPageablePageFree(psStream->psInitStream->pvBase);
}
HostNonPageablePageFree(psStream->psInitStream);
psStream = 0;
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "PDump client connecting to %s %s",
+ pszName,
+ (bResetStream == IMG_TRUE) ? "with reset" : "no reset"));
+
for (psThis = g_psStreamList; psThis != IMG_NULL; psThis = psThis->psNext)
psStream->ui32RPtr = 0;
psStream->ui32WPtr = 0;
psStream->ui32DataWritten = psStream->psInitStream->ui32DataWritten;
- if (psStream->bInitPhaseComplete == IMG_FALSE)
+ if (psStream->psCtrl->bInitPhaseComplete == IMG_FALSE)
{
- if (psStream->ui32Flags & DEBUG_FLAGS_TEXTSTREAM)
+ if (psStream->psCtrl->ui32Flags & DEBUG_FLAGS_TEXTSTREAM)
{
DBGDrivWrite2(psStream, (IMG_UINT8 *)szComment, sizeof(szComment) - 1, 0x01);
}
- psStream->bInitPhaseComplete = IMG_TRUE;
+ psStream->psCtrl->bInitPhaseComplete = IMG_TRUE;
+ }
+
+ {
+
+
+ psStream->psInitStream->ui32InitPhaseWOff = psStream->psInitStream->ui32WPtr;
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Set %s client marker bo %x, total bw %x",
+ psStream->szName,
+ psStream->psInitStream->ui32InitPhaseWOff,
+ psStream->psInitStream->ui32DataWritten ));
}
}
return((IMG_VOID *) psStream);
}
+static void IMG_CALLCONV DBGDrivInvalidateStream(PDBG_STREAM psStream)
+{
+ IMG_CHAR pszErrorMsg[] = "**OUTOFMEM\n";
+ IMG_UINT32 ui32Space;
+ IMG_UINT32 ui32Off = 0;
+ IMG_UINT32 ui32WPtr = psStream->ui32WPtr;
+ IMG_PUINT8 pui8Buffer = (IMG_UINT8 *) psStream->pvBase;
+
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivInvalidateStream: An error occurred for stream %s\r\n", psStream->szName ));
+
+
+
+
+
+
+
+
+
+ ui32Space = SpaceInStream(psStream);
+
+
+ if(ui32Space > 0)
+ {
+ ui32Space--;
+ }
+ else
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivInvalidateStream: Buffer full."));
+ }
+
+ while((pszErrorMsg[ui32Off] != 0) && (ui32Off < ui32Space))
+ {
+ pui8Buffer[ui32WPtr] = (IMG_UINT8)pszErrorMsg[ui32Off];
+ ui32Off++;
+ ui32WPtr++;
+ }
+ pui8Buffer[ui32WPtr++] = '\0';
+ psStream->ui32WPtr = ui32WPtr;
+
+
+ psStream->psCtrl->ui32Flags |= DEBUG_FLAGS_READONLY;
+}
+
+static IMG_VOID InvalidateAllStreams(IMG_VOID)
+{
+ PDBG_STREAM psStream = g_psStreamList;
+ while (psStream != IMG_NULL)
+ {
+ DBGDrivInvalidateStream(psStream);
+ psStream = psStream->psNext;
+ }
+ return;
+}
+
+
+
IMG_UINT32 IMG_CALLCONV DBGDrivWriteStringCM(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
{
- if (!StreamValid(psStream))
+ if (!StreamValidForWrite(psStream))
{
return(0xFFFFFFFFUL);
}
- if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED)
{
- if ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
{
return(0);
}
}
else
{
- if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
+ if (psStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
- if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
+ if ((psStream->psCtrl->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
{
return(0);
}
- if (!StreamValid(psStream))
+ if (!StreamValidForWrite(psStream))
{
return(0xFFFFFFFFUL);
}
- if ((psStream->ui32DebugLevel & ui32Level) == 0)
+ if ((psStream->psCtrl->ui32DebugLevel & ui32Level) == 0)
{
return(0xFFFFFFFFUL);
}
- if ((psStream->ui32OutMode & DEBUG_OUTMODE_ASYNC) == 0)
+ if ((psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_ASYNC) == 0)
{
- if (psStream->ui32OutMode & DEBUG_OUTMODE_STANDARDDBG)
+ if (psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_STANDARDDBG)
{
PVR_DPF((PVR_DBG_MESSAGE,"%s: %s\r\n",psStream->szName, pszString));
}
- if (psStream->ui32OutMode & DEBUG_OUTMODE_MONO)
+ if (psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_MONO)
{
MonoOut(psStream->szName,IMG_FALSE);
MonoOut(": ",IMG_FALSE);
if (
!(
- ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) != 0) ||
- ((psStream->ui32OutMode & DEBUG_OUTMODE_ASYNC) != 0)
+ ((psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) != 0) ||
+ ((psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_ASYNC) != 0)
)
)
{
ui32Space=SpaceInStream(psStream);
+
if(ui32Space > 0)
{
ui32Space--;
ui32Len = 0;
ui32WPtr = psStream->ui32WPtr;
- pui8Buffer = (IMG_UINT8 *) psStream->ui32Base;
+ pui8Buffer = (IMG_UINT8 *) psStream->pvBase;
while((pszString[ui32Len] != 0) && (ui32Len < ui32Space))
{
- if (!StreamValid(psStream))
+ if (!StreamValidForRead(psStream))
{
return(0);
}
- pui8Buff = (IMG_UINT8 *) psStream->ui32Base;
+ pui8Buff = (IMG_UINT8 *)psStream->pvBase;
ui32Offset = psStream->ui32RPtr;
if (psStream->ui32RPtr == psStream->ui32WPtr)
- if (!StreamValid(psMainStream))
+ if (!StreamValidForWrite(psMainStream))
{
return(0xFFFFFFFFUL);
}
- if ((psMainStream->ui32DebugLevel & ui32Level) == 0)
+ if ((psMainStream->psCtrl->ui32DebugLevel & ui32Level) == 0)
{
return(0xFFFFFFFFUL);
}
- if (psMainStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
+ if (psMainStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED)
{
- if ((psMainStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
+ if ((psMainStream->psCtrl->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
{
- return(0xFFFFFFFFUL);
+
+ return(ui32InBuffSize);
}
}
- else if (psMainStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
+ else if (psMainStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
- if ((psMainStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
- return(0xFFFFFFFFUL);
+ if ((psMainStream->psCtrl->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
+ {
+
+ return(ui32InBuffSize);
+ }
}
- if(psMainStream->bInitPhaseComplete)
+ if(psMainStream->psCtrl->bInitPhaseComplete)
{
psStream = psMainStream;
}
ui32Space=SpaceInStream(psStream);
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Recv %d b for %s: Roff = %x, WOff = %x",
+ ui32InBuffSize,
+ psStream->szName,
+ psStream->ui32RPtr,
+ psStream->ui32WPtr));
+
- if ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
+ if ((psStream->psCtrl->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
{
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivWrite: buffer %x is disabled", (IMG_UINTPTR_T) psStream));
return(0);
}
if (ui32Space < 8)
{
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivWrite: buffer %x is full", (IMG_UINTPTR_T) psStream));
return(0);
}
{
- if (!StreamValid(psStream))
+ if (!StreamValidForWrite(psStream))
{
return(0xFFFFFFFFUL);
}
- if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED)
{
- if ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
{
- return(0xFFFFFFFFUL);
+
+ return(ui32InBuffSize);
}
}
else
{
- if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
+ if (psStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
- if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
+ if ((psStream->psCtrl->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
{
- return(0xFFFFFFFFUL);
+
+ return(ui32InBuffSize);
}
}
}
return(DBGDrivWrite2(psStream,pui8InBuf,ui32InBuffSize,ui32Level));
}
-IMG_UINT32 IMG_CALLCONV DBGDrivWrite2(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
+
+static IMG_UINT32 DBGDrivWritePersist(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
{
- IMG_UINT32 ui32Space;
DBG_STREAM *psStream;
+ PVR_UNREFERENCED_PARAMETER(ui32Level);
- if (!StreamValid(psMainStream))
+ if (!StreamValidForWrite(psMainStream))
{
return(0xFFFFFFFFUL);
}
-
- if ((psMainStream->ui32DebugLevel & ui32Level) == 0)
+ psStream = psMainStream->psInitStream;
+ if(psStream->bCircularAllowed == IMG_TRUE)
{
- return(0xFFFFFFFFUL);
+ PVR_DPF((PVR_DBG_WARNING, "DBGDrivWritePersist: Init phase is a circular buffer, some data may be lost"));
}
- if(psMainStream->bInitPhaseComplete)
- {
- psStream = psMainStream;
- }
- else
- {
- psStream = psMainStream->psInitStream;
- }
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Append %x b to %s: Roff = %x, WOff = %x [bw = %x]",
+ ui32InBuffSize,
+ psStream->szName,
+ psStream->ui32RPtr,
+ psStream->ui32WPtr,
+ psStream->ui32DataWritten));
-
+ return( WriteExpandingBuffer(psStream, pui8InBuf, ui32InBuffSize) );
+}
- ui32Space=SpaceInStream(psStream);
+IMG_UINT32 IMG_CALLCONV DBGDrivWrite2(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
+{
+ DBG_STREAM *psStream;
- if ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
+ if (!StreamValidForWrite(psMainStream))
{
- return(0);
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivWrite2: stream not valid"));
+ return(0xFFFFFFFFUL);
}
- if (psStream->ui32Flags & DEBUG_FLAGS_NO_BUF_EXPANDSION)
+ if ((psMainStream->psCtrl->ui32DebugLevel & ui32Level) == 0)
{
-
-
-
- if (ui32Space < 32)
- {
- return(0);
- }
+ return(0);
}
- else
- {
- if ((ui32Space < 32) || (ui32Space <= (ui32InBuffSize + 4)))
- {
- IMG_UINT32 ui32NewBufSize;
-
-
-
- ui32NewBufSize = 2 * psStream->ui32Size;
-
- if (ui32InBuffSize > psStream->ui32Size)
- {
- ui32NewBufSize += ui32InBuffSize;
- }
-
-
- if (!ExpandStreamBuffer(psStream,ui32NewBufSize))
- {
- if (ui32Space < 32)
- {
- return(0);
- }
- }
-
-
-
- ui32Space = SpaceInStream(psStream);
- }
+ if(psMainStream->psCtrl->bInitPhaseComplete)
+ {
+ psStream = psMainStream;
}
-
-
-
- if (ui32Space <= (ui32InBuffSize + 4))
+ else
{
- ui32InBuffSize = ui32Space - 4;
+ psStream = psMainStream->psInitStream;
}
-
-
- Write(psStream,pui8InBuf,ui32InBuffSize);
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Recv(exp) %d b for %s: Roff = %x, WOff = %x",
+ ui32InBuffSize,
+ psStream->szName,
+ psStream->ui32RPtr,
+ psStream->ui32WPtr));
-#if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
- if (ui32InBuffSize)
- {
- HostSignalEvent(DBG_EVENT_STREAM_DATA);
- }
-#endif
- return(ui32InBuffSize);
+ return( WriteExpandingBuffer(psStream, pui8InBuf, ui32InBuffSize) );
}
IMG_UINT32 IMG_CALLCONV DBGDrivRead(PDBG_STREAM psMainStream, IMG_BOOL bReadInitBuffer, IMG_UINT32 ui32OutBuffSize,IMG_UINT8 * pui8OutBuf)
- if (!StreamValid(psMainStream))
+ if (!StreamValidForRead(psMainStream))
{
+ PVR_DPF((PVR_DBG_ERROR, "DBGDrivRead: buffer %x is invalid", (IMG_UINTPTR_T) psMainStream));
return(0);
}
psStream = psMainStream;
}
- if (psStream->ui32RPtr == psStream->ui32WPtr)
+
+ if (psStream->ui32RPtr == psStream->ui32WPtr ||
+ ((psStream->ui32InitPhaseWOff > 0) &&
+ (psStream->ui32RPtr >= psStream->ui32InitPhaseWOff)) )
{
return(0);
}
+ if ((psStream->ui32InitPhaseWOff > 0) &&
+ (psStream->ui32InitPhaseWOff < psStream->ui32WPtr))
+ {
+ ui32Data = psStream->ui32InitPhaseWOff - psStream->ui32RPtr;
+ }
+
+
+
if (ui32Data > ui32OutBuffSize)
{
ui32Data = ui32OutBuffSize;
}
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "Send %x b from %s: Roff = %x, WOff = %x",
+ ui32Data,
+ psStream->szName,
+ psStream->ui32RPtr,
+ psStream->ui32WPtr));
+
if ((psStream->ui32RPtr + ui32Data) > psStream->ui32Size)
HostMemCopy((IMG_VOID *) pui8OutBuf,
- (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr),
+ (IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
ui32B1);
- HostMemCopy((IMG_VOID *)((IMG_UINT32) pui8OutBuf + ui32B1),
- (IMG_VOID *)psStream->ui32Base,
+ HostMemCopy((IMG_VOID *)(pui8OutBuf + ui32B1),
+ psStream->pvBase,
ui32B2);
else
{
HostMemCopy((IMG_VOID *) pui8OutBuf,
- (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr),
+ (IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
ui32Data);
return;
}
- psStream->ui32CapMode = ui32Mode;
- psStream->ui32DefaultMode = ui32Mode;
- psStream->ui32Start = ui32Start;
- psStream->ui32End = ui32End;
- psStream->ui32SampleRate = ui32SampleRate;
+ psStream->psCtrl->ui32CapMode = ui32Mode;
+ psStream->psCtrl->ui32DefaultMode = ui32Mode;
+ psStream->psCtrl->ui32Start = ui32Start;
+ psStream->psCtrl->ui32End = ui32End;
+ psStream->psCtrl->ui32SampleRate = ui32SampleRate;
- if (psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
{
ActivateHotKeys(psStream);
}
return;
}
- psStream->ui32OutMode = ui32OutMode;
+ psStream->psCtrl->ui32OutMode = ui32OutMode;
}
void IMG_CALLCONV DBGDrivSetDebugLevel(PDBG_STREAM psStream,IMG_UINT32 ui32DebugLevel)
return;
}
- psStream->ui32DebugLevel = ui32DebugLevel;
+ psStream->psCtrl->ui32DebugLevel = ui32DebugLevel;
}
void IMG_CALLCONV DBGDrivSetFrame(PDBG_STREAM psStream,IMG_UINT32 ui32Frame)
return;
}
- psStream->ui32Current = ui32Frame;
+ psStream->psCtrl->ui32Current = ui32Frame;
- if ((ui32Frame >= psStream->ui32Start) &&
- (ui32Frame <= psStream->ui32End) &&
- (((ui32Frame - psStream->ui32Start) % psStream->ui32SampleRate) == 0))
+ if ((ui32Frame >= psStream->psCtrl->ui32Start) &&
+ (ui32Frame <= psStream->psCtrl->ui32End) &&
+ (((ui32Frame - psStream->psCtrl->ui32Start) % psStream->psCtrl->ui32SampleRate) == 0))
{
- psStream->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
+ psStream->psCtrl->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
}
else
{
- psStream->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
+ psStream->psCtrl->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
}
if (g_bHotkeyMiddump)
{
if ((ui32Frame >= g_ui32HotkeyMiddumpStart) &&
(ui32Frame <= g_ui32HotkeyMiddumpEnd) &&
- (((ui32Frame - g_ui32HotkeyMiddumpStart) % psStream->ui32SampleRate) == 0))
+ (((ui32Frame - g_ui32HotkeyMiddumpStart) % psStream->psCtrl->ui32SampleRate) == 0))
{
- psStream->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
+ psStream->psCtrl->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
}
else
{
- psStream->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
- if (psStream->ui32Current > g_ui32HotkeyMiddumpEnd)
+ psStream->psCtrl->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
+ if (psStream->psCtrl->ui32Current > g_ui32HotkeyMiddumpEnd)
{
g_bHotkeyMiddump = IMG_FALSE;
}
{
g_bHotKeyRegistered = IMG_FALSE;
- PVR_DPF((PVR_DBG_MESSAGE,"Hotkey pressed (%08x)!\n",psStream));
+ PVR_DPF((PVR_DBG_MESSAGE,"Hotkey pressed (%p)!\n",psStream));
if (!g_bHotKeyPressed)
{
- g_ui32HotKeyFrame = psStream->ui32Current + 2;
+ g_ui32HotKeyFrame = psStream->psCtrl->ui32Current + 2;
- if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
- ((psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY) != 0))
+ if (((psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
+ ((psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_HOTKEY) != 0))
{
if (!g_bHotkeyMiddump)
{
g_ui32HotkeyMiddumpStart = g_ui32HotKeyFrame + 1;
g_ui32HotkeyMiddumpEnd = 0xffffffff;
g_bHotkeyMiddump = IMG_TRUE;
- PVR_DPF((PVR_DBG_MESSAGE,"Sampling every %d frame(s)\n", psStream->ui32SampleRate));
+ PVR_DPF((PVR_DBG_MESSAGE,"Sampling every %d frame(s)\n", psStream->psCtrl->ui32SampleRate));
}
else
{
- if (psStream->ui32Current > g_ui32HotKeyFrame)
+ if (psStream->psCtrl->ui32Current > g_ui32HotKeyFrame)
{
g_bHotKeyPressed = IMG_FALSE;
}
return(0);
}
- return(psStream->ui32Current);
+ return(psStream->psCtrl->ui32Current);
}
IMG_BOOL IMG_CALLCONV DBGDrivIsLastCaptureFrame(PDBG_STREAM psStream)
return IMG_FALSE;
}
- if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED)
{
- ui32NextFrame = psStream->ui32Current + psStream->ui32SampleRate;
- if (ui32NextFrame > psStream->ui32End)
+ ui32NextFrame = psStream->psCtrl->ui32Current + psStream->psCtrl->ui32SampleRate;
+ if (ui32NextFrame > psStream->psCtrl->ui32End)
{
return IMG_TRUE;
}
return IMG_FALSE;
}
- if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
+ if (psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED)
{
if (g_bHotkeyMiddump)
{
- if ((psStream->ui32Current >= (g_ui32HotkeyMiddumpStart - ui32FrameShift)) &&
- (psStream->ui32Current <= (g_ui32HotkeyMiddumpEnd - ui32FrameShift)) &&
- ((((psStream->ui32Current + ui32FrameShift) - g_ui32HotkeyMiddumpStart) % psStream->ui32SampleRate) == 0))
+ if ((psStream->psCtrl->ui32Current >= (g_ui32HotkeyMiddumpStart - ui32FrameShift)) &&
+ (psStream->psCtrl->ui32Current <= (g_ui32HotkeyMiddumpEnd - ui32FrameShift)) &&
+ ((((psStream->psCtrl->ui32Current + ui32FrameShift) - g_ui32HotkeyMiddumpStart) % psStream->psCtrl->ui32SampleRate) == 0))
{
return IMG_TRUE;
}
}
else
{
- if ((psStream->ui32Current >= (psStream->ui32Start - ui32FrameShift)) &&
- (psStream->ui32Current <= (psStream->ui32End - ui32FrameShift)) &&
- ((((psStream->ui32Current + ui32FrameShift) - psStream->ui32Start) % psStream->ui32SampleRate) == 0))
+ if ((psStream->psCtrl->ui32Current >= (psStream->psCtrl->ui32Start - ui32FrameShift)) &&
+ (psStream->psCtrl->ui32Current <= (psStream->psCtrl->ui32End - ui32FrameShift)) &&
+ ((((psStream->psCtrl->ui32Current + ui32FrameShift) - psStream->psCtrl->ui32Start) % psStream->psCtrl->ui32SampleRate) == 0))
{
return IMG_TRUE;
}
}
}
- else if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
+ else if (psStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
- if ((psStream->ui32Current == (g_ui32HotKeyFrame-ui32FrameShift)) && (g_bHotKeyPressed))
+ if ((psStream->psCtrl->ui32Current == (g_ui32HotKeyFrame-ui32FrameShift)) && (g_bHotKeyPressed))
{
return IMG_TRUE;
}
return;
}
- psStream->ui32CapMode = ui32Mode;
+ psStream->psCtrl->ui32CapMode = ui32Mode;
}
void IMG_CALLCONV DBGDrivDefaultMode(PDBG_STREAM psStream)
return;
}
- psStream->ui32CapMode = psStream->ui32DefaultMode;
+ psStream->psCtrl->ui32CapMode = psStream->psCtrl->ui32DefaultMode;
+}
+
+IMG_VOID IMG_CALLCONV DBGDrivSetClientMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
+{
+
+
+ if (!StreamValid(psStream))
+ {
+ return;
+ }
+
+ psStream->ui32InitPhaseWOff = ui32Marker;
}
void IMG_CALLCONV DBGDrivSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
return 0;
}
- if(psMainStream->bInitPhaseComplete)
+ if(psMainStream->psCtrl->bInitPhaseComplete)
{
psStream = psMainStream;
}
return;
}
- if(psMainStream->bInitPhaseComplete)
+ if(psMainStream->psCtrl->bInitPhaseComplete)
{
psStream = psMainStream;
}
psStream = psMainStream->psInitStream;
}
+ PVR_DPF((PVR_DBGDRIV_MESSAGE, "DBGDrivSetStreamOffset: %s set to %x b",
+ psStream->szName,
+ ui32StreamOffset));
psStream->ui32DataWritten = ui32StreamOffset;
}
-IMG_UINT32 IMG_CALLCONV DBGDrivGetServiceTable(void)
+IMG_PVOID IMG_CALLCONV DBGDrivGetServiceTable(IMG_VOID)
{
- return((IMG_UINT32) &g_sDBGKMServices);
+ return((IMG_PVOID)&g_sDBGKMServices);
}
IMG_UINT32 IMG_CALLCONV DBGDrivWriteLF(PDBG_STREAM psStream, IMG_UINT8 * pui8InBuf, IMG_UINT32 ui32InBuffSize, IMG_UINT32 ui32Level, IMG_UINT32 ui32Flags)
- if (!StreamValid(psStream))
+ if (!StreamValidForWrite(psStream))
{
return(0xFFFFFFFFUL);
}
- if ((psStream->ui32DebugLevel & ui32Level) == 0)
+ if ((psStream->psCtrl->ui32DebugLevel & ui32Level) == 0)
{
return(0xFFFFFFFFUL);
}
- if ((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0)
+ if ((psStream->psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0)
{
- if ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
{
- return(0xFFFFFFFFUL);
+
+ return(ui32InBuffSize);
}
}
- else if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
+ else if (psStream->psCtrl->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
{
- if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
- return(0xFFFFFFFFUL);
+ if ((psStream->psCtrl->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
+ {
+
+ return(ui32InBuffSize);
+ }
}
psLFBuffer = FindLFBuf(psStream);
- if (!StreamValid(psStream))
+ if (!StreamValidForRead(psStream))
{
return(0);
}
IMG_VOID IMG_CALLCONV DBGDrivStartInitPhase(PDBG_STREAM psStream)
{
- psStream->bInitPhaseComplete = IMG_FALSE;
+ psStream->psCtrl->bInitPhaseComplete = IMG_FALSE;
}
IMG_VOID IMG_CALLCONV DBGDrivStopInitPhase(PDBG_STREAM psStream)
{
- psStream->bInitPhaseComplete = IMG_TRUE;
+ psStream->psCtrl->bInitPhaseComplete = IMG_TRUE;
}
#if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
IMG_VOID * pvNewBuf;
IMG_UINT32 ui32NewSizeInPages;
IMG_UINT32 ui32NewWOffset;
+ IMG_UINT32 ui32NewROffset;
IMG_UINT32 ui32SpaceInOldBuf;
ui32NewSizeInPages = ((ui32NewSize + 0xfffUL) & ~0xfffUL) / 4096UL;
- if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
pvNewBuf = HostNonPageablePageAlloc(ui32NewSizeInPages);
}
return IMG_FALSE;
}
-
-
-
- if (psStream->ui32RPtr <= psStream->ui32WPtr)
+ if(psStream->bCircularAllowed)
{
- HostMemCopy((IMG_VOID *)pvNewBuf, (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr), psStream->ui32WPtr - psStream->ui32RPtr);
- }
- else
- {
- IMG_UINT32 ui32FirstCopySize;
-
+ if (psStream->ui32RPtr <= psStream->ui32WPtr)
+ {
+
- ui32FirstCopySize = psStream->ui32Size - psStream->ui32RPtr;
+ HostMemCopy(pvNewBuf,
+ (IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
+ psStream->ui32WPtr - psStream->ui32RPtr);
+ }
+ else
+ {
+ IMG_UINT32 ui32FirstCopySize;
+
+
- HostMemCopy((IMG_VOID *)pvNewBuf, (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr), ui32FirstCopySize);
+ ui32FirstCopySize = psStream->ui32Size - psStream->ui32RPtr;
+
+ HostMemCopy(pvNewBuf,
+ (IMG_VOID *)((IMG_UINTPTR_T)psStream->pvBase + psStream->ui32RPtr),
+ ui32FirstCopySize);
+
+
+ HostMemCopy((IMG_VOID *)((IMG_UINTPTR_T)pvNewBuf + ui32FirstCopySize),
+ (IMG_VOID *)(IMG_PBYTE)psStream->pvBase,
+ psStream->ui32WPtr);
+ }
+ ui32NewROffset = 0;
+ }
+ else
+ {
-
- HostMemCopy((IMG_VOID *)((IMG_UINT32)pvNewBuf + ui32FirstCopySize), (IMG_VOID *)psStream->ui32Base, psStream->ui32WPtr);
+ HostMemCopy(pvNewBuf, psStream->pvBase, psStream->ui32WPtr);
+ ui32NewROffset = psStream->ui32RPtr;
}
+
ui32NewWOffset = psStream->ui32Size - ui32SpaceInOldBuf;
- if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
+ if ((psStream->psCtrl->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
{
- HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
+ HostNonPageablePageFree(psStream->pvBase);
}
else
{
- HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
+ HostPageablePageFree(psStream->pvBase);
}
- psStream->ui32Base = (IMG_UINT32)pvNewBuf;
- psStream->ui32RPtr = 0;
+ psStream->pvBase = pvNewBuf;
+ psStream->ui32RPtr = ui32NewROffset;
psStream->ui32WPtr = ui32NewWOffset;
psStream->ui32Size = ui32NewSizeInPages * 4096;
{
IMG_UINT32 ui32Space;
+ if (psStream->bCircularAllowed)
+ {
+
if (psStream->ui32RPtr > psStream->ui32WPtr)
{
ui32Space = psStream->ui32RPtr - psStream->ui32WPtr;
{
ui32Space = psStream->ui32RPtr + (psStream->ui32Size - psStream->ui32WPtr);
}
+ }
+ else
+ {
+
+ ui32Space = psStream->ui32Size - psStream->ui32WPtr;
+ }
return ui32Space;
}
IMG_UINT32 IMG_CALLCONV DBGDrivGetFrame(PDBG_STREAM psStream);
IMG_VOID IMG_CALLCONV DBGDrivOverrideMode(PDBG_STREAM psStream,IMG_UINT32 ui32Mode);
IMG_VOID IMG_CALLCONV DBGDrivDefaultMode(PDBG_STREAM psStream);
-IMG_UINT32 IMG_CALLCONV DBGDrivGetServiceTable(IMG_VOID);
+IMG_PVOID IMG_CALLCONV DBGDrivGetServiceTable(IMG_VOID);
IMG_UINT32 IMG_CALLCONV DBGDrivWriteStringCM(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level);
IMG_UINT32 IMG_CALLCONV DBGDrivWriteCM(PDBG_STREAM psStream,IMG_UINT8 *pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level);
+IMG_VOID IMG_CALLCONV DBGDrivSetClientMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
IMG_VOID IMG_CALLCONV DBGDrivSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
IMG_UINT32 IMG_CALLCONV DBGDrivGetMarker(PDBG_STREAM psStream);
IMG_BOOL IMG_CALLCONV DBGDrivIsLastCaptureFrame(PDBG_STREAM psStream);
IMG_VOID HostMemSet(IMG_VOID *pvDest,IMG_UINT8 ui8Value,IMG_UINT32 ui32Size);
IMG_VOID HostMemCopy(IMG_VOID *pvDest,IMG_VOID *pvSrc,IMG_UINT32 ui32Size);
-IMG_BOOL StreamValid(PDBG_STREAM psStream);
-IMG_VOID Write(PDBG_STREAM psStream,IMG_UINT8 *pui8Data,IMG_UINT32 ui32InBuffSize);
IMG_VOID MonoOut(IMG_CHAR * pszString,IMG_BOOL bNewLine);
+IMG_SID PStream2SID(PDBG_STREAM psStream);
+PDBG_STREAM SID2PStream(IMG_SID hStream);
+IMG_BOOL AddSIDEntry(PDBG_STREAM psStream);
+IMG_BOOL RemoveSIDEntry(PDBG_STREAM psStream);
IMG_VOID * IMG_CALLCONV ExtDBGDrivCreateStream(IMG_CHAR * pszName, IMG_UINT32 ui32CapMode, IMG_UINT32 ui32OutMode, IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size);
IMG_VOID IMG_CALLCONV ExtDBGDrivDestroyStream(PDBG_STREAM psStream);
IMG_UINT32 IMG_CALLCONV ExtDBGDrivGetStreamOffset(PDBG_STREAM psStream);
IMG_VOID IMG_CALLCONV ExtDBGDrivSetStreamOffset(PDBG_STREAM psStream, IMG_UINT32 ui32StreamOffset);
IMG_VOID IMG_CALLCONV ExtDBGDrivWaitForEvent(DBG_EVENT eEvent);
+IMG_VOID IMG_CALLCONV ExtDBGDrivSetConnectNotifier(DBGKM_CONNECT_NOTIFIER fn_notifier);
+
+IMG_UINT32 IMG_CALLCONV ExtDBGDrivWritePersist(PDBG_STREAM psStream,IMG_UINT8 *pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level);
#endif
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#ifndef _IOCTL_
+#define _IOCTL_
+
+#define MAX_DBGVXD_W32_API 25
+
+extern IMG_UINT32 (*g_DBGDrivProc[MAX_DBGVXD_W32_API])(IMG_VOID *, IMG_VOID *);
+
+#endif
+
--- /dev/null
+/**********************************************************************
+ *
+ * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful but, except
+ * as otherwise stated in writing, without any warranty; without even the
+ * implied warranty of merchantability or fitness for a particular purpose.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
+ *
+ ******************************************************************************/
+
+#include "img_defs.h"
+#include "dbgdrvif.h"
+#include "dbgdriv.h"
+
+#define MAX_SID_ENTRIES 8
+
+typedef struct _SID_INFO
+{
+ PDBG_STREAM psStream;
+} SID_INFO, *PSID_INFO;
+
+static SID_INFO gaSID_Xlat_Table[MAX_SID_ENTRIES];
+
+IMG_SID PStream2SID(PDBG_STREAM psStream)
+{
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ IMG_INT32 iIdx;
+
+ for (iIdx = 0; iIdx < MAX_SID_ENTRIES; iIdx++)
+ {
+ if (psStream == gaSID_Xlat_Table[iIdx].psStream)
+ {
+
+ return (IMG_SID)iIdx+1;
+ }
+ }
+ }
+
+ return (IMG_SID)0;
+}
+
+
+PDBG_STREAM SID2PStream(IMG_SID hStream)
+{
+
+ IMG_INT32 iIdx = (IMG_INT32)hStream-1;
+
+ if (iIdx >= 0 && iIdx < MAX_SID_ENTRIES)
+ {
+ return gaSID_Xlat_Table[iIdx].psStream;
+ }
+ else
+ {
+ return (PDBG_STREAM)IMG_NULL;
+ }
+}
+
+
+IMG_BOOL AddSIDEntry(PDBG_STREAM psStream)
+{
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ IMG_INT32 iIdx;
+
+ for (iIdx = 0; iIdx < MAX_SID_ENTRIES; iIdx++)
+ {
+ if (psStream == gaSID_Xlat_Table[iIdx].psStream)
+ {
+
+ return IMG_TRUE;
+ }
+
+ if (gaSID_Xlat_Table[iIdx].psStream == (PDBG_STREAM)IMG_NULL)
+ {
+
+ gaSID_Xlat_Table[iIdx].psStream = psStream;
+ return IMG_TRUE;
+ }
+ }
+ }
+
+ return IMG_FALSE;
+}
+
+IMG_BOOL RemoveSIDEntry(PDBG_STREAM psStream)
+{
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ IMG_INT32 iIdx;
+
+ for (iIdx = 0; iIdx < MAX_SID_ENTRIES; iIdx++)
+ {
+ if (psStream == gaSID_Xlat_Table[iIdx].psStream)
+ {
+ gaSID_Xlat_Table[iIdx].psStream = (PDBG_STREAM)IMG_NULL;
+ return IMG_TRUE;
+ }
+ }
+ }
+
+ return IMG_FALSE;
+}
+
+
{
- g_ui32HotKeyFrame = psStream->ui32Current + 2;
+ g_ui32HotKeyFrame = psStream->psCtrl->ui32Current + 2;
#ifdef LINUX
#include <asm/uaccess.h>
+#include "pvr_uaccess.h"
#endif
#include "img_types.h"
#include "dbgdrvif.h"
#include "dbgdriv.h"
#include "hotkey.h"
+#include "dbgdriv_ioctl.h"
-IMG_UINT32 DBGDIOCDrivCreateStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivCreateStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_CREATESTREAM psIn;
IMG_VOID * *ppvOut;
#ifdef LINUX
- if(copy_from_user(name, psIn->pszName, 32) != 0)
+ if(pvr_copy_from_user(name, psIn->u.pszName, 32) != 0)
{
return IMG_FALSE;
}
*ppvOut = ExtDBGDrivCreateStream(name, psIn->ui32CapMode, psIn->ui32OutMode, 0, psIn->ui32Pages);
#else
- *ppvOut = ExtDBGDrivCreateStream(psIn->pszName, psIn->ui32CapMode, psIn->ui32OutMode, DEBUG_FLAGS_NO_BUF_EXPANDSION, psIn->ui32Pages);
+ *ppvOut = ExtDBGDrivCreateStream(psIn->u.pszName, psIn->ui32CapMode, psIn->ui32OutMode, DEBUG_FLAGS_NO_BUF_EXPANDSION, psIn->ui32Pages);
#endif
return(IMG_TRUE);
}
-IMG_UINT32 DBGDIOCDrivDestroyStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivDestroyStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pStream;
- PDBG_STREAM psStream;
+ PDBG_STREAM *ppsStream;
+ PDBG_STREAM psStream;
- pStream = (IMG_UINT32 *) pvInBuffer;
- psStream = (PDBG_STREAM) *pStream;
+ ppsStream = (PDBG_STREAM *) pvInBuffer;
+ psStream = (PDBG_STREAM) *ppsStream;
PVR_UNREFERENCED_PARAMETER( pvOutBuffer);
return(IMG_TRUE);
}
-IMG_UINT32 DBGDIOCDrivGetStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivGetStream(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_FINDSTREAM psParams;
- IMG_UINT32 * pui32Stream;
+ IMG_SID * phStream;
- psParams = (PDBG_IN_FINDSTREAM)pvInBuffer;
- pui32Stream = (IMG_UINT32 *)pvOutBuffer;
+ psParams = (PDBG_IN_FINDSTREAM)pvInBuffer;
+ phStream = (IMG_SID *)pvOutBuffer;
- *pui32Stream = (IMG_UINT32)ExtDBGDrivFindStream(psParams->pszName, psParams->bResetStream);
+ *phStream = PStream2SID(ExtDBGDrivFindStream(psParams->u.pszName, psParams->bResetStream));
return(IMG_TRUE);
}
-IMG_UINT32 DBGDIOCDrivWriteString(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWriteString(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_WRITESTRING psParams;
- IMG_UINT32 * pui32OutLen;
+ IMG_UINT32 *pui32OutLen;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_WRITESTRING) pvInBuffer;
pui32OutLen = (IMG_UINT32 *) pvOutBuffer;
- *pui32OutLen = ExtDBGDrivWriteString((PDBG_STREAM) psParams->pvStream,psParams->pszString,psParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32OutLen = ExtDBGDrivWriteString(psStream,psParams->u.pszString,psParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32OutLen = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivWriteStringCM(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWriteStringCM(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_WRITESTRING psParams;
- IMG_UINT32 * pui32OutLen;
+ IMG_UINT32 *pui32OutLen;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_WRITESTRING) pvInBuffer;
pui32OutLen = (IMG_UINT32 *) pvOutBuffer;
- *pui32OutLen = ExtDBGDrivWriteStringCM((PDBG_STREAM) psParams->pvStream,psParams->pszString,psParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32OutLen = ExtDBGDrivWriteStringCM(psStream,psParams->u.pszString,psParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32OutLen = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivReadString(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivReadString(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32OutLen;
+ IMG_UINT32 * pui32OutLen;
PDBG_IN_READSTRING psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_READSTRING) pvInBuffer;
pui32OutLen = (IMG_UINT32 *) pvOutBuffer;
- *pui32OutLen = ExtDBGDrivReadString(psParams->pvStream,psParams->pszString,psParams->ui32StringLen);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32OutLen = ExtDBGDrivReadString(psStream,
+ psParams->u.pszString,psParams->ui32StringLen);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32OutLen = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivWrite(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWrite(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32BytesCopied;
- PDBG_IN_WRITE psInParams;
+ IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_WRITE psInParams;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_WRITE) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivWrite((PDBG_STREAM) psInParams->pvStream,psInParams->pui8InBuffer,psInParams->ui32TransferSize,psInParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivWrite(psStream,
+ psInParams->u.pui8InBuffer,
+ psInParams->ui32TransferSize,
+ psInParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32BytesCopied = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivWrite2(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWrite2(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32BytesCopied;
- PDBG_IN_WRITE psInParams;
+ IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_WRITE psInParams;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_WRITE) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivWrite2((PDBG_STREAM) psInParams->pvStream,psInParams->pui8InBuffer,psInParams->ui32TransferSize,psInParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivWrite2(psStream,
+ psInParams->u.pui8InBuffer,
+ psInParams->ui32TransferSize,
+ psInParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32BytesCopied = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivWriteCM(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWriteCM(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32BytesCopied;
- PDBG_IN_WRITE psInParams;
+ IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_WRITE psInParams;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_WRITE) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivWriteCM((PDBG_STREAM) psInParams->pvStream,psInParams->pui8InBuffer,psInParams->ui32TransferSize,psInParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivWriteCM(psStream,
+ psInParams->u.pui8InBuffer,
+ psInParams->ui32TransferSize,
+ psInParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32BytesCopied = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivRead(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivRead(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32BytesCopied;
- PDBG_IN_READ psInParams;
+ IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_READ psInParams;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_READ) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivRead((PDBG_STREAM) psInParams->pvStream,psInParams->bReadInitBuffer, psInParams->ui32OutBufferSize,psInParams->pui8OutBuffer);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivRead(psStream,
+ psInParams->bReadInitBuffer,
+ psInParams->ui32OutBufferSize,
+ psInParams->u.pui8OutBuffer);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32BytesCopied = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivSetCaptureMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivSetCaptureMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- PDBG_IN_SETDEBUGMODE psParams;
+ PDBG_IN_SETDEBUGMODE psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_SETDEBUGMODE) pvInBuffer;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivSetCaptureMode((PDBG_STREAM) psParams->pvStream,
- psParams->ui32Mode,
- psParams->ui32Start,
- psParams->ui32End,
- psParams->ui32SampleRate);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivSetCaptureMode(psStream,
+ psParams->ui32Mode,
+ psParams->ui32Start,
+ psParams->ui32End,
+ psParams->ui32SampleRate);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivSetOutMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivSetOutMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_SETDEBUGOUTMODE psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_SETDEBUGOUTMODE) pvInBuffer;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivSetOutputMode((PDBG_STREAM) psParams->pvStream,psParams->ui32Mode);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivSetOutputMode(psStream,psParams->ui32Mode);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivSetDebugLevel(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivSetDebugLevel(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_SETDEBUGLEVEL psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_SETDEBUGLEVEL) pvInBuffer;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivSetDebugLevel((PDBG_STREAM) psParams->pvStream,psParams->ui32Level);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivSetDebugLevel(psStream,psParams->ui32Level);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivSetFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivSetFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_SETFRAME psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_SETFRAME) pvInBuffer;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivSetFrame((PDBG_STREAM) psParams->pvStream,psParams->ui32Frame);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivSetFrame(psStream,psParams->ui32Frame);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivGetFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivGetFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pStream;
- PDBG_STREAM psStream;
- IMG_UINT32 * pui32Current;
+ PDBG_STREAM psStream;
+ IMG_UINT32 *pui32Current;
- pStream = (IMG_UINT32 *) pvInBuffer;
- psStream = (PDBG_STREAM) *pStream;
pui32Current = (IMG_UINT32 *) pvOutBuffer;
-
- *pui32Current = ExtDBGDrivGetFrame(psStream);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(*(IMG_SID *)pvInBuffer);
+
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32Current = ExtDBGDrivGetFrame(psStream);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32Current = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivIsCaptureFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivIsCaptureFrame(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_ISCAPTUREFRAME psParams;
- IMG_UINT32 * pui32Current;
+ IMG_UINT32 * pui32Current;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_ISCAPTUREFRAME) pvInBuffer;
pui32Current = (IMG_UINT32 *) pvOutBuffer;
- *pui32Current = ExtDBGDrivIsCaptureFrame((PDBG_STREAM) psParams->pvStream, psParams->bCheckPreviousFrame);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32Current = ExtDBGDrivIsCaptureFrame(psStream,
+ psParams->bCheckPreviousFrame);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32Current = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivOverrideMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivOverrideMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_OVERRIDEMODE psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_OVERRIDEMODE) pvInBuffer;
PVR_UNREFERENCED_PARAMETER( pvOutBuffer);
- ExtDBGDrivOverrideMode((PDBG_STREAM) psParams->pvStream,psParams->ui32Mode);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivOverrideMode(psStream,psParams->ui32Mode);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivDefaultMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivDefaultMode(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pStream;
- PDBG_STREAM psStream;
-
- pStream = (IMG_UINT32 *) pvInBuffer;
- psStream = (PDBG_STREAM) *pStream;
+ PDBG_STREAM psStream;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivDefaultMode(psStream);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(*(IMG_SID *)pvInBuffer);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivDefaultMode(psStream);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivSetMarker(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivSetMarker(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
PDBG_IN_SETMARKER psParams;
+ PDBG_STREAM psStream;
psParams = (PDBG_IN_SETMARKER) pvInBuffer;
PVR_UNREFERENCED_PARAMETER(pvOutBuffer);
- ExtDBGDrivSetMarker((PDBG_STREAM) psParams->pvStream, psParams->ui32Marker);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ ExtDBGDrivSetMarker(psStream, psParams->ui32Marker);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivGetMarker(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivGetMarker(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pStream;
- PDBG_STREAM psStream;
- IMG_UINT32 * pui32Current;
+ PDBG_STREAM psStream;
+ IMG_UINT32 *pui32Current;
- pStream = (IMG_UINT32 *) pvInBuffer;
- psStream = (PDBG_STREAM) *pStream;
pui32Current = (IMG_UINT32 *) pvOutBuffer;
- *pui32Current = ExtDBGDrivGetMarker(psStream);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(*(IMG_SID *)pvInBuffer);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32Current = ExtDBGDrivGetMarker(psStream);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32Current = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivGetServiceTable(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivGetServiceTable(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32Out;
+ IMG_PVOID * ppvOut;
PVR_UNREFERENCED_PARAMETER(pvInBuffer);
- pui32Out = (IMG_UINT32 *) pvOutBuffer;
+ ppvOut = (IMG_PVOID *) pvOutBuffer;
- *pui32Out = DBGDrivGetServiceTable();
+ *ppvOut = DBGDrivGetServiceTable();
return(IMG_TRUE);
}
-IMG_UINT32 DBGDIOCDrivWriteLF(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWriteLF(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- PDBG_IN_WRITE_LF psInParams;
- IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_WRITE_LF psInParams;
+ IMG_UINT32 *pui32BytesCopied;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_WRITE_LF) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivWriteLF(psInParams->pvStream,
- psInParams->pui8InBuffer,
- psInParams->ui32BufferSize,
- psInParams->ui32Level,
- psInParams->ui32Flags);
-
- return IMG_TRUE;
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivWriteLF(psStream,
+ psInParams->u.pui8InBuffer,
+ psInParams->ui32BufferSize,
+ psInParams->ui32Level,
+ psInParams->ui32Flags);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivReadLF(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivReadLF(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
- IMG_UINT32 * pui32BytesCopied;
- PDBG_IN_READ psInParams;
+ IMG_UINT32 * pui32BytesCopied;
+ PDBG_IN_READ psInParams;
+ PDBG_STREAM psStream;
psInParams = (PDBG_IN_READ) pvInBuffer;
pui32BytesCopied = (IMG_UINT32 *) pvOutBuffer;
- *pui32BytesCopied = ExtDBGDrivReadLF((PDBG_STREAM) psInParams->pvStream,psInParams->ui32OutBufferSize,psInParams->pui8OutBuffer);
-
- return(IMG_TRUE);
+ psStream = SID2PStream(psInParams->hStream);
+ if (psStream != (PDBG_STREAM)IMG_NULL)
+ {
+ *pui32BytesCopied = ExtDBGDrivReadLF(psStream,
+ psInParams->ui32OutBufferSize,
+ psInParams->u.pui8OutBuffer);
+ return(IMG_TRUE);
+ }
+ else
+ {
+
+ *pui32BytesCopied = 0;
+ return(IMG_FALSE);
+ }
}
-IMG_UINT32 DBGDIOCDrivWaitForEvent(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
+static IMG_UINT32 DBGDIOCDrivWaitForEvent(IMG_VOID * pvInBuffer, IMG_VOID * pvOutBuffer)
{
DBG_EVENT eEvent = (DBG_EVENT)(*(IMG_UINT32 *)pvInBuffer);
return(IMG_TRUE);
}
+
+IMG_UINT32 (*g_DBGDrivProc[25])(IMG_VOID *, IMG_VOID *) =
+{
+ DBGDIOCDrivCreateStream,
+ DBGDIOCDrivDestroyStream,
+ DBGDIOCDrivGetStream,
+ DBGDIOCDrivWriteString,
+ DBGDIOCDrivReadString,
+ DBGDIOCDrivWrite,
+ DBGDIOCDrivRead,
+ DBGDIOCDrivSetCaptureMode,
+ DBGDIOCDrivSetOutMode,
+ DBGDIOCDrivSetDebugLevel,
+ DBGDIOCDrivSetFrame,
+ DBGDIOCDrivGetFrame,
+ DBGDIOCDrivOverrideMode,
+ DBGDIOCDrivDefaultMode,
+ DBGDIOCDrivGetServiceTable,
+ DBGDIOCDrivWrite2,
+ DBGDIOCDrivWriteStringCM,
+ DBGDIOCDrivWriteCM,
+ DBGDIOCDrivSetMarker,
+ DBGDIOCDrivGetMarker,
+ DBGDIOCDrivIsCaptureFrame,
+ DBGDIOCDrivWriteLF,
+ DBGDIOCDrivReadLF,
+ DBGDIOCDrivWaitForEvent
+};
+
#ifndef _IOCTL_
#define _IOCTL_
+#define MAX_DBGVXD_W32_API 25
-IMG_UINT32 DBGDIOCDrivCreateStream(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivDestroyStream(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivGetStream(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWriteString(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivReadString(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWrite(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWrite2(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivRead(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivSetCaptureMode(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivSetOutMode(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivSetDebugLevel(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivSetFrame(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivGetFrame(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivOverrideMode(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivDefaultMode(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivGetServiceTable(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWriteStringCM(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWriteCM(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivSetMarker(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivGetMarker(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivIsCaptureFrame(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWriteLF(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivReadLF(IMG_VOID *, IMG_VOID *);
-IMG_UINT32 DBGDIOCDrivWaitForEvent(IMG_VOID*, IMG_VOID *);
-
-IMG_UINT32 (*g_DBGDrivProc[])(IMG_VOID *, IMG_VOID *) =
-{
- DBGDIOCDrivCreateStream,
- DBGDIOCDrivDestroyStream,
- DBGDIOCDrivGetStream,
- DBGDIOCDrivWriteString,
- DBGDIOCDrivReadString,
- DBGDIOCDrivWrite,
- DBGDIOCDrivRead,
- DBGDIOCDrivSetCaptureMode,
- DBGDIOCDrivSetOutMode,
- DBGDIOCDrivSetDebugLevel,
- DBGDIOCDrivSetFrame,
- DBGDIOCDrivGetFrame,
- DBGDIOCDrivOverrideMode,
- DBGDIOCDrivDefaultMode,
- DBGDIOCDrivGetServiceTable,
- DBGDIOCDrivWrite2,
- DBGDIOCDrivWriteStringCM,
- DBGDIOCDrivWriteCM,
- DBGDIOCDrivSetMarker,
- DBGDIOCDrivGetMarker,
- DBGDIOCDrivIsCaptureFrame,
- DBGDIOCDrivWriteLF,
- DBGDIOCDrivReadLF,
- DBGDIOCDrivWaitForEvent
-};
-
-#define MAX_DBGVXD_W32_API (sizeof(g_DBGDrivProc)/sizeof(IMG_UINT32))
+extern IMG_UINT32 (*g_DBGDrivProc[MAX_DBGVXD_W32_API])(IMG_VOID *, IMG_VOID *);
#endif
#include "pvr_debug.h"
#include "dbgdrvif.h"
-#include "dbgdriv/common/hostfunc.h"
+#include "hostfunc.h"
+#include "dbgdriv.h"
-#if !defined(SUPPORT_DRI_DRM)
-IMG_UINT32 gPVRDebugLevel = DBGPRIV_WARNING;
+#if defined(DEBUG) && !defined(SUPPORT_DRI_DRM)
+IMG_UINT32 gPVRDebugLevel = (DBGPRIV_FATAL | DBGPRIV_ERROR | DBGPRIV_WARNING);
#define PVR_STRING_TERMINATOR '\0'
#define PVR_IS_FILE_SEPARATOR(character) ( ((character) == '\\') || ((character) == '/') )
...
)
{
- IMG_BOOL bTrace, bDebug;
+ IMG_BOOL bTrace;
#if !defined(__sh__)
IMG_CHAR *pszLeafName;
-
+
pszLeafName = (char *)strrchr (pszFileName, '\\');
-
+
if (pszLeafName)
{
pszFileName = pszLeafName;
}
#endif
-
- bTrace = gPVRDebugLevel & ui32DebugLevel & DBGPRIV_CALLTRACE;
- bDebug = ((gPVRDebugLevel & DBGPRIV_ALLLEVELS) >= ui32DebugLevel);
- if (bTrace || bDebug)
+ bTrace = (IMG_BOOL)(ui32DebugLevel & DBGPRIV_CALLTRACE) ? IMG_TRUE : IMG_FALSE;
+
+ if (gPVRDebugLevel & ui32DebugLevel)
{
va_list vaArgs;
static char szBuffer[256];
va_start (vaArgs, pszFormat);
- if (bDebug)
+ if (bTrace == IMG_FALSE)
{
switch(ui32DebugLevel)
{
vsprintf (&szBuffer[strlen(szBuffer)], pszFormat, vaArgs);
-
- if (!bTrace)
+ if (bTrace == IMG_FALSE)
{
sprintf (&szBuffer[strlen(szBuffer)], " [%d, %s]", (int)ui32Line, pszFileName);
}
#
#
-include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
-
MODULE = dbgdrv
-INCLUDES =
+INCLUDES = -I$(EURASIAROOT)/services4/srvkm/env/linux
SOURCES =
include $(EURASIAROOT)/tools/intern/debug/dbgdriv/linux/makefile.linux.common
+
+include $(EURASIAROOT)/eurasiacon/build/linux/kbuild/Makefile.kbuild_subdir_common
#endif
#include "img_types.h"
-#include "client/linuxsrv.h"
-#include "dbgdriv/common/ioctl.h"
+#include "linuxsrv.h"
+#include "dbgdriv_ioctl.h"
#include "dbgdrvif.h"
-#include "dbgdriv/common/dbgdriv.h"
-#include "dbgdriv/common/hostfunc.h"
+#include "dbgdriv.h"
+#include "hostfunc.h"
+#include "hotkey.h"
#include "pvr_debug.h"
#include "pvrmodule.h"
+#include "pvr_uaccess.h"
#if defined(SUPPORT_DRI_DRM)
#endif
-void DBGDrvGetServiceTable(void **fn_table)
+IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table);
+
+IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table)
{
extern DBGKM_SERVICE_TABLE g_sDBGKMServices;
}
#if defined(SUPPORT_DRI_DRM)
-IMG_INT dbgdrv_ioctl(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile)
+int dbgdrv_ioctl(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile)
#else
long dbgdrv_ioctl(struct file *file, unsigned int ioctlCmd, unsigned long arg)
#endif
in = buffer;
out = buffer + (PAGE_SIZE >>1);
- if(copy_from_user(in, pIP->pInBuffer, pIP->ui32InBufferSize) != 0)
+ if(pvr_copy_from_user(in, pIP->pInBuffer, pIP->ui32InBufferSize) != 0)
{
goto init_failed;
}
if(pIP->ui32Cmd == DEBUG_SERVICE_READ)
{
- IMG_CHAR *ui8Tmp;
IMG_UINT32 *pui32BytesCopied = (IMG_UINT32 *)out;
DBG_IN_READ *psReadInParams = (DBG_IN_READ *)in;
+ DBG_STREAM *psStream;
+ IMG_CHAR *ui8Tmp;
ui8Tmp = vmalloc(psReadInParams->ui32OutBufferSize);
goto init_failed;
}
- *pui32BytesCopied = ExtDBGDrivRead((DBG_STREAM *)psReadInParams->pvStream,
+ psStream = SID2PStream(psReadInParams->hStream);
+ if(!psStream)
+ {
+ goto init_failed;
+ }
+
+ *pui32BytesCopied = ExtDBGDrivRead(psStream,
psReadInParams->bReadInitBuffer,
psReadInParams->ui32OutBufferSize,
ui8Tmp);
- if(copy_to_user(psReadInParams->pui8OutBuffer,
+ if(pvr_copy_to_user(psReadInParams->u.pui8OutBuffer,
ui8Tmp,
*pui32BytesCopied) != 0)
{
}
-void RemoveHotKey(unsigned hHotKey)
+IMG_VOID RemoveHotKey (IMG_UINT32 hHotKey)
{
-
+ PVR_UNREFERENCED_PARAMETER(hHotKey);
}
-void DefineHotKey(unsigned ScanCode, unsigned ShiftState, void *pInfo)
+IMG_VOID DefineHotKey (IMG_UINT32 ui32ScanCode, IMG_UINT32 ui32ShiftState, PHOTKEYINFO psInfo)
{
-
+ PVR_UNREFERENCED_PARAMETER(ui32ScanCode);
+ PVR_UNREFERENCED_PARAMETER(ui32ShiftState);
+ PVR_UNREFERENCED_PARAMETER(psInfo);
}
EXPORT_SYMBOL(DBGDrvGetServiceTable);
endif
INCLUDES += -I$(EURASIAROOT)/include4 \
- -I$(EURASIAROOT)/tools/intern/debug
+ -I$(EURASIAROOT)/tools/intern/debug \
+ -I$(EURASIAROOT)/tools/intern/debug/dbgdriv/common \
+ -I$(EURASIAROOT)/tools/intern/debug/client
SOURCES += $(DBGDRV_SOURCES_ROOT)/linux/main.c \
$(DBGDRV_SOURCES_ROOT)/common/dbgdriv.c \
$(DBGDRV_SOURCES_ROOT)/common/ioctl.c \
+ $(DBGDRV_SOURCES_ROOT)/common/handle.c \
$(DBGDRV_SOURCES_ROOT)/linux/hostfunc.c \
$(DBGDRV_SOURCES_ROOT)/common/hotkey.c
git.openpandora.org / sgx.git / commitdiff