137 files changed, 67960 insertions, 0 deletions

diff --git a/arch/arm/configs/android_4430_defconfig b/arch/arm/configs/android_4430_defconfig
new file mode 100644
index 00000000000..d432abe6721
--- /dev/null
+++ b/arch/arm/configs/android_4430_defconfig
@@ -0,0 +1,1926 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.35
+# Fri Sep  3 08:14:37 2010
+#
+CONFIG_ARM=y
+CONFIG_HAVE_PWM=y
+CONFIG_SYS_SUPPORTS_APM_EMULATION=y
+CONFIG_GENERIC_GPIO=y
+CONFIG_GENERIC_TIME=y
+# CONFIG_ARCH_USES_GETTIMEOFFSET is not set
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y
+CONFIG_HAVE_PROC_CPU=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_STACKTRACE_SUPPORT=y
+CONFIG_LOCKDEP_SUPPORT=y
+CONFIG_TRACE_IRQFLAGS_SUPPORT=y
+CONFIG_HARDIRQS_SW_RESEND=y
+CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_LOCKBREAK=y
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_ARCH_HAS_CPUFREQ=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_NEED_DMA_MAP_STATE=y
+CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y
+CONFIG_VECTORS_BASE=0xffff0000
+CONFIG_ARCH_HAS_CPU_IDLE_WAIT=y
+CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
+CONFIG_CONSTRUCTORS=y
+
+#
+# General setup
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+CONFIG_CROSS_COMPILE=""
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_HAVE_KERNEL_GZIP=y
+CONFIG_HAVE_KERNEL_LZMA=y
+CONFIG_HAVE_KERNEL_LZO=y
+CONFIG_KERNEL_GZIP=y
+# CONFIG_KERNEL_BZIP2 is not set
+# CONFIG_KERNEL_LZMA is not set
+# CONFIG_KERNEL_LZO is not set
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_SYSVIPC_SYSCTL=y
+# CONFIG_POSIX_MQUEUE is not set
+CONFIG_BSD_PROCESS_ACCT=y
+# CONFIG_BSD_PROCESS_ACCT_V3 is not set
+# CONFIG_TASKSTATS is not set
+# CONFIG_AUDIT is not set
+
+#
+# RCU Subsystem
+#
+CONFIG_TREE_RCU=y
+# CONFIG_TREE_PREEMPT_RCU is not set
+# CONFIG_TINY_RCU is not set
+# CONFIG_RCU_TRACE is not set
+CONFIG_RCU_FANOUT=32
+# CONFIG_RCU_FANOUT_EXACT is not set
+# CONFIG_RCU_FAST_NO_HZ is not set
+# CONFIG_TREE_RCU_TRACE is not set
+# CONFIG_IKCONFIG is not set
+CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_CGROUPS is not set
+# CONFIG_SYSFS_DEPRECATED_V2 is not set
+# CONFIG_RELAY is not set
+# CONFIG_NAMESPACES is not set
+CONFIG_BLK_DEV_INITRD=y
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_RD_GZIP=y
+# CONFIG_RD_BZIP2 is not set
+# CONFIG_RD_LZMA is not set
+# CONFIG_RD_LZO is not set
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SYSCTL=y
+CONFIG_ANON_INODES=y
+CONFIG_PANIC_TIMEOUT=0
+CONFIG_EMBEDDED=y
+CONFIG_UID16=y
+# CONFIG_SYSCTL_SYSCALL is not set
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_ALL is not set
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+# CONFIG_ELF_CORE is not set
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SIGNALFD=y
+CONFIG_TIMERFD=y
+CONFIG_EVENTFD=y
+CONFIG_SHMEM=y
+CONFIG_ASHMEM=y
+CONFIG_AIO=y
+CONFIG_HAVE_PERF_EVENTS=y
+CONFIG_PERF_USE_VMALLOC=y
+
+#
+# Kernel Performance Events And Counters
+#
+# CONFIG_PERF_EVENTS is not set
+# CONFIG_PERF_COUNTERS is not set
+CONFIG_VM_EVENT_COUNTERS=y
+CONFIG_SLUB_DEBUG=y
+CONFIG_COMPAT_BRK=y
+# CONFIG_SLAB is not set
+CONFIG_SLUB=y
+# CONFIG_SLOB is not set
+# CONFIG_PROFILING is not set
+CONFIG_HAVE_OPROFILE=y
+# CONFIG_KPROBES is not set
+CONFIG_HAVE_KPROBES=y
+CONFIG_HAVE_KRETPROBES=y
+CONFIG_USE_GENERIC_SMP_HELPERS=y
+CONFIG_HAVE_CLK=y
+
+#
+# GCOV-based kernel profiling
+#
+# CONFIG_GCOV_KERNEL is not set
+# CONFIG_SLOW_WORK is not set
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_SLABINFO=y
+CONFIG_RT_MUTEXES=y
+CONFIG_BASE_SMALL=0
+CONFIG_MODULES=y
+# CONFIG_MODULE_FORCE_LOAD is not set
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+CONFIG_MODVERSIONS=y
+CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_STOP_MACHINE=y
+CONFIG_BLOCK=y
+CONFIG_LBDAF=y
+# CONFIG_BLK_DEV_BSG is not set
+# CONFIG_BLK_DEV_INTEGRITY is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+# CONFIG_INLINE_SPIN_TRYLOCK is not set
+# CONFIG_INLINE_SPIN_TRYLOCK_BH is not set
+# CONFIG_INLINE_SPIN_LOCK is not set
+# CONFIG_INLINE_SPIN_LOCK_BH is not set
+# CONFIG_INLINE_SPIN_LOCK_IRQ is not set
+# CONFIG_INLINE_SPIN_LOCK_IRQSAVE is not set
+# CONFIG_INLINE_SPIN_UNLOCK is not set
+# CONFIG_INLINE_SPIN_UNLOCK_BH is not set
+# CONFIG_INLINE_SPIN_UNLOCK_IRQ is not set
+# CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE is not set
+# CONFIG_INLINE_READ_TRYLOCK is not set
+# CONFIG_INLINE_READ_LOCK is not set
+# CONFIG_INLINE_READ_LOCK_BH is not set
+# CONFIG_INLINE_READ_LOCK_IRQ is not set
+# CONFIG_INLINE_READ_LOCK_IRQSAVE is not set
+# CONFIG_INLINE_READ_UNLOCK is not set
+# CONFIG_INLINE_READ_UNLOCK_BH is not set
+# CONFIG_INLINE_READ_UNLOCK_IRQ is not set
+# CONFIG_INLINE_READ_UNLOCK_IRQRESTORE is not set
+# CONFIG_INLINE_WRITE_TRYLOCK is not set
+# CONFIG_INLINE_WRITE_LOCK is not set
+# CONFIG_INLINE_WRITE_LOCK_BH is not set
+# CONFIG_INLINE_WRITE_LOCK_IRQ is not set
+# CONFIG_INLINE_WRITE_LOCK_IRQSAVE is not set
+# CONFIG_INLINE_WRITE_UNLOCK is not set
+# CONFIG_INLINE_WRITE_UNLOCK_BH is not set
+# CONFIG_INLINE_WRITE_UNLOCK_IRQ is not set
+# CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE is not set
+CONFIG_MUTEX_SPIN_ON_OWNER=y
+CONFIG_FREEZER=y
+
+#
+# System Type
+#
+CONFIG_MMU=y
+# CONFIG_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_INTEGRATOR is not set
+# CONFIG_ARCH_REALVIEW is not set
+# CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_VEXPRESS is not set
+# CONFIG_ARCH_AT91 is not set
+# CONFIG_ARCH_BCMRING is not set
+# CONFIG_ARCH_CLPS711X is not set
+# CONFIG_ARCH_CNS3XXX is not set
+# CONFIG_ARCH_GEMINI is not set
+# CONFIG_ARCH_EBSA110 is not set
+# CONFIG_ARCH_EP93XX is not set
+# CONFIG_ARCH_FOOTBRIDGE is not set
+# CONFIG_ARCH_MXC is not set
+# CONFIG_ARCH_STMP3XXX is not set
+# CONFIG_ARCH_NETX is not set
+# CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_IOP13XX is not set
+# CONFIG_ARCH_IOP32X is not set
+# CONFIG_ARCH_IOP33X is not set
+# CONFIG_ARCH_IXP23XX is not set
+# CONFIG_ARCH_IXP2000 is not set
+# CONFIG_ARCH_IXP4XX is not set
+# CONFIG_ARCH_L7200 is not set
+# CONFIG_ARCH_DOVE is not set
+# CONFIG_ARCH_KIRKWOOD is not set
+# CONFIG_ARCH_LOKI is not set
+# CONFIG_ARCH_MV78XX0 is not set
+# CONFIG_ARCH_ORION5X is not set
+# CONFIG_ARCH_MMP is not set
+# CONFIG_ARCH_KS8695 is not set
+# CONFIG_ARCH_NS9XXX is not set
+# CONFIG_ARCH_W90X900 is not set
+# CONFIG_ARCH_NUC93X is not set
+# CONFIG_ARCH_PNX4008 is not set
+# CONFIG_ARCH_PXA is not set
+# CONFIG_ARCH_MSM is not set
+# CONFIG_ARCH_SHMOBILE is not set
+# CONFIG_ARCH_RPC is not set
+# CONFIG_ARCH_SA1100 is not set
+# CONFIG_ARCH_S3C2410 is not set
+# CONFIG_ARCH_S3C64XX is not set
+# CONFIG_ARCH_S5P6440 is not set
+# CONFIG_ARCH_S5P6442 is not set
+# CONFIG_ARCH_S5PC100 is not set
+# CONFIG_ARCH_S5PV210 is not set
+# CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7A40X is not set
+# CONFIG_ARCH_U300 is not set
+# CONFIG_ARCH_U8500 is not set
+# CONFIG_ARCH_NOMADIK is not set
+# CONFIG_ARCH_DAVINCI is not set
+CONFIG_ARCH_OMAP=y
+# CONFIG_PLAT_SPEAR is not set
+
+#
+# TI OMAP Implementations
+#
+# CONFIG_ARCH_OMAP1 is not set
+CONFIG_ARCH_OMAP2PLUS=y
+# CONFIG_ARCH_OMAP2 is not set
+# CONFIG_ARCH_OMAP3 is not set
+CONFIG_ARCH_OMAP4=y
+
+#
+# OMAP Feature Selections
+#
+CONFIG_OMAP_SMARTREFLEX=y
+# CONFIG_OMAP_SMARTREFLEX_TESTING is not set
+CONFIG_OMAP_SMARTREFLEX_CLASS3=y
+# CONFIG_OMAP_RESET_CLOCKS is not set
+# CONFIG_OMAP_MUX is not set
+CONFIG_OMAP_MCBSP=y
+CONFIG_OMAP_MBOX_FWK=y
+CONFIG_OMAP_REMOTE_PROC=y
+CONFIG_OMAP_RPROC_MEMPOOL_SIZE=0x600000
+CONFIG_OMAP_IOMMU=y
+# CONFIG_OMAP_IOMMU_DEBUG is not set
+# CONFIG_OMAP_MPU_TIMER is not set
+CONFIG_OMAP_32K_TIMER=y
+CONFIG_OMAP_32K_TIMER_HZ=128
+CONFIG_OMAP_DM_TIMER=y
+# CONFIG_OMAP_PM_NONE is not set
+CONFIG_OMAP_PM_NOOP=y
+# CONFIG_OMAP_PM is not set
+
+#
+# OMAP Board Type
+#
+# CONFIG_WIFI_CONTROL_FUNC is not set
+# CONFIG_TIWLAN_SDIO is not set
+# CONFIG_OMAP4_ES1 is not set
+CONFIG_MACH_OMAP_4430SDP=y
+CONFIG_MACH_OMAP4_PANDA=y
+# CONFIG_ERRATA_OMAP4_AXI2OCP is not set
+
+#
+# Processor Type
+#
+CONFIG_CPU_32v6K=y
+CONFIG_CPU_V7=y
+CONFIG_CPU_32v7=y
+CONFIG_CPU_ABRT_EV7=y
+CONFIG_CPU_PABRT_V7=y
+CONFIG_CPU_CACHE_V7=y
+CONFIG_CPU_CACHE_VIPT=y
+CONFIG_CPU_COPY_V6=y
+CONFIG_CPU_TLB_V7=y
+CONFIG_CPU_HAS_ASID=y
+CONFIG_CPU_CP15=y
+CONFIG_CPU_CP15_MMU=y
+
+#
+# Processor Features
+#
+CONFIG_ARM_THUMB=y
+CONFIG_ARM_THUMBEE=y
+# CONFIG_CPU_ICACHE_DISABLE is not set
+# CONFIG_CPU_DCACHE_DISABLE is not set
+# CONFIG_CPU_BPREDICT_DISABLE is not set
+CONFIG_HAS_TLS_REG=y
+CONFIG_OUTER_CACHE=y
+CONFIG_OUTER_CACHE_SYNC=y
+CONFIG_CACHE_L2X0=y
+CONFIG_CACHE_PL310=y
+CONFIG_ARM_L1_CACHE_SHIFT=5
+CONFIG_ARM_DMA_MEM_BUFFERABLE=y
+CONFIG_CPU_HAS_PMU=y
+# CONFIG_ARM_ERRATA_430973 is not set
+# CONFIG_ARM_ERRATA_458693 is not set
+# CONFIG_ARM_ERRATA_460075 is not set
+# CONFIG_PL310_ERRATA_588369 is not set
+CONFIG_ARM_ERRATA_720789=y
+CONFIG_ARM_GIC=y
+CONFIG_COMMON_CLKDEV=y
+
+#
+# Bus support
+#
+# CONFIG_PCI_SYSCALL is not set
+# CONFIG_ARCH_SUPPORTS_MSI is not set
+# CONFIG_PCCARD is not set
+
+#
+# Kernel Features
+#
+CONFIG_TICK_ONESHOT=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
+CONFIG_SMP=y
+CONFIG_HAVE_ARM_SCU=y
+CONFIG_HAVE_ARM_TWD=y
+CONFIG_VMSPLIT_3G=y
+# CONFIG_VMSPLIT_2G is not set
+# CONFIG_VMSPLIT_1G is not set
+CONFIG_PAGE_OFFSET=0xC0000000
+CONFIG_NR_CPUS=2
+CONFIG_HOTPLUG_CPU=y
+CONFIG_LOCAL_TIMERS=y
+# CONFIG_PREEMPT_NONE is not set
+# CONFIG_PREEMPT_VOLUNTARY is not set
+CONFIG_PREEMPT=y
+CONFIG_HZ=128
+# CONFIG_THUMB2_KERNEL is not set
+CONFIG_AEABI=y
+CONFIG_OABI_COMPAT=y
+CONFIG_ARCH_HAS_HOLES_MEMORYMODEL=y
+# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set
+# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set
+# CONFIG_HIGHMEM is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+CONFIG_PAGEFLAGS_EXTENDED=y
+CONFIG_SPLIT_PTLOCK_CPUS=4
+# CONFIG_PHYS_ADDR_T_64BIT is not set
+CONFIG_ZONE_DMA_FLAG=0
+CONFIG_VIRT_TO_BUS=y
+# CONFIG_KSM is not set
+CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
+# CONFIG_LEDS is not set
+CONFIG_ALIGNMENT_TRAP=y
+# CONFIG_UACCESS_WITH_MEMCPY is not set
+
+#
+# Boot options
+#
+CONFIG_ZBOOT_ROM_TEXT=0x0
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_CMDLINE="root=/dev/ram0 rw mem=128M console=ttyS2,115200n8 initrd=0x81600000,20M ramdisk_size=20480"
+# CONFIG_CMDLINE_FORCE is not set
+# CONFIG_XIP_KERNEL is not set
+# CONFIG_KEXEC is not set
+
+#
+# CPU Power Management
+#
+# CONFIG_CPU_FREQ is not set
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+
+#
+# Floating point emulation
+#
+
+#
+# At least one emulation must be selected
+#
+# CONFIG_FPE_NWFPE is not set
+# CONFIG_FPE_FASTFPE is not set
+CONFIG_VFP=y
+CONFIG_VFPv3=y
+CONFIG_NEON=y
+
+#
+# Userspace binary formats
+#
+CONFIG_BINFMT_ELF=y
+CONFIG_HAVE_AOUT=y
+# CONFIG_BINFMT_AOUT is not set
+CONFIG_BINFMT_MISC=y
+
+#
+# Power management options
+#
+CONFIG_PM=y
+CONFIG_PM_DEBUG=y
+# CONFIG_PM_ADVANCED_DEBUG is not set
+# CONFIG_PM_VERBOSE is not set
+CONFIG_CAN_PM_TRACE=y
+CONFIG_PM_SLEEP_SMP=y
+CONFIG_PM_SLEEP=y
+CONFIG_SUSPEND_NVS=y
+CONFIG_SUSPEND=y
+# CONFIG_PM_TEST_SUSPEND is not set
+CONFIG_SUSPEND_FREEZER=y
+CONFIG_HAS_WAKELOCK=y
+CONFIG_HAS_EARLYSUSPEND=y
+CONFIG_WAKELOCK=y
+CONFIG_WAKELOCK_STAT=y
+CONFIG_USER_WAKELOCK=y
+CONFIG_EARLYSUSPEND=y
+# CONFIG_NO_USER_SPACE_SCREEN_ACCESS_CONTROL is not set
+CONFIG_CONSOLE_EARLYSUSPEND=y
+# CONFIG_FB_EARLYSUSPEND is not set
+# CONFIG_APM_EMULATION is not set
+CONFIG_PM_RUNTIME=y
+CONFIG_PM_OPS=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+CONFIG_UNIX=y
+CONFIG_XFRM=y
+# CONFIG_XFRM_USER is not set
+# CONFIG_XFRM_SUB_POLICY is not set
+# CONFIG_XFRM_MIGRATE is not set
+# CONFIG_XFRM_STATISTICS is not set
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+CONFIG_IP_PNP_BOOTP=y
+CONFIG_IP_PNP_RARP=y
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_XFRM_MODE_TRANSPORT=y
+CONFIG_INET_XFRM_MODE_TUNNEL=y
+CONFIG_INET_XFRM_MODE_BEET=y
+CONFIG_INET_LRO=y
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_CUBIC=y
+CONFIG_DEFAULT_TCP_CONG="cubic"
+# CONFIG_TCP_MD5SIG is not set
+# CONFIG_IPV6 is not set
+CONFIG_ANDROID_PARANOID_NETWORK=y
+CONFIG_NET_ACTIVITY_STATS=y
+# CONFIG_NETWORK_SECMARK is not set
+# CONFIG_NETFILTER is not set
+# CONFIG_IP_DCCP is not set
+# CONFIG_IP_SCTP is not set
+# CONFIG_RDS is not set
+# CONFIG_TIPC is not set
+# CONFIG_ATM is not set
+# CONFIG_L2TP is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_NET_DSA is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_PHONET is not set
+# CONFIG_IEEE802154 is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_DCB is not set
+CONFIG_RPS=y
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_CAN is not set
+# CONFIG_IRDA is not set
+CONFIG_BT=y
+CONFIG_BT_L2CAP=y
+# CONFIG_BT_L2CAP_EXT_FEATURES is not set
+CONFIG_BT_SCO=y
+CONFIG_BT_RFCOMM=y
+CONFIG_BT_RFCOMM_TTY=y
+# CONFIG_BT_BNEP is not set
+# CONFIG_BT_HIDP is not set
+
+#
+# Bluetooth device drivers
+#
+# CONFIG_BT_HCIBTSDIO is not set
+# CONFIG_BT_HCIUART is not set
+# CONFIG_BT_HCIVHCI is not set
+# CONFIG_BT_MRVL is not set
+# CONFIG_AF_RXRPC is not set
+# CONFIG_WIRELESS is not set
+# CONFIG_WIMAX is not set
+CONFIG_RFKILL=y
+# CONFIG_RFKILL_PM is not set
+# CONFIG_RFKILL_INPUT is not set
+# CONFIG_NET_9P is not set
+# CONFIG_CAIF is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
+CONFIG_DEVTMPFS_MOUNT=y
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+CONFIG_FW_LOADER=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_EXTRA_FIRMWARE=""
+# CONFIG_DEBUG_DRIVER is not set
+# CONFIG_DEBUG_DEVRES is not set
+# CONFIG_SYS_HYPERVISOR is not set
+# CONFIG_CONNECTOR is not set
+# CONFIG_MTD is not set
+# CONFIG_PARPORT is not set
+CONFIG_BLK_DEV=y
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=y
+# CONFIG_BLK_DEV_CRYPTOLOOP is not set
+
+#
+# DRBD disabled because PROC_FS, INET or CONNECTOR not selected
+#
+# CONFIG_BLK_DEV_NBD is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=16384
+# CONFIG_BLK_DEV_XIP is not set
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_ATA_OVER_ETH is not set
+# CONFIG_MG_DISK is not set
+CONFIG_MISC_DEVICES=y
+# CONFIG_AD525X_DPOT is not set
+CONFIG_ANDROID_PMEM=y
+# CONFIG_ICS932S401 is not set
+# CONFIG_ENCLOSURE_SERVICES is not set
+CONFIG_KERNEL_DEBUGGER_CORE=y
+# CONFIG_ISL29003 is not set
+# CONFIG_SENSORS_TSL2550 is not set
+CONFIG_SENSORS_BH1780=y
+# CONFIG_SENSORS_AK8975 is not set
+# CONFIG_DS1682 is not set
+# CONFIG_TI_DAC7512 is not set
+CONFIG_UID_STAT=y
+CONFIG_BMP085=y
+# CONFIG_WL127X_RFKILL is not set
+# CONFIG_APANIC is not set
+# CONFIG_C2PORT is not set
+
+#
+# EEPROM support
+#
+# CONFIG_EEPROM_AT24 is not set
+# CONFIG_EEPROM_AT25 is not set
+# CONFIG_EEPROM_LEGACY is not set
+# CONFIG_EEPROM_MAX6875 is not set
+# CONFIG_EEPROM_93CX6 is not set
+# CONFIG_IWMC3200TOP is not set
+CONFIG_HAVE_IDE=y
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+CONFIG_SCSI_MOD=y
+# CONFIG_RAID_ATTRS is not set
+# CONFIG_SCSI is not set
+# CONFIG_SCSI_DMA is not set
+# CONFIG_SCSI_NETLINK is not set
+# CONFIG_ATA is not set
+# CONFIG_MD is not set
+CONFIG_NETDEVICES=y
+# CONFIG_DUMMY is not set
+# CONFIG_BONDING is not set
+# CONFIG_MACVLAN is not set
+# CONFIG_EQUALIZER is not set
+# CONFIG_TUN is not set
+# CONFIG_VETH is not set
+# CONFIG_PHYLIB is not set
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+# CONFIG_AX88796 is not set
+# CONFIG_SMC91X is not set
+# CONFIG_DM9000 is not set
+# CONFIG_ENC28J60 is not set
+# CONFIG_ETHOC is not set
+# CONFIG_SMC911X is not set
+# CONFIG_SMSC911X is not set
+# CONFIG_DNET is not set
+# CONFIG_IBM_NEW_EMAC_ZMII is not set
+# CONFIG_IBM_NEW_EMAC_RGMII is not set
+# CONFIG_IBM_NEW_EMAC_TAH is not set
+# CONFIG_IBM_NEW_EMAC_EMAC4 is not set
+# CONFIG_IBM_NEW_EMAC_NO_FLOW_CTRL is not set
+# CONFIG_IBM_NEW_EMAC_MAL_CLR_ICINTSTAT is not set
+# CONFIG_IBM_NEW_EMAC_MAL_COMMON_ERR is not set
+# CONFIG_B44 is not set
+# CONFIG_KS8842 is not set
+CONFIG_KS8851=y
+# CONFIG_KS8851_MLL is not set
+# CONFIG_NETDEV_1000 is not set
+# CONFIG_NETDEV_10000 is not set
+# CONFIG_WLAN is not set
+
+#
+# Enable WiMAX (Networking options) to see the WiMAX drivers
+#
+# CONFIG_WAN is not set
+# CONFIG_PPP is not set
+# CONFIG_SLIP is not set
+# CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
+# CONFIG_ISDN is not set
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+# CONFIG_INPUT_FF_MEMLESS is not set
+# CONFIG_INPUT_POLLDEV is not set
+# CONFIG_INPUT_SPARSEKMAP is not set
+
+#
+# Userland interfaces
+#
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_JOYDEV is not set
+CONFIG_INPUT_EVDEV=y
+# CONFIG_INPUT_EVBUG is not set
+CONFIG_INPUT_KEYRESET=y
+
+#
+# Input Device Drivers
+#
+CONFIG_INPUT_KEYBOARD=y
+# CONFIG_KEYBOARD_ADP5588 is not set
+CONFIG_KEYBOARD_ATKBD=y
+# CONFIG_KEYBOARD_QT2160 is not set
+# CONFIG_KEYBOARD_LKKBD is not set
+# CONFIG_KEYBOARD_GPIO is not set
+# CONFIG_KEYBOARD_TCA6416 is not set
+# CONFIG_KEYBOARD_MATRIX is not set
+# CONFIG_KEYBOARD_LM8323 is not set
+# CONFIG_KEYBOARD_MAX7359 is not set
+# CONFIG_KEYBOARD_NEWTON is not set
+# CONFIG_KEYBOARD_OPENCORES is not set
+# CONFIG_KEYBOARD_STOWAWAY is not set
+# CONFIG_KEYBOARD_SUNKBD is not set
+CONFIG_KEYBOARD_OMAP4=y
+# CONFIG_KEYBOARD_TWL4030 is not set
+# CONFIG_KEYBOARD_XTKBD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TABLET is not set
+CONFIG_INPUT_TOUCHSCREEN=y
+# CONFIG_TOUCHSCREEN_ADS7846 is not set
+# CONFIG_TOUCHSCREEN_AD7877 is not set
+# CONFIG_TOUCHSCREEN_AD7879_I2C is not set
+# CONFIG_TOUCHSCREEN_AD7879_SPI is not set
+# CONFIG_TOUCHSCREEN_AD7879 is not set
+# CONFIG_TOUCHSCREEN_DYNAPRO is not set
+# CONFIG_TOUCHSCREEN_HAMPSHIRE is not set
+# CONFIG_TOUCHSCREEN_EETI is not set
+# CONFIG_TOUCHSCREEN_FUJITSU is not set
+# CONFIG_TOUCHSCREEN_GUNZE is not set
+# CONFIG_TOUCHSCREEN_ELO is not set
+# CONFIG_TOUCHSCREEN_WACOM_W8001 is not set
+# CONFIG_TOUCHSCREEN_MCS5000 is not set
+# CONFIG_TOUCHSCREEN_MTOUCH is not set
+# CONFIG_TOUCHSCREEN_INEXIO is not set
+# CONFIG_TOUCHSCREEN_MK712 is not set
+# CONFIG_TOUCHSCREEN_PENMOUNT is not set
+# CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI is not set
+# CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set
+# CONFIG_TOUCHSCREEN_TOUCHWIN is not set
+# CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set
+# CONFIG_TOUCHSCREEN_TOUCHIT213 is not set
+# CONFIG_TOUCHSCREEN_TSC2007 is not set
+# CONFIG_TOUCHSCREEN_W90X900 is not set
+CONFIG_TOUCHSCREEN_SYNTM12XX=y
+# CONFIG_TOUCHSCREEN_TPS6507X is not set
+CONFIG_INPUT_MISC=y
+# CONFIG_INPUT_AD714X is not set
+# CONFIG_INPUT_ATI_REMOTE is not set
+# CONFIG_INPUT_ATI_REMOTE2 is not set
+CONFIG_INPUT_KEYCHORD=y
+# CONFIG_INPUT_KEYSPAN_REMOTE is not set
+# CONFIG_INPUT_POWERMATE is not set
+# CONFIG_INPUT_YEALINK is not set
+# CONFIG_INPUT_CM109 is not set
+# CONFIG_INPUT_TWL4030_PWRBUTTON is not set
+# CONFIG_INPUT_TWL4030_VIBRA is not set
+# CONFIG_INPUT_TWL6040_VIBRA is not set
+CONFIG_INPUT_UINPUT=y
+CONFIG_INPUT_GPIO=y
+# CONFIG_INPUT_PCF8574 is not set
+# CONFIG_INPUT_GPIO_ROTARY_ENCODER is not set
+CONFIG_INPUT_SFH7741=y
+CONFIG_INPUT_CMA3000_I2C=y
+
+#
+# Hardware I/O ports
+#
+CONFIG_SERIO=y
+CONFIG_SERIO_SERPORT=y
+CONFIG_SERIO_LIBPS2=y
+# CONFIG_SERIO_RAW is not set
+# CONFIG_SERIO_ALTERA_PS2 is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_CONSOLE_TRANSLATIONS=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+# CONFIG_VT_HW_CONSOLE_BINDING is not set
+CONFIG_DEVMEM=y
+CONFIG_DEVKMEM=y
+# CONFIG_SERIAL_NONSTANDARD is not set
+# CONFIG_N_GSM is not set
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_NR_UARTS=32
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_MANY_PORTS=y
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+CONFIG_SERIAL_8250_DETECT_IRQ=y
+CONFIG_SERIAL_8250_RSA=y
+
+#
+# Non-8250 serial port support
+#
+# CONFIG_SERIAL_MAX3100 is not set
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+CONFIG_SERIAL_OMAP=y
+CONFIG_SERIAL_OMAP_CONSOLE=y
+# CONFIG_SERIAL_TIMBERDALE is not set
+# CONFIG_SERIAL_ALTERA_JTAGUART is not set
+# CONFIG_SERIAL_ALTERA_UART is not set
+CONFIG_UNIX98_PTYS=y
+# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set
+# CONFIG_LEGACY_PTYS is not set
+# CONFIG_IPMI_HANDLER is not set
+CONFIG_HW_RANDOM=y
+# CONFIG_HW_RANDOM_TIMERIOMEM is not set
+# CONFIG_R3964 is not set
+# CONFIG_RAW_DRIVER is not set
+# CONFIG_TCG_TPM is not set
+# CONFIG_DCC_TTY is not set
+# CONFIG_RAMOOPS is not set
+CONFIG_I2C=y
+CONFIG_I2C_BOARDINFO=y
+CONFIG_I2C_COMPAT=y
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_HELPER_AUTO=y
+
+#
+# I2C Hardware Bus support
+#
+
+#
+# I2C system bus drivers (mostly embedded / system-on-chip)
+#
+# CONFIG_I2C_DESIGNWARE is not set
+# CONFIG_I2C_GPIO is not set
+# CONFIG_I2C_OCORES is not set
+CONFIG_I2C_OMAP=y
+# CONFIG_I2C_PCA_PLATFORM is not set
+# CONFIG_I2C_SIMTEC is not set
+# CONFIG_I2C_XILINX is not set
+
+#
+# External I2C/SMBus adapter drivers
+#
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_TAOS_EVM is not set
+
+#
+# Other I2C/SMBus bus drivers
+#
+# CONFIG_I2C_STUB is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+CONFIG_SPI=y
+# CONFIG_SPI_DEBUG is not set
+CONFIG_SPI_MASTER=y
+
+#
+# SPI Master Controller Drivers
+#
+# CONFIG_SPI_BITBANG is not set
+# CONFIG_SPI_GPIO is not set
+CONFIG_SPI_OMAP24XX=y
+# CONFIG_SPI_XILINX is not set
+# CONFIG_SPI_DESIGNWARE is not set
+
+#
+# SPI Protocol Masters
+#
+# CONFIG_SPI_SPIDEV is not set
+# CONFIG_SPI_TLE62X0 is not set
+
+#
+# PPS support
+#
+# CONFIG_PPS is not set
+CONFIG_ARCH_REQUIRE_GPIOLIB=y
+CONFIG_GPIOLIB=y
+# CONFIG_DEBUG_GPIO is not set
+# CONFIG_GPIO_SYSFS is not set
+
+#
+# Memory mapped GPIO expanders:
+#
+# CONFIG_GPIO_IT8761E is not set
+
+#
+# I2C GPIO expanders:
+#
+# CONFIG_GPIO_MAX7300 is not set
+# CONFIG_GPIO_MAX732X is not set
+# CONFIG_GPIO_PCA953X is not set
+# CONFIG_GPIO_PCF857X is not set
+# CONFIG_GPIO_TWL4030 is not set
+# CONFIG_GPIO_ADP5588 is not set
+
+#
+# PCI GPIO expanders:
+#
+
+#
+# SPI GPIO expanders:
+#
+# CONFIG_GPIO_MAX7301 is not set
+# CONFIG_GPIO_MCP23S08 is not set
+# CONFIG_GPIO_MC33880 is not set
+
+#
+# AC97 GPIO expanders:
+#
+
+#
+# MODULbus GPIO expanders:
+#
+# CONFIG_W1 is not set
+CONFIG_POWER_SUPPLY=y
+# CONFIG_POWER_SUPPLY_DEBUG is not set
+# CONFIG_PDA_POWER is not set
+# CONFIG_TEST_POWER is not set
+# CONFIG_BATTERY_DS2760 is not set
+# CONFIG_BATTERY_DS2782 is not set
+CONFIG_TWL6030_BCI_BATTERY=y
+CONFIG_CHARGER_BQ2415x=y
+# CONFIG_BATTERY_BQ27x00 is not set
+# CONFIG_BATTERY_MAX17040 is not set
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Native drivers
+#
+# CONFIG_SENSORS_AD7414 is not set
+# CONFIG_SENSORS_AD7418 is not set
+# CONFIG_SENSORS_ADCXX is not set
+# CONFIG_SENSORS_ADM1021 is not set
+# CONFIG_SENSORS_ADM1025 is not set
+# CONFIG_SENSORS_ADM1026 is not set
+# CONFIG_SENSORS_ADM1029 is not set
+# CONFIG_SENSORS_ADM1031 is not set
+# CONFIG_SENSORS_ADM9240 is not set
+# CONFIG_SENSORS_ADT7411 is not set
+# CONFIG_SENSORS_ADT7462 is not set
+# CONFIG_SENSORS_ADT7470 is not set
+# CONFIG_SENSORS_ADT7475 is not set
+# CONFIG_SENSORS_ASC7621 is not set
+# CONFIG_SENSORS_ATXP1 is not set
+# CONFIG_SENSORS_DS1621 is not set
+# CONFIG_SENSORS_F71805F is not set
+# CONFIG_SENSORS_F71882FG is not set
+# CONFIG_SENSORS_F75375S is not set
+# CONFIG_SENSORS_G760A is not set
+# CONFIG_SENSORS_GL518SM is not set
+# CONFIG_SENSORS_GL520SM is not set
+# CONFIG_SENSORS_IT87 is not set
+# CONFIG_SENSORS_LM63 is not set
+# CONFIG_SENSORS_LM70 is not set
+# CONFIG_SENSORS_LM73 is not set
+CONFIG_SENSORS_LM75=y
+# CONFIG_SENSORS_LM77 is not set
+# CONFIG_SENSORS_LM78 is not set
+# CONFIG_SENSORS_LM80 is not set
+# CONFIG_SENSORS_LM83 is not set
+# CONFIG_SENSORS_LM85 is not set
+# CONFIG_SENSORS_LM87 is not set
+# CONFIG_SENSORS_LM90 is not set
+# CONFIG_SENSORS_LM92 is not set
+# CONFIG_SENSORS_LM93 is not set
+# CONFIG_SENSORS_LTC4215 is not set
+# CONFIG_SENSORS_LTC4245 is not set
+# CONFIG_SENSORS_LM95241 is not set
+# CONFIG_SENSORS_MAX1111 is not set
+# CONFIG_SENSORS_MAX1619 is not set
+# CONFIG_SENSORS_MAX6650 is not set
+# CONFIG_SENSORS_PC87360 is not set
+# CONFIG_SENSORS_PC87427 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_SHT15 is not set
+# CONFIG_SENSORS_DME1737 is not set
+# CONFIG_SENSORS_EMC1403 is not set
+# CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47M192 is not set
+# CONFIG_SENSORS_SMSC47B397 is not set
+# CONFIG_SENSORS_ADS7828 is not set
+# CONFIG_SENSORS_ADS7871 is not set
+# CONFIG_SENSORS_AMC6821 is not set
+# CONFIG_SENSORS_THMC50 is not set
+# CONFIG_SENSORS_TMP102 is not set
+# CONFIG_SENSORS_TMP401 is not set
+# CONFIG_SENSORS_TMP421 is not set
+# CONFIG_SENSORS_VT1211 is not set
+# CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83791D is not set
+# CONFIG_SENSORS_W83792D is not set
+# CONFIG_SENSORS_W83793 is not set
+# CONFIG_SENSORS_W83L785TS is not set
+# CONFIG_SENSORS_W83L786NG is not set
+# CONFIG_SENSORS_W83627HF is not set
+# CONFIG_SENSORS_W83627EHF is not set
+# CONFIG_SENSORS_LIS3_SPI is not set
+# CONFIG_SENSORS_LIS3_I2C is not set
+# CONFIG_THERMAL is not set
+CONFIG_WATCHDOG=y
+# CONFIG_WATCHDOG_NOWAYOUT is not set
+
+#
+# Watchdog Device Drivers
+#
+# CONFIG_SOFT_WATCHDOG is not set
+# CONFIG_MPCORE_WATCHDOG is not set
+CONFIG_OMAP_WATCHDOG=y
+# CONFIG_TWL4030_WATCHDOG is not set
+# CONFIG_MAX63XX_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
+
+#
+# Sonics Silicon Backplane
+#
+# CONFIG_SSB is not set
+CONFIG_MFD_SUPPORT=y
+CONFIG_MFD_CORE=y
+# CONFIG_MFD_88PM860X is not set
+# CONFIG_MFD_SM501 is not set
+# CONFIG_MFD_ASIC3 is not set
+# CONFIG_HTC_EGPIO is not set
+# CONFIG_HTC_PASIC3 is not set
+# CONFIG_HTC_I2CPLD is not set
+# CONFIG_TPS65010 is not set
+# CONFIG_TPS6507X is not set
+CONFIG_TWL4030_CORE=y
+# CONFIG_TWL4030_POWER is not set
+# CONFIG_TWL4030_CODEC is not set
+# CONFIG_MFD_TC35892 is not set
+CONFIG_TWL6030_PWM=y
+CONFIG_TWL6030_GPADC=y
+CONFIG_TWL6040_CODEC=y
+# CONFIG_MFD_TMIO is not set
+# CONFIG_MFD_T7L66XB is not set
+# CONFIG_MFD_TC6387XB is not set
+# CONFIG_MFD_TC6393XB is not set
+# CONFIG_PMIC_DA903X is not set
+# CONFIG_PMIC_ADP5520 is not set
+# CONFIG_MFD_MAX8925 is not set
+# CONFIG_MFD_WM8400 is not set
+# CONFIG_MFD_WM831X is not set
+# CONFIG_MFD_WM8350_I2C is not set
+# CONFIG_MFD_WM8994 is not set
+# CONFIG_MFD_PCF50633 is not set
+# CONFIG_MFD_MC13783 is not set
+# CONFIG_ABX500_CORE is not set
+# CONFIG_EZX_PCAP is not set
+# CONFIG_AB8500_CORE is not set
+CONFIG_REGULATOR=y
+# CONFIG_REGULATOR_DEBUG is not set
+# CONFIG_REGULATOR_DUMMY is not set
+# CONFIG_REGULATOR_FIXED_VOLTAGE is not set
+# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set
+# CONFIG_REGULATOR_USERSPACE_CONSUMER is not set
+# CONFIG_REGULATOR_BQ24022 is not set
+# CONFIG_REGULATOR_MAX1586 is not set
+# CONFIG_REGULATOR_MAX8649 is not set
+# CONFIG_REGULATOR_MAX8660 is not set
+CONFIG_REGULATOR_TWL4030=y
+# CONFIG_REGULATOR_LP3971 is not set
+# CONFIG_REGULATOR_TPS65023 is not set
+# CONFIG_REGULATOR_TPS6507X is not set
+CONFIG_MEDIA_SUPPORT=y
+
+#
+# Multimedia core support
+#
+CONFIG_VIDEO_DEV=y
+CONFIG_VIDEO_V4L2_COMMON=y
+# CONFIG_VIDEO_ALLOW_V4L1 is not set
+CONFIG_VIDEO_V4L1_COMPAT=y
+# CONFIG_DVB_CORE is not set
+CONFIG_VIDEO_MEDIA=y
+
+#
+# Multimedia drivers
+#
+CONFIG_IR_CORE=y
+CONFIG_VIDEO_IR=y
+CONFIG_RC_MAP=y
+CONFIG_IR_NEC_DECODER=y
+CONFIG_IR_RC5_DECODER=y
+CONFIG_IR_RC6_DECODER=y
+CONFIG_IR_JVC_DECODER=y
+CONFIG_IR_SONY_DECODER=y
+# CONFIG_IR_IMON is not set
+# CONFIG_MEDIA_ATTACH is not set
+CONFIG_MEDIA_TUNER=y
+# CONFIG_MEDIA_TUNER_CUSTOMISE is not set
+CONFIG_MEDIA_TUNER_SIMPLE=y
+CONFIG_MEDIA_TUNER_TDA8290=y
+CONFIG_MEDIA_TUNER_TDA9887=y
+CONFIG_MEDIA_TUNER_TEA5761=y
+CONFIG_MEDIA_TUNER_TEA5767=y
+CONFIG_MEDIA_TUNER_MT20XX=y
+CONFIG_MEDIA_TUNER_XC2028=y
+CONFIG_MEDIA_TUNER_XC5000=y
+CONFIG_MEDIA_TUNER_MC44S803=y
+CONFIG_VIDEO_V4L2=y
+CONFIG_VIDEOBUF_GEN=y
+CONFIG_VIDEOBUF_DMA_CONTIG=y
+CONFIG_VIDEO_CAPTURE_DRIVERS=y
+# CONFIG_VIDEO_ADV_DEBUG is not set
+# CONFIG_VIDEO_FIXED_MINOR_RANGES is not set
+CONFIG_VIDEO_HELPER_CHIPS_AUTO=y
+CONFIG_VIDEO_IR_I2C=y
+# CONFIG_VIDEO_VIVI is not set
+CONFIG_VIDEO_OMAP2_VOUT=y
+# CONFIG_VIDEO_SAA5246A is not set
+# CONFIG_VIDEO_SAA5249 is not set
+# CONFIG_SOC_CAMERA is not set
+# CONFIG_V4L_MEM2MEM_DRIVERS is not set
+CONFIG_RADIO_ADAPTERS=y
+# CONFIG_I2C_SI4713 is not set
+# CONFIG_RADIO_SI4713 is not set
+# CONFIG_RADIO_SI470X is not set
+# CONFIG_RADIO_TEA5764 is not set
+# CONFIG_RADIO_SAA7706H is not set
+# CONFIG_RADIO_TEF6862 is not set
+# CONFIG_DAB is not set
+CONFIG_DMM_OMAP=y
+CONFIG_TILER_OMAP=y
+
+#
+# Graphics support
+#
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+CONFIG_FB=y
+# CONFIG_FIRMWARE_EDID is not set
+# CONFIG_FB_DDC is not set
+# CONFIG_FB_BOOT_VESA_SUPPORT is not set
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set
+# CONFIG_FB_SYS_FILLRECT is not set
+# CONFIG_FB_SYS_COPYAREA is not set
+# CONFIG_FB_SYS_IMAGEBLIT is not set
+# CONFIG_FB_FOREIGN_ENDIAN is not set
+# CONFIG_FB_SYS_FOPS is not set
+# CONFIG_FB_SVGALIB is not set
+# CONFIG_FB_MACMODES is not set
+# CONFIG_FB_BACKLIGHT is not set
+# CONFIG_FB_MODE_HELPERS is not set
+# CONFIG_FB_TILEBLITTING is not set
+
+#
+# Frame buffer hardware drivers
+#
+# CONFIG_FB_S1D13XXX is not set
+# CONFIG_FB_TMIO is not set
+# CONFIG_FB_VIRTUAL is not set
+# CONFIG_FB_METRONOME is not set
+# CONFIG_FB_MB862XX is not set
+# CONFIG_FB_BROADSHEET is not set
+# CONFIG_FB_OMAP_BOOTLOADER_INIT is not set
+CONFIG_OMAP2_VRAM=y
+CONFIG_OMAP2_DSS=y
+CONFIG_OMAP2_VRAM_SIZE=4
+CONFIG_OMAP2_DSS_DEBUG_SUPPORT=y
+# CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS is not set
+CONFIG_OMAP2_DSS_DPI=y
+# CONFIG_OMAP2_DSS_RFBI is not set
+# CONFIG_OMAP2_DSS_VENC is not set
+CONFIG_OMAP2_DSS_HDMI=y
+CONFIG_OMAP2_DSS_DSI=y
+# CONFIG_OMAP2_DSS_USE_DSI_PLL is not set
+CONFIG_OMAP2_DSS_FAKE_VSYNC=y
+CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK=0
+CONFIG_FB_OMAP2=y
+CONFIG_FB_OMAP2_DEBUG_SUPPORT=y
+CONFIG_FB_OMAP2_NUM_FBS=2
+
+#
+# OMAP2/3 Display Device Drivers
+#
+# CONFIG_PANEL_GENERIC is not set
+# CONFIG_PANEL_SHARP_LS037V7DW01 is not set
+# CONFIG_PANEL_SHARP_LQ043T1DG01 is not set
+CONFIG_PANEL_PICO_DLP=y
+CONFIG_PANEL_TAAL=y
+# CONFIG_PANEL_TOPPOLY_TDO35S is not set
+# CONFIG_PANEL_TPO_TD043MTEA1 is not set
+CONFIG_BACKLIGHT_LCD_SUPPORT=y
+CONFIG_LCD_CLASS_DEVICE=y
+# CONFIG_LCD_L4F00242T03 is not set
+# CONFIG_LCD_LMS283GF05 is not set
+# CONFIG_LCD_LTV350QV is not set
+# CONFIG_LCD_TDO24M is not set
+# CONFIG_LCD_VGG2432A4 is not set
+# CONFIG_LCD_PLATFORM is not set
+# CONFIG_LCD_S6E63M0 is not set
+CONFIG_BACKLIGHT_CLASS_DEVICE=y
+CONFIG_BACKLIGHT_GENERIC=y
+# CONFIG_BACKLIGHT_PWM is not set
+# CONFIG_BACKLIGHT_ADP8860 is not set
+
+#
+# Display device support
+#
+# CONFIG_DISPLAY_SUPPORT is not set
+
+#
+# Console display driver support
+#
+# CONFIG_VGA_CONSOLE is not set
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+CONFIG_FONTS=y
+CONFIG_FONT_8x8=y
+CONFIG_FONT_8x16=y
+# CONFIG_FONT_6x11 is not set
+# CONFIG_FONT_7x14 is not set
+# CONFIG_FONT_PEARL_8x8 is not set
+# CONFIG_FONT_ACORN_8x8 is not set
+# CONFIG_FONT_MINI_4x6 is not set
+# CONFIG_FONT_SUN8x16 is not set
+# CONFIG_FONT_SUN12x22 is not set
+# CONFIG_FONT_10x18 is not set
+CONFIG_LOGO=y
+CONFIG_LOGO_LINUX_MONO=y
+CONFIG_LOGO_LINUX_VGA16=y
+CONFIG_LOGO_LINUX_CLUT224=y
+CONFIG_SOUND=y
+# CONFIG_SOUND_OSS_CORE is not set
+CONFIG_SND=y
+CONFIG_SND_TIMER=y
+CONFIG_SND_PCM=y
+CONFIG_SND_JACK=y
+# CONFIG_SND_SEQUENCER is not set
+# CONFIG_SND_MIXER_OSS is not set
+# CONFIG_SND_PCM_OSS is not set
+# CONFIG_SND_HRTIMER is not set
+CONFIG_SND_DYNAMIC_MINORS=y
+CONFIG_SND_SUPPORT_OLD_API=y
+CONFIG_SND_VERBOSE_PROCFS=y
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+# CONFIG_SND_RAWMIDI_SEQ is not set
+# CONFIG_SND_OPL3_LIB_SEQ is not set
+# CONFIG_SND_OPL4_LIB_SEQ is not set
+# CONFIG_SND_SBAWE_SEQ is not set
+# CONFIG_SND_EMU10K1_SEQ is not set
+CONFIG_SND_DRIVERS=y
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+CONFIG_SND_ARM=y
+CONFIG_SND_SPI=y
+CONFIG_SND_SOC=y
+CONFIG_SND_OMAP_SOC=y
+CONFIG_SND_OMAP_SOC_ABE_DSP=y
+CONFIG_SND_OMAP_SOC_MCBSP=y
+CONFIG_SND_OMAP_SOC_MCPDM=y
+CONFIG_SND_OMAP_SOC_ABE=y
+CONFIG_SND_OMAP_SOC_DMIC=y
+CONFIG_SND_OMAP_SOC_SDP4430=y
+CONFIG_SND_OMAP_SOC_HDMI=y
+CONFIG_SND_SOC_I2C_AND_SPI=y
+# CONFIG_SND_SOC_ALL_CODECS is not set
+CONFIG_SND_SOC_DMIC=y
+CONFIG_SND_SOC_TWL6040=y
+# CONFIG_SOUND_PRIME is not set
+# CONFIG_HID_SUPPORT is not set
+CONFIG_USB_SUPPORT=y
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB_ARCH_HAS_EHCI=y
+# CONFIG_USB is not set
+# CONFIG_USB_OTG_WHITELIST is not set
+# CONFIG_USB_OTG_BLACKLIST_HUB is not set
+CONFIG_USB_MUSB_HDRC=y
+CONFIG_USB_MUSB_SOC=y
+
+#
+# OMAP 44xx high speed USB support
+#
+# CONFIG_USB_MUSB_HOST is not set
+CONFIG_USB_MUSB_PERIPHERAL=y
+# CONFIG_USB_MUSB_OTG is not set
+CONFIG_USB_GADGET_MUSB_HDRC=y
+# CONFIG_MUSB_PIO_ONLY is not set
+CONFIG_USB_INVENTRA_DMA=y
+# CONFIG_USB_TI_CPPI_DMA is not set
+# CONFIG_USB_MUSB_DEBUG is not set
+
+#
+# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may
+#
+CONFIG_USB_GADGET=y
+# CONFIG_USB_GADGET_DEBUG is not set
+# CONFIG_USB_GADGET_DEBUG_FILES is not set
+# CONFIG_USB_GADGET_DEBUG_FS is not set
+CONFIG_USB_GADGET_VBUS_DRAW=2
+CONFIG_USB_GADGET_SELECTED=y
+# CONFIG_USB_GADGET_AT91 is not set
+# CONFIG_USB_GADGET_ATMEL_USBA is not set
+# CONFIG_USB_GADGET_FSL_USB2 is not set
+# CONFIG_USB_GADGET_LH7A40X is not set
+# CONFIG_USB_GADGET_OMAP is not set
+# CONFIG_USB_GADGET_PXA25X is not set
+# CONFIG_USB_GADGET_R8A66597 is not set
+# CONFIG_USB_GADGET_PXA27X is not set
+# CONFIG_USB_GADGET_S3C_HSOTG is not set
+# CONFIG_USB_GADGET_IMX is not set
+# CONFIG_USB_GADGET_S3C2410 is not set
+# CONFIG_USB_GADGET_M66592 is not set
+# CONFIG_USB_GADGET_AMD5536UDC is not set
+# CONFIG_USB_GADGET_FSL_QE is not set
+# CONFIG_USB_GADGET_CI13XXX is not set
+# CONFIG_USB_GADGET_NET2280 is not set
+# CONFIG_USB_GADGET_GOKU is not set
+# CONFIG_USB_GADGET_LANGWELL is not set
+# CONFIG_USB_GADGET_DUMMY_HCD is not set
+CONFIG_USB_GADGET_DUALSPEED=y
+CONFIG_USB_ZERO=m
+# CONFIG_USB_AUDIO is not set
+CONFIG_USB_ETH=m
+CONFIG_USB_ETH_RNDIS=y
+# CONFIG_USB_ETH_EEM is not set
+# CONFIG_USB_GADGETFS is not set
+# CONFIG_USB_FUNCTIONFS is not set
+CONFIG_USB_FILE_STORAGE=m
+# CONFIG_USB_FILE_STORAGE_TEST is not set
+# CONFIG_USB_MASS_STORAGE is not set
+CONFIG_USB_G_SERIAL=m
+# CONFIG_USB_MIDI_GADGET is not set
+# CONFIG_USB_G_PRINTER is not set
+# CONFIG_USB_ANDROID is not set
+CONFIG_USB_CDC_COMPOSITE=m
+# CONFIG_USB_G_NOKIA is not set
+CONFIG_USB_G_MULTI=m
+CONFIG_USB_G_MULTI_RNDIS=y
+CONFIG_USB_G_MULTI_CDC=y
+# CONFIG_USB_G_HID is not set
+# CONFIG_USB_G_DBGP is not set
+# CONFIG_USB_G_WEBCAM is not set
+
+#
+# OTG and related infrastructure
+#
+CONFIG_USB_OTG_UTILS=y
+# CONFIG_USB_GPIO_VBUS is not set
+# CONFIG_USB_ULPI is not set
+# CONFIG_TWL4030_USB is not set
+CONFIG_NOP_USB_XCEIV=y
+CONFIG_MMC=y
+# CONFIG_MMC_DEBUG is not set
+CONFIG_MMC_UNSAFE_RESUME=y
+# CONFIG_MMC_EMBEDDED_SDIO is not set
+# CONFIG_MMC_PARANOID_SD_INIT is not set
+
+#
+# MMC/SD/SDIO Card Drivers
+#
+CONFIG_MMC_BLOCK=y
+CONFIG_MMC_BLOCK_BOUNCE=y
+# CONFIG_MMC_BLOCK_DEFERRED_RESUME is not set
+# CONFIG_SDIO_UART is not set
+# CONFIG_MMC_TEST is not set
+
+#
+# MMC/SD/SDIO Host Controller Drivers
+#
+# CONFIG_MMC_SDHCI is not set
+# CONFIG_MMC_OMAP is not set
+CONFIG_MMC_OMAP_HS=y
+# CONFIG_MMC_SPI is not set
+# CONFIG_MEMSTICK is not set
+CONFIG_NEW_LEDS=y
+CONFIG_LEDS_CLASS=y
+
+#
+# LED drivers
+#
+# CONFIG_LEDS_PCA9532 is not set
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_GPIO_PLATFORM=y
+# CONFIG_LEDS_LP3944 is not set
+# CONFIG_LEDS_PCA955X is not set
+# CONFIG_LEDS_DAC124S085 is not set
+CONFIG_LEDS_PWM=y
+# CONFIG_LEDS_REGULATOR is not set
+# CONFIG_LEDS_BD2802 is not set
+# CONFIG_LEDS_LT3593 is not set
+# CONFIG_LEDS_TRIGGERS is not set
+CONFIG_SWITCH=y
+CONFIG_SWITCH_GPIO=y
+# CONFIG_ACCESSIBILITY is not set
+CONFIG_RTC_LIB=y
+CONFIG_RTC_CLASS=y
+CONFIG_RTC_HCTOSYS=y
+CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
+# CONFIG_RTC_DEBUG is not set
+
+#
+# RTC interfaces
+#
+CONFIG_RTC_INTF_SYSFS=y
+CONFIG_RTC_INTF_PROC=y
+CONFIG_RTC_INTF_DEV=y
+# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
+CONFIG_RTC_INTF_ALARM=y
+CONFIG_RTC_INTF_ALARM_DEV=y
+# CONFIG_RTC_DRV_TEST is not set
+
+#
+# I2C RTC drivers
+#
+# CONFIG_RTC_DRV_DS1307 is not set
+# CONFIG_RTC_DRV_DS1374 is not set
+# CONFIG_RTC_DRV_DS1672 is not set
+# CONFIG_RTC_DRV_MAX6900 is not set
+# CONFIG_RTC_DRV_RS5C372 is not set
+# CONFIG_RTC_DRV_ISL1208 is not set
+# CONFIG_RTC_DRV_X1205 is not set
+# CONFIG_RTC_DRV_PCF8563 is not set
+# CONFIG_RTC_DRV_PCF8583 is not set
+# CONFIG_RTC_DRV_M41T80 is not set
+# CONFIG_RTC_DRV_BQ32K is not set
+CONFIG_RTC_DRV_TWL4030=y
+# CONFIG_RTC_DRV_S35390A is not set
+# CONFIG_RTC_DRV_FM3130 is not set
+# CONFIG_RTC_DRV_RX8581 is not set
+# CONFIG_RTC_DRV_RX8025 is not set
+
+#
+# SPI RTC drivers
+#
+# CONFIG_RTC_DRV_M41T94 is not set
+# CONFIG_RTC_DRV_DS1305 is not set
+# CONFIG_RTC_DRV_DS1390 is not set
+# CONFIG_RTC_DRV_MAX6902 is not set
+# CONFIG_RTC_DRV_R9701 is not set
+# CONFIG_RTC_DRV_RS5C348 is not set
+# CONFIG_RTC_DRV_DS3234 is not set
+# CONFIG_RTC_DRV_PCF2123 is not set
+
+#
+# Platform RTC drivers
+#
+# CONFIG_RTC_DRV_CMOS is not set
+# CONFIG_RTC_DRV_DS1286 is not set
+# CONFIG_RTC_DRV_DS1511 is not set
+# CONFIG_RTC_DRV_DS1553 is not set
+# CONFIG_RTC_DRV_DS1742 is not set
+# CONFIG_RTC_DRV_STK17TA8 is not set
+# CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T35 is not set
+# CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_MSM6242 is not set
+# CONFIG_RTC_DRV_BQ4802 is not set
+# CONFIG_RTC_DRV_RP5C01 is not set
+# CONFIG_RTC_DRV_V3020 is not set
+
+#
+# on-CPU RTC drivers
+#
+# CONFIG_DMADEVICES is not set
+# CONFIG_AUXDISPLAY is not set
+# CONFIG_UIO is not set
+CONFIG_STAGING=y
+# CONFIG_STAGING_EXCLUDE_BUILD is not set
+# CONFIG_ECHO is not set
+# CONFIG_COMEDI is not set
+
+#
+# Android
+#
+CONFIG_ANDROID=y
+CONFIG_ANDROID_BINDER_IPC=y
+CONFIG_ANDROID_LOGGER=y
+CONFIG_ANDROID_RAM_CONSOLE=y
+CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE=y
+# CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION is not set
+# CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT is not set
+CONFIG_ANDROID_TIMED_OUTPUT=y
+CONFIG_ANDROID_TIMED_GPIO=y
+CONFIG_ANDROID_LOW_MEMORY_KILLER=y
+# CONFIG_POHMELFS is not set
+
+#
+# RAR Register Driver
+#
+CONFIG_IIO=y
+# CONFIG_IIO_RING_BUFFER is not set
+# CONFIG_IIO_TRIGGER is not set
+
+#
+# Accelerometers
+#
+# CONFIG_ADIS16209 is not set
+# CONFIG_ADIS16220 is not set
+# CONFIG_ADIS16240 is not set
+# CONFIG_KXSD9 is not set
+# CONFIG_LIS3L02DQ is not set
+
+#
+# Analog to digital convertors
+#
+# CONFIG_MAX1363 is not set
+
+#
+# Digital gyroscope sensors
+#
+# CONFIG_ADIS16260 is not set
+
+#
+# Inertial measurement units
+#
+# CONFIG_ADIS16300 is not set
+# CONFIG_ADIS16350 is not set
+# CONFIG_ADIS16400 is not set
+
+#
+# Light sensors
+#
+# CONFIG_SENSORS_TSL2563 is not set
+
+#
+# Magnetometer sensors
+#
+CONFIG_SENSORS_HMC5843=y
+
+#
+# Triggers - standalone
+#
+# CONFIG_RAMZSWAP is not set
+# CONFIG_BATMAN_ADV is not set
+# CONFIG_FB_SM7XX is not set
+
+#
+# Texas Instruments shared transport line discipline
+#
+CONFIG_TI_ST=m
+CONFIG_ST_BT=m
+CONFIG_ST_FM=m
+# CONFIG_ADIS16255 is not set
+CONFIG_Sys_Link=y
+CONFIG_SYSLINK_PROC=y
+CONFIG_SYSLINK_PROC4430=y
+CONFIG_DUCATI_BASEIMAGE_PHYS_ADDR=0x9CF00000
+CONFIG_SYSLINK_DUCATI_PM=y
+CONFIG_OMAP_DEVICE_HANDLER=y
+CONFIG_MPU_SYSLINK_PLATFORM=y
+CONFIG_MPU_SYSLINK_IPC=y
+CONFIG_SYSLINK_USE_SYSMGR=y
+CONFIG_SYSLINK_IOMMU_ENABLE=y
+CONFIG_SYSLINK_RECOVERY=y
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+# CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
+# CONFIG_EXT3_FS_XATTR is not set
+# CONFIG_EXT4_FS is not set
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+CONFIG_FS_POSIX_ACL=y
+# CONFIG_XFS_FS is not set
+# CONFIG_GFS2_FS is not set
+# CONFIG_OCFS2_FS is not set
+# CONFIG_BTRFS_FS is not set
+# CONFIG_NILFS2_FS is not set
+CONFIG_FILE_LOCKING=y
+CONFIG_FSNOTIFY=y
+CONFIG_DNOTIFY=y
+CONFIG_INOTIFY=y
+CONFIG_INOTIFY_USER=y
+CONFIG_QUOTA=y
+# CONFIG_QUOTA_NETLINK_INTERFACE is not set
+CONFIG_PRINT_QUOTA_WARNING=y
+# CONFIG_QUOTA_DEBUG is not set
+CONFIG_QUOTA_TREE=y
+# CONFIG_QFMT_V1 is not set
+CONFIG_QFMT_V2=y
+CONFIG_QUOTACTL=y
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+CONFIG_FAT_FS=y
+CONFIG_MSDOS_FS=y
+CONFIG_VFAT_FS=y
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_SYSCTL=y
+CONFIG_PROC_PAGE_MONITOR=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_TMPFS_POSIX_ACL is not set
+# CONFIG_HUGETLB_PAGE is not set
+# CONFIG_CONFIGFS_FS is not set
+CONFIG_MISC_FILESYSTEMS=y
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_LOGFS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_SQUASHFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_OMFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_ROMFS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+CONFIG_NETWORK_FILESYSTEMS=y
+CONFIG_NFS_FS=y
+CONFIG_NFS_V3=y
+CONFIG_NFS_V3_ACL=y
+CONFIG_NFS_V4=y
+# CONFIG_NFS_V4_1 is not set
+CONFIG_ROOT_NFS=y
+# CONFIG_NFSD is not set
+CONFIG_LOCKD=y
+CONFIG_LOCKD_V4=y
+CONFIG_NFS_ACL_SUPPORT=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+CONFIG_SUNRPC_GSS=y
+CONFIG_RPCSEC_GSS_KRB5=y
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+# CONFIG_SMB_FS is not set
+# CONFIG_CEPH_FS is not set
+# CONFIG_CIFS is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+# CONFIG_ACORN_PARTITION is not set
+# CONFIG_OSF_PARTITION is not set
+# CONFIG_AMIGA_PARTITION is not set
+# CONFIG_ATARI_PARTITION is not set
+# CONFIG_MAC_PARTITION is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_BSD_DISKLABEL is not set
+# CONFIG_MINIX_SUBPARTITION is not set
+# CONFIG_SOLARIS_X86_PARTITION is not set
+# CONFIG_UNIXWARE_DISKLABEL is not set
+# CONFIG_LDM_PARTITION is not set
+# CONFIG_SGI_PARTITION is not set
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+# CONFIG_SYSV68_PARTITION is not set
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="iso8859-1"
+CONFIG_NLS_CODEPAGE_437=y
+# CONFIG_NLS_CODEPAGE_737 is not set
+# CONFIG_NLS_CODEPAGE_775 is not set
+# CONFIG_NLS_CODEPAGE_850 is not set
+# CONFIG_NLS_CODEPAGE_852 is not set
+# CONFIG_NLS_CODEPAGE_855 is not set
+# CONFIG_NLS_CODEPAGE_857 is not set
+# CONFIG_NLS_CODEPAGE_860 is not set
+# CONFIG_NLS_CODEPAGE_861 is not set
+# CONFIG_NLS_CODEPAGE_862 is not set
+# CONFIG_NLS_CODEPAGE_863 is not set
+# CONFIG_NLS_CODEPAGE_864 is not set
+# CONFIG_NLS_CODEPAGE_865 is not set
+# CONFIG_NLS_CODEPAGE_866 is not set
+# CONFIG_NLS_CODEPAGE_869 is not set
+# CONFIG_NLS_CODEPAGE_936 is not set
+# CONFIG_NLS_CODEPAGE_950 is not set
+# CONFIG_NLS_CODEPAGE_932 is not set
+# CONFIG_NLS_CODEPAGE_949 is not set
+# CONFIG_NLS_CODEPAGE_874 is not set
+# CONFIG_NLS_ISO8859_8 is not set
+# CONFIG_NLS_CODEPAGE_1250 is not set
+# CONFIG_NLS_CODEPAGE_1251 is not set
+# CONFIG_NLS_ASCII is not set
+CONFIG_NLS_ISO8859_1=y
+# CONFIG_NLS_ISO8859_2 is not set
+# CONFIG_NLS_ISO8859_3 is not set
+# CONFIG_NLS_ISO8859_4 is not set
+# CONFIG_NLS_ISO8859_5 is not set
+# CONFIG_NLS_ISO8859_6 is not set
+# CONFIG_NLS_ISO8859_7 is not set
+# CONFIG_NLS_ISO8859_9 is not set
+# CONFIG_NLS_ISO8859_13 is not set
+# CONFIG_NLS_ISO8859_14 is not set
+# CONFIG_NLS_ISO8859_15 is not set
+# CONFIG_NLS_KOI8_R is not set
+# CONFIG_NLS_KOI8_U is not set
+# CONFIG_NLS_UTF8 is not set
+# CONFIG_DLM is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_ENABLE_WARN_DEPRECATED is not set
+# CONFIG_ENABLE_MUST_CHECK is not set
+CONFIG_FRAME_WARN=1024
+CONFIG_MAGIC_SYSRQ=y
+# CONFIG_STRIP_ASM_SYMS is not set
+# CONFIG_UNUSED_SYMBOLS is not set
+CONFIG_DEBUG_FS=y
+# CONFIG_HEADERS_CHECK is not set
+CONFIG_DEBUG_KERNEL=y
+# CONFIG_DEBUG_SHIRQ is not set
+# CONFIG_DETECT_SOFTLOCKUP is not set
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
+# CONFIG_SCHED_DEBUG is not set
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_TIMER_STATS is not set
+# CONFIG_DEBUG_OBJECTS is not set
+# CONFIG_SLUB_DEBUG_ON is not set
+# CONFIG_SLUB_STATS is not set
+# CONFIG_DEBUG_KMEMLEAK is not set
+# CONFIG_DEBUG_PREEMPT is not set
+# CONFIG_DEBUG_RT_MUTEXES is not set
+# CONFIG_RT_MUTEX_TESTER is not set
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_MUTEXES is not set
+# CONFIG_DEBUG_LOCK_ALLOC is not set
+# CONFIG_PROVE_LOCKING is not set
+# CONFIG_LOCK_STAT is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
+# CONFIG_DEBUG_KOBJECT is not set
+# CONFIG_DEBUG_BUGVERBOSE is not set
+CONFIG_DEBUG_INFO=y
+# CONFIG_DEBUG_VM is not set
+# CONFIG_DEBUG_WRITECOUNT is not set
+# CONFIG_DEBUG_MEMORY_INIT is not set
+# CONFIG_DEBUG_LIST is not set
+# CONFIG_DEBUG_SG is not set
+# CONFIG_DEBUG_NOTIFIERS is not set
+# CONFIG_DEBUG_CREDENTIALS is not set
+CONFIG_FRAME_POINTER=y
+# CONFIG_BOOT_PRINTK_DELAY is not set
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
+# CONFIG_BACKTRACE_SELF_TEST is not set
+# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set
+# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set
+# CONFIG_LKDTM is not set
+# CONFIG_CPU_NOTIFIER_ERROR_INJECT is not set
+# CONFIG_FAULT_INJECTION is not set
+# CONFIG_SYSCTL_SYSCALL_CHECK is not set
+# CONFIG_PAGE_POISONING is not set
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_TRACING_SUPPORT=y
+# CONFIG_FTRACE is not set
+# CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_ATOMIC64_SELFTEST is not set
+# CONFIG_SAMPLES is not set
+CONFIG_HAVE_ARCH_KGDB=y
+# CONFIG_KGDB is not set
+# CONFIG_ARM_UNWIND is not set
+# CONFIG_DEBUG_USER is not set
+# CONFIG_DEBUG_ERRORS is not set
+# CONFIG_DEBUG_STACK_USAGE is not set
+# CONFIG_DEBUG_LL is not set
+# CONFIG_OC_ETM is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+# CONFIG_SECURITYFS is not set
+# CONFIG_DEFAULT_SECURITY_SELINUX is not set
+# CONFIG_DEFAULT_SECURITY_SMACK is not set
+# CONFIG_DEFAULT_SECURITY_TOMOYO is not set
+CONFIG_DEFAULT_SECURITY_DAC=y
+CONFIG_DEFAULT_SECURITY=""
+CONFIG_CRYPTO=y
+
+#
+# Crypto core or helper
+#
+CONFIG_CRYPTO_ALGAPI=y
+CONFIG_CRYPTO_ALGAPI2=y
+CONFIG_CRYPTO_AEAD2=y
+CONFIG_CRYPTO_BLKCIPHER=y
+CONFIG_CRYPTO_BLKCIPHER2=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_RNG2=y
+CONFIG_CRYPTO_PCOMP=y
+CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
+# CONFIG_CRYPTO_GF128MUL is not set
+# CONFIG_CRYPTO_NULL is not set
+# CONFIG_CRYPTO_PCRYPT is not set
+CONFIG_CRYPTO_WORKQUEUE=y
+# CONFIG_CRYPTO_CRYPTD is not set
+# CONFIG_CRYPTO_AUTHENC is not set
+# CONFIG_CRYPTO_TEST is not set
+
+#
+# Authenticated Encryption with Associated Data
+#
+# CONFIG_CRYPTO_CCM is not set
+# CONFIG_CRYPTO_GCM is not set
+# CONFIG_CRYPTO_SEQIV is not set
+
+#
+# Block modes
+#
+CONFIG_CRYPTO_CBC=y
+# CONFIG_CRYPTO_CTR is not set
+# CONFIG_CRYPTO_CTS is not set
+CONFIG_CRYPTO_ECB=m
+# CONFIG_CRYPTO_LRW is not set
+CONFIG_CRYPTO_PCBC=m
+# CONFIG_CRYPTO_XTS is not set
+
+#
+# Hash modes
+#
+# CONFIG_CRYPTO_HMAC is not set
+# CONFIG_CRYPTO_XCBC is not set
+# CONFIG_CRYPTO_VMAC is not set
+
+#
+# Digest
+#
+CONFIG_CRYPTO_CRC32C=y
+# CONFIG_CRYPTO_GHASH is not set
+# CONFIG_CRYPTO_MD4 is not set
+CONFIG_CRYPTO_MD5=y
+# CONFIG_CRYPTO_MICHAEL_MIC is not set
+# CONFIG_CRYPTO_RMD128 is not set
+# CONFIG_CRYPTO_RMD160 is not set
+# CONFIG_CRYPTO_RMD256 is not set
+# CONFIG_CRYPTO_RMD320 is not set
+# CONFIG_CRYPTO_SHA1 is not set
+# CONFIG_CRYPTO_SHA256 is not set
+# CONFIG_CRYPTO_SHA512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
+# CONFIG_CRYPTO_WP512 is not set
+
+#
+# Ciphers
+#
+# CONFIG_CRYPTO_AES is not set
+# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_ARC4 is not set
+# CONFIG_CRYPTO_BLOWFISH is not set
+# CONFIG_CRYPTO_CAMELLIA is not set
+# CONFIG_CRYPTO_CAST5 is not set
+# CONFIG_CRYPTO_CAST6 is not set
+CONFIG_CRYPTO_DES=y
+# CONFIG_CRYPTO_FCRYPT is not set
+# CONFIG_CRYPTO_KHAZAD is not set
+# CONFIG_CRYPTO_SALSA20 is not set
+# CONFIG_CRYPTO_SEED is not set
+# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_TEA is not set
+# CONFIG_CRYPTO_TWOFISH is not set
+
+#
+# Compression
+#
+# CONFIG_CRYPTO_DEFLATE is not set
+# CONFIG_CRYPTO_ZLIB is not set
+# CONFIG_CRYPTO_LZO is not set
+
+#
+# Random Number Generation
+#
+# CONFIG_CRYPTO_ANSI_CPRNG is not set
+CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
+
+#
+# Library routines
+#
+CONFIG_BITREVERSE=y
+CONFIG_GENERIC_FIND_LAST_BIT=y
+CONFIG_CRC_CCITT=y
+CONFIG_CRC16=y
+CONFIG_CRC_T10DIF=y
+# CONFIG_CRC_ITU_T is not set
+CONFIG_CRC32=y
+# CONFIG_CRC7 is not set
+CONFIG_LIBCRC32C=y
+CONFIG_ZLIB_INFLATE=y
+CONFIG_DECOMPRESS_GZIP=y
+CONFIG_GENERIC_ALLOCATOR=y
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT=y
+CONFIG_HAS_DMA=y
+CONFIG_NLATTR=y
diff --git a/drivers/gpu/Makefile b/drivers/gpu/Makefile
index cc9277885dd..5a2011531b8 100644
--- a/drivers/gpu/Makefile
+++ b/drivers/gpu/Makefile
@@ -1 +1,2 @@
 obj-y                   += drm/ vga/ stub/
+obj-y                   += pvr/
diff --git a/drivers/gpu/pvr/Kconfig b/drivers/gpu/pvr/Kconfig
new file mode 100644
index 00000000000..8479735bb2f
--- /dev/null
+++ b/drivers/gpu/pvr/Kconfig
@@ -0,0 +1,90 @@
+config SGX540
+        tristate "PowerVR SGX"
+        depends on ARCH_OMAP4
+        ---help---
+          Support for the PowerVR SGX 3D core.
+
+config SGX530
+        tristate "PowerVR SGX"
+        depends on ARCH_OMAP3
+        ---help---
+          Support for the PowerVR SGX 3D core.
+
+config VIRTUAL_DISPLAY_SUPPORT
+        tristate "Virtual display support"
+        depends on SGX540
+        ---help---
+          Support for showing one framebuffer split in 2 displays at the same
+          time. Each display will show a part of the framebuffer by updating
+          the corresponding overlay on each display. This feature requires
+          2 framebuffers so CONFIG_FB_OMAP2_NUM_FBS must be 2 and each
+          framebuffer must be initialized correctly.
+          The current implementation supports only panels of the same X and Y
+          resolutions and both panels must have the same bits per pixel values.
+          This feature is EXPERIMENTAL and might not be stable if power
+          management is added at the moment.
+          It is important to give enough memory to FB0 to allow at least
+          one buffer with twice the height of a normal single display buffer,
+          so if the panel needs 864x480x4 bytes for one single display buffer
+          you must give twice the size which is 864x960x4 with the bootargs
+          omapfb.vram='0:4M'. To enable double buffering you need to give
+          864x960x4x2 bytes for two buffers, the bootargs should have
+          omapfb.vram='0:8M'. Since FB1 must also be initialized properly be
+          sure to left enough memory for one single buffer (864x480x4 bytes).
+          The bootarg 'vram' must have the FB0 and FB1 memory requirements
+          combined. Example:
+          If you want FB0 with 4M (no double buffering) and FB1 with 2M, the
+          bootargs must have the following:
+          vram='6M' omapfb.vram='0:4M,1:2M'
+
+choice
+        prompt "SGX revision"
+        depends on SGX530
+        default SGX_REV125
+
+config SGX_REV121
+       bool "Revision 1.2.1 - Omap 3430"
+
+config SGX_REV125
+        bool "Revision 1.2.5 - Omap 3630"
+
+endchoice
+
+choice
+        prompt "SGX revision"
+        depends on SGX540
+        default SGX_REV120
+
+config SGX_REV110
+       bool "Revision 1.1.0 - Omap 4430 ES1"
+
+config SGX_REV120
+       bool "Revision 1.2.0 - Omap 4430 ES2"
+
+endchoice
+
+choice
+        prompt "PowerVR build type"
+        depends on SGX530
+        default SGX_530_BUILD_RELEASE
+
+config SGX_530_BUILD_RELEASE
+       bool "SGX530 RELEASE"
+
+config SGX_530_BUILD_DEBUG
+       bool "SGX530 DEBUG"
+
+endchoice
+
+choice
+        prompt "PowerVR build type"
+        depends on SGX540
+        default SGX_540_BUILD_RELEASE
+
+config SGX_540_BUILD_RELEASE
+       bool "SGX540 RELEASE"
+
+config SGX_540_BUILD_DEBUG
+       bool "SGX540 DEBUG"
+
+endchoice
diff --git a/drivers/gpu/pvr/Makefile b/drivers/gpu/pvr/Makefile
new file mode 100644
index 00000000000..b49aea59deb
--- /dev/null
+++ b/drivers/gpu/pvr/Makefile
@@ -0,0 +1,141 @@
+#
+ccflags-y = -DLINUX -D__linux__ -Idrivers/gpu/pvr \
+        -DANDROID \
+        -DPVR_BUILD_DIR="\"omap_sgx_android\"" \
+        -DSGX_DYNAMIC_TIMING_INFO \
+        -DSYS_CUSTOM_POWERLOCK_WRAP \
+        -DSERVICES4 \
+        -DSUPPORT_SRVINIT \
+        -DSUPPORT_PERCONTEXT_PB \
+        -DTRANSFER_QUEUE \
+        -DSYS_USING_INTERRUPTS \
+        -DPVR_SECURE_HANDLES \
+        -DPVR_SECURE_FD_EXPORT \
+        -DLDM_PLATFORM \
+        -DSUPPORT_SGX_HWPERF \
+        -DSUPPORT_MEMINFO_IDS \
+        -DDISPLAY_CONTROLLER=omaplfb \
+        -DSYS_SGX_ACTIVE_POWER_LATENCY_MS=100 \
+        -DPVR_BUILD_DATE="" \
+        -DSUPPORT_SGX \
+        -DCLIENT_DRIVER_DEFAULT_WAIT_RETRIES=50 \
+        -DPVR_LINUX_TIMERS_USING_WORKQUEUES \
+        -DFLIP_TECHNIQUE_OVERLAY \
+        -DPVR_LINUX_USING_WORKQUEUES \
+        -DSUPPORT_ANDROID_PLATFORM \
+        -DPVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE \
+        -DSYS_CUSTOM_POWERLOCK_WRAP \
+        -DSUPPORT_SGX_NEW_STATUS_VALS \
+        -DPVRSRV_MODNAME="\"pvrsrvkm"\"
+
+ccflags-$(CONFIG_SGX540) +=  -Idrivers/gpu/pvr/omap4  -Idrivers/gpu/pvr/sgx \
+        -DNO_OMAP_TIMER \
+        -DSGX_CLK_CORE_DIV5 \
+        -DSGX540 -DSUPPORT_SGX540
+
+ccflags-$(CONFIG_SGX_REV110) += -DSGX_CORE_REV=110
+ccflags-$(CONFIG_SGX_REV120) += -DSGX_CORE_REV=120
+
+ccflags-$(CONFIG_SGX530) +=  -Idrivers/gpu/pvr/omap3  -Idrivers/gpu/pvr/sgx \
+        -DSGX530 -DSUPPORT_SGX530
+
+ccflags-$(CONFIG_SGX_REV125) += -DSGX_CORE_REV=125
+ccflags-$(CONFIG_SGX_REV121) += -DSGX_CORE_REV=121
+
+ccflags-$(CONFIG_SGX_530_BUILD_RELEASE) += \
+        -DPVR_BUILD_TYPE="\"release\"" \
+        -DRELEASE \
+        -DSUPPORT_ACTIVE_POWER_MANAGEMENT \
+        -DSGX_EARLYSUSPEND \
+        -DSUPPORT_HW_RECOVERY \
+        -DSUPPORT_SGX_LOW_LATENCY_SCHEDULING
+
+ccflags-$(CONFIG_SGX_530_BUILD_DEBUG) += \
+        -DPVR_BUILD_TYPE="\"debug\""  -DDEBUG \
+        -DDEBUG_LINUX_MEMORY_ALLOCATIONS \
+        -DDEBUG_LINUX_MEM_AREAS \
+        -DDEBUG_LINUX_MMAP_AREAS \
+        -DDEBUG_BRIDGE_KM \
+        -DPVRSRV_USSE_EDM_STATUS_DEBUG \
+        -DPVRSRV_DUMP_MK_TRACE \
+        -DDEBUG_LOG_PATH_TRUNCATE="\"eurasia_km\""
+
+ccflags-$(CONFIG_SGX_540_BUILD_RELEASE) += \
+        -DPVR_BUILD_TYPE="\"release\"" \
+        -DRELEASE \
+        -DSUPPORT_SGX_LOW_LATENCY_SCHEDULING
+
+ccflags-$(CONFIG_SGX_540_BUILD_DEBUG) += \
+        -DPVR_BUILD_TYPE="\"debug\""  -DDEBUG \
+        -DDEBUG_LINUX_MEMORY_ALLOCATIONS \
+        -DDEBUG_LINUX_MEM_AREAS \
+        -DDEBUG_LINUX_MMAP_AREAS \
+        -DDEBUG_BRIDGE_KM \
+        -DPVRSRV_USSE_EDM_STATUS_DEBUG \
+        -DPVRSRV_DUMP_MK_TRACE \
+        -DDEBUG_LOG_PATH_TRUNCATE="\"eurasia_km\""
+
+pvr_common-y := \
+        osfunc.o \
+        mutils.o \
+        mmap.o \
+        module.o \
+        pdump.o \
+        proc.o \
+        pvr_bridge_k.o \
+        pvr_debug.o \
+        mm.o \
+        mutex.o \
+        event.o \
+        osperproc.o \
+        buffer_manager.o \
+        devicemem.o \
+        deviceclass.o \
+        handle.o \
+        hash.o \
+        metrics.o \
+        pvrsrv.o \
+        queue.o \
+        ra.o \
+        resman.o \
+        power.o \
+        mem.o \
+        pdump_common.o \
+        bridged_support.o \
+        bridged_pvr_bridge.o \
+        perproc.o \
+        lists.o \
+        mem_debug.o \
+        osfunc_common.o
+
+pvr540-$(CONFIG_SGX540) := \
+        omap4/sysconfig.o \
+        omap4/sysutils.o
+
+pvr530-$(CONFIG_SGX530) := \
+        omap3/sysconfig.o \
+        omap3/sysutils.o
+
+sgx-y :=  \
+        sgx/bridged_sgx_bridge.o \
+        sgx/sgxinit.o \
+        sgx/sgxpower.o \
+        sgx/sgxreset.o \
+        sgx/sgxutils.o \
+        sgx/sgxkick.o \
+        sgx/sgxtransfer.o \
+        sgx/mmu.o \
+        sgx/pb.o
+
+sgx_displayclass-y := \
+        display/omap_sgx_displayclass.o \
+        display/omap_display.o
+
+omaplfb-y := \
+        omaplfb/omaplfb_displayclass.o \
+        omaplfb/omaplfb_linux.o
+
+obj-$(CONFIG_SGX540) := pvr_common.o sgx.o omaplfb.o pvr540.o
+obj-$(CONFIG_SGX530) := pvr_common.o sgx.o omaplfb.o pvr530.o
+obj-$(CONFIG_VIRTUAL_DISPLAY_SUPPORT) := pvr_common.o sgx.o \
+        sgx_displayclass.o pvr540.o
diff --git a/drivers/gpu/pvr/bridged_pvr_bridge.c b/drivers/gpu/pvr/bridged_pvr_bridge.c
new file mode 100644
index 00000000000..2b6cb484e77
--- /dev/null
+++ b/drivers/gpu/pvr/bridged_pvr_bridge.c
@@ -0,0 +1,3881 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "img_defs.h"
+#include "services.h"
+#include "pvr_bridge_km.h"
+#include "pvr_debug.h"
+#include "ra.h"
+#include "pvr_bridge.h"
+#if defined(SUPPORT_SGX)
+#include "sgx_bridge.h"
+#endif
+#if defined(SUPPORT_VGX)
+#include "vgx_bridge.h"
+#endif
+#if defined(SUPPORT_MSVDX)
+#include "msvdx_bridge.h"
+#endif
+#include "perproc.h"
+#include "device.h"
+#include "buffer_manager.h"
+
+#include "pdump_km.h"
+#include "syscommon.h"
+
+#include "bridged_pvr_bridge.h"
+#if defined(SUPPORT_SGX)
+#include "bridged_sgx_bridge.h"
+#endif
+#if defined(SUPPORT_VGX)
+#include "bridged_vgx_bridge.h"
+#endif
+#if defined(SUPPORT_MSVDX)
+#include "bridged_msvdx_bridge.h"
+#endif
+
+#include "env_data.h"
+
+#if defined (__linux__)
+#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_BRIDGE_GLOBAL_STATS g_BridgeGlobalStats;
+#endif
+
+#if defined(PVR_SECURE_HANDLES)
+static IMG_BOOL abSharedDeviceMemHeap[PVRSRV_MAX_CLIENT_HEAPS];
+static IMG_BOOL *pbSharedDeviceMemHeap = abSharedDeviceMemHeap;
+#else
+static IMG_BOOL *pbSharedDeviceMemHeap = (IMG_BOOL*)IMG_NULL;
+#endif
+
+
+#if defined(DEBUG_BRIDGE_KM)
+PVRSRV_ERROR
+CopyFromUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
+                                        IMG_UINT32 ui32BridgeID,
+                                        IMG_VOID *pvDest,
+                                        IMG_VOID *pvSrc,
+                                        IMG_UINT32 ui32Size)
+{
+        g_BridgeDispatchTable[ui32BridgeID].ui32CopyFromUserTotalBytes+=ui32Size;
+        g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+=ui32Size;
+        return OSCopyFromUser(pProcData, pvDest, pvSrc, ui32Size);
+}
+PVRSRV_ERROR
+CopyToUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
+                                  IMG_UINT32 ui32BridgeID,
+                                  IMG_VOID *pvDest,
+                                  IMG_VOID *pvSrc,
+                                  IMG_UINT32 ui32Size)
+{
+        g_BridgeDispatchTable[ui32BridgeID].ui32CopyToUserTotalBytes+=ui32Size;
+        g_BridgeGlobalStats.ui32TotalCopyToUserBytes+=ui32Size;
+        return OSCopyToUser(pProcData, pvDest, pvSrc, ui32Size);
+}
+#endif
+
+
+static IMG_INT
+PVRSRVEnumerateDevicesBW(IMG_UINT32 ui32BridgeID,
+                                                 IMG_VOID *psBridgeIn,
+                                                 PVRSRV_BRIDGE_OUT_ENUMDEVICE *psEnumDeviceOUT,
+                                                 PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DEVICES);
+
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+
+        psEnumDeviceOUT->eError =
+                PVRSRVEnumerateDevicesKM(&psEnumDeviceOUT->ui32NumDevices,
+                                                                 psEnumDeviceOUT->asDeviceIdentifier);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVAcquireDeviceDataBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *psAcquireDevInfoIN,
+                                                  PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *psAcquireDevInfoOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO);
+
+        psAcquireDevInfoOUT->eError =
+                PVRSRVAcquireDeviceDataKM(psAcquireDevInfoIN->uiDevIndex,
+                                                                  psAcquireDevInfoIN->eDeviceType,
+                                                                  &hDevCookieInt);
+        if(psAcquireDevInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+                psAcquireDevInfoOUT->eError =
+                PVRSRVAllocHandle(psPerProc->psHandleBase,
+                                                  &psAcquireDevInfoOUT->hDevCookie,
+                                                  hDevCookieInt,
+                                                  PVRSRV_HANDLE_TYPE_DEV_NODE,
+                                                  PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVCreateDeviceMemContextBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT *psCreateDevMemContextIN,
+                                                           PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT *psCreateDevMemContextOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemContextInt;
+        IMG_UINT32 i;
+        IMG_BOOL bCreated;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT);
+
+        
+        NEW_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS + 1)
+
+        psCreateDevMemContextOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psCreateDevMemContextIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psCreateDevMemContextOUT->eError =
+                PVRSRVCreateDeviceMemContextKM(hDevCookieInt,
+                                                                           psPerProc,
+                                                                           &hDevMemContextInt,
+                                                                           &psCreateDevMemContextOUT->ui32ClientHeapCount,
+                                                                           &psCreateDevMemContextOUT->sHeapInfo[0],
+                                                                           &bCreated,
+                                                                           pbSharedDeviceMemHeap);
+
+        if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        if(bCreated)
+        {
+                PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                                  &psCreateDevMemContextOUT->hDevMemContext,
+                                                  hDevMemContextInt,
+                                                  PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT,
+                                                  PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+        }
+        else
+        {
+                psCreateDevMemContextOUT->eError =
+                        PVRSRVFindHandle(psPerProc->psHandleBase,
+                                                         &psCreateDevMemContextOUT->hDevMemContext,
+                                                         hDevMemContextInt,
+                                                         PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+                if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        for(i = 0; i < psCreateDevMemContextOUT->ui32ClientHeapCount; i++)
+        {
+                IMG_HANDLE hDevMemHeapExt;
+
+#if defined(PVR_SECURE_HANDLES)
+                if(abSharedDeviceMemHeap[i])
+#endif
+                {
+                        
+                        PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
+                                                          psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
+                                                          PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
+                                                          PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+                }
+#if defined(PVR_SECURE_HANDLES)
+                else
+                {
+                        
+                        if(bCreated)
+                        {
+                                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
+                                                                         psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
+                                                                         PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
+                                                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE,
+                                                                         psCreateDevMemContextOUT->hDevMemContext);
+                        }
+                        else
+                        {
+                                psCreateDevMemContextOUT->eError =
+                                        PVRSRVFindHandle(psPerProc->psHandleBase, &hDevMemHeapExt,
+                                                                         psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
+                                                                         PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
+                                if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
+                                {
+                                        return 0;
+                                }
+                        }
+                }
+#endif
+                psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap = hDevMemHeapExt;
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVDestroyDeviceMemContextBW(IMG_UINT32 ui32BridgeID,
+                                                                PVRSRV_BRIDGE_IN_DESTROY_DEVMEMCONTEXT *psDestroyDevMemContextIN,
+                                                                PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemContextInt;
+        IMG_BOOL bDestroyed;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psDestroyDevMemContextIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+                                                   psDestroyDevMemContextIN->hDevMemContext,
+                                                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVDestroyDeviceMemContextKM(hDevCookieInt, hDevMemContextInt, &bDestroyed);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if(bDestroyed)
+        {
+                psRetOUT->eError =
+                        PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                psDestroyDevMemContextIN->hDevMemContext,
+                                                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+        }
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVGetDeviceMemHeapInfoBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoIN,
+                                                           PVRSRV_BRIDGE_OUT_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemContextInt;
+        IMG_UINT32 i;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS)
+
+        psGetDevMemHeapInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psGetDevMemHeapInfoIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDevMemHeapInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+                                                   psGetDevMemHeapInfoIN->hDevMemContext,
+                                                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+        if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDevMemHeapInfoOUT->eError =
+                PVRSRVGetDeviceMemHeapInfoKM(hDevCookieInt,
+                                                                           hDevMemContextInt,
+                                                                           &psGetDevMemHeapInfoOUT->ui32ClientHeapCount,
+                                                                           &psGetDevMemHeapInfoOUT->sHeapInfo[0],
+                                                                           pbSharedDeviceMemHeap);
+
+        if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        for(i = 0; i < psGetDevMemHeapInfoOUT->ui32ClientHeapCount; i++)
+        {
+                IMG_HANDLE hDevMemHeapExt;
+
+#if defined(PVR_SECURE_HANDLES)
+                if(abSharedDeviceMemHeap[i])
+#endif
+                {
+                        
+                        PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
+                                                          psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
+                                                          PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
+                                                          PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+                }
+#if defined(PVR_SECURE_HANDLES)
+                else
+                {
+                        
+                        psGetDevMemHeapInfoOUT->eError =
+                                PVRSRVFindHandle(psPerProc->psHandleBase, &hDevMemHeapExt,
+                                                                 psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
+                                                                 PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
+                        if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
+                        {
+                                return 0;
+                        }
+                }
+#endif
+                psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap = hDevMemHeapExt;
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc)
+
+        return 0;
+}
+
+
+#if defined(OS_PVRSRV_ALLOC_DEVICE_MEM_BW)
+IMG_INT
+PVRSRVAllocDeviceMemBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psAllocDeviceMemIN,
+                                           PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *psAllocDeviceMemOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc);
+#else
+static IMG_INT
+PVRSRVAllocDeviceMemBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psAllocDeviceMemIN,
+                                           PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *psAllocDeviceMemOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemHeapInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_DEVICEMEM);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc, 2)
+
+        psAllocDeviceMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psAllocDeviceMemIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psAllocDeviceMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemHeapInt,
+                                                   psAllocDeviceMemIN->hDevMemHeap,
+                                                   PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
+
+        if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psAllocDeviceMemOUT->eError =
+                PVRSRVAllocDeviceMemKM(hDevCookieInt,
+                                                           psPerProc,
+                                                           hDevMemHeapInt,
+                                                           psAllocDeviceMemIN->ui32Attribs,
+                                                           psAllocDeviceMemIN->ui32Size,
+                                                           psAllocDeviceMemIN->ui32Alignment,
+                                                           &psMemInfo,
+                                                           "" );
+
+        if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        OSMemSet(&psAllocDeviceMemOUT->sClientMemInfo,
+                         0,
+                         sizeof(psAllocDeviceMemOUT->sClientMemInfo));
+
+        psAllocDeviceMemOUT->sClientMemInfo.pvLinAddrKM =
+                        psMemInfo->pvLinAddrKM;
+
+#if defined (__linux__)
+        psAllocDeviceMemOUT->sClientMemInfo.pvLinAddr = 0;
+#else
+        psAllocDeviceMemOUT->sClientMemInfo.pvLinAddr = psMemInfo->pvLinAddrKM;
+#endif
+        psAllocDeviceMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
+        psAllocDeviceMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
+        psAllocDeviceMemOUT->sClientMemInfo.ui32AllocSize = psMemInfo->ui32AllocSize;
+        psAllocDeviceMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo,
+                                          psMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        if(psAllocDeviceMemIN->ui32Attribs & PVRSRV_MEM_NO_SYNCOBJ)
+        {
+                
+                OSMemSet(&psAllocDeviceMemOUT->sClientSyncInfo,
+                                 0,
+                                 sizeof (PVRSRV_CLIENT_SYNC_INFO));
+                psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo = IMG_NULL;
+        }
+        else
+        {
+                
+
+                psAllocDeviceMemOUT->sClientSyncInfo.psSyncData =
+                        psMemInfo->psKernelSyncInfo->psSyncData;
+                psAllocDeviceMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
+                        psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
+                psAllocDeviceMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
+                        psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
+
+                psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo =
+                        psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
+
+                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                         &psAllocDeviceMemOUT->sClientSyncInfo.hKernelSyncInfo,
+                                                         psMemInfo->psKernelSyncInfo,
+                                                         PVRSRV_HANDLE_TYPE_SYNC_INFO,
+                                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE,
+                                                         psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo);
+
+                psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo =
+                        &psAllocDeviceMemOUT->sClientSyncInfo;
+
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc)
+
+        return 0;
+}
+
+#endif 
+
+static IMG_INT
+PVRSRVFreeDeviceMemBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_FREEDEVICEMEM *psFreeDeviceMemIN,
+                                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_VOID *pvKernelMemInfo;
+
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_DEVICEMEM);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psFreeDeviceMemIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvKernelMemInfo,
+                                                   psFreeDeviceMemIN->psKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVFreeDeviceMemKM(hDevCookieInt, pvKernelMemInfo);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psFreeDeviceMemIN->psKernelMemInfo,
+                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVExportDeviceMemBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_EXPORTDEVICEMEM *psExportDeviceMemIN,
+                                          PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EXPORT_DEVICEMEM);
+
+        
+        psExportDeviceMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psExportDeviceMemIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psExportDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: can't find devcookie"));
+                return 0;
+        }
+
+        
+        psExportDeviceMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_PVOID *)&psKernelMemInfo,
+                                                   psExportDeviceMemIN->psKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        if(psExportDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: can't find kernel meminfo"));
+                return 0;
+        }
+
+        
+        psExportDeviceMemOUT->eError =
+                PVRSRVFindHandle(KERNEL_HANDLE_BASE,
+                                                         &psExportDeviceMemOUT->hMemInfo,
+                                                         psKernelMemInfo,
+                                                         PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psExportDeviceMemOUT->eError == PVRSRV_OK)
+        {
+                
+                PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVExportDeviceMemBW: allocation is already exported"));
+                return 0;
+        }
+
+        
+        psExportDeviceMemOUT->eError = PVRSRVAllocHandle(KERNEL_HANDLE_BASE,
+                                                                                                        &psExportDeviceMemOUT->hMemInfo,
+                                                                                                        psKernelMemInfo,
+                                                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                                                                                        PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+        if (psExportDeviceMemOUT->eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: failed to allocate handle from global handle list"));
+                return 0;
+        }
+
+        
+        psKernelMemInfo->ui32Flags |= PVRSRV_MEM_EXPORTED;
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVMapDeviceMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN,
+                                                         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_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEV_MEMORY);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc, 2)
+
+        
+        psMapDevMemOUT->eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
+                                                                                                (IMG_VOID**)&psSrcKernelMemInfo,
+                                                                                                psMapDevMemIN->hKernelMemInfo,
+                                                                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psMapDevMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        psMapDevMemOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                                                &hDstDevMemHeap,
+                                                                                                psMapDevMemIN->hDstDevMemHeap,
+                                                                                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
+        if(psMapDevMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        psMapDevMemOUT->eError = PVRSRVMapDeviceMemoryKM(psPerProc,
+                                                                                                  psSrcKernelMemInfo,
+                                                                                                  hDstDevMemHeap,
+                                                                                                  &psDstKernelMemInfo);
+        if(psMapDevMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        OSMemSet(&psMapDevMemOUT->sDstClientMemInfo,
+                         0,
+                         sizeof(psMapDevMemOUT->sDstClientMemInfo));
+        OSMemSet(&psMapDevMemOUT->sDstClientSyncInfo,
+                         0,
+                         sizeof(psMapDevMemOUT->sDstClientSyncInfo));
+
+        psMapDevMemOUT->sDstClientMemInfo.pvLinAddrKM =
+                        psDstKernelMemInfo->pvLinAddrKM;
+
+        psMapDevMemOUT->sDstClientMemInfo.pvLinAddr = 0;
+        psMapDevMemOUT->sDstClientMemInfo.sDevVAddr = psDstKernelMemInfo->sDevVAddr;
+        psMapDevMemOUT->sDstClientMemInfo.ui32Flags = psDstKernelMemInfo->ui32Flags;
+        psMapDevMemOUT->sDstClientMemInfo.ui32AllocSize = psDstKernelMemInfo->ui32AllocSize;
+        psMapDevMemOUT->sDstClientMemInfo.hMappingInfo = psDstKernelMemInfo->sMemBlk.hOSMemHandle;
+
+        
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo,
+                                          psDstKernelMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+        psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo = IMG_NULL;
+
+        
+        if(psDstKernelMemInfo->psKernelSyncInfo)
+        {
+                psMapDevMemOUT->sDstClientSyncInfo.psSyncData =
+                        psDstKernelMemInfo->psKernelSyncInfo->psSyncData;
+                psMapDevMemOUT->sDstClientSyncInfo.sWriteOpsCompleteDevVAddr =
+                        psDstKernelMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
+                psMapDevMemOUT->sDstClientSyncInfo.sReadOpsCompleteDevVAddr =
+                        psDstKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
+
+                psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo =
+                        psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
+
+                psMapDevMemOUT->sDstClientMemInfo.psClientSyncInfo = &psMapDevMemOUT->sDstClientSyncInfo;
+                
+                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                          &psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo,
+                                          psDstKernelMemInfo->psKernelSyncInfo,
+                                          PVRSRV_HANDLE_TYPE_SYNC_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                          psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo);
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc)
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVUnmapDeviceMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_UNMAP_DEV_MEMORY *psUnmapDevMemIN,
+                                                         PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo = IMG_NULL;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEV_MEMORY);
+
+        psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                                        (IMG_VOID**)&psKernelMemInfo,
+                                                                                        psUnmapDevMemIN->psKernelMemInfo,
+                                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVUnmapDeviceMemoryKM(psKernelMemInfo);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psUnmapDevMemIN->psKernelMemInfo,
+                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        return 0;
+}
+
+
+
+static IMG_INT
+PVRSRVMapDeviceClassMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_MAP_DEVICECLASS_MEMORY *psMapDevClassMemIN,
+                                                         PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psMapDevClassMemOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+        IMG_HANDLE hOSMapInfo;
+        IMG_HANDLE hDeviceClassBufferInt;
+        IMG_HANDLE hDevMemContextInt;
+        PVRSRV_HANDLE_TYPE eHandleType;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc, 2)
+
+        
+        psMapDevClassMemOUT->eError =
+                PVRSRVLookupHandleAnyType(psPerProc->psHandleBase, &hDeviceClassBufferInt,
+                                                                  &eHandleType,
+                                                                  psMapDevClassMemIN->hDeviceClassBuffer);
+
+        if(psMapDevClassMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        psMapDevClassMemOUT->eError =
+        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+                                   psMapDevClassMemIN->hDevMemContext,
+                                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+        if(psMapDevClassMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        switch(eHandleType)
+        {
+#if defined(PVR_SECURE_HANDLES)
+                case PVRSRV_HANDLE_TYPE_DISP_BUFFER:
+                case PVRSRV_HANDLE_TYPE_BUF_BUFFER:
+#else
+                case PVRSRV_HANDLE_TYPE_NONE:
+#endif
+                        break;
+                default:
+                        psMapDevClassMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
+                        return 0;
+        }
+
+        psMapDevClassMemOUT->eError =
+                PVRSRVMapDeviceClassMemoryKM(psPerProc,
+                                                                         hDevMemContextInt,
+                                                                         hDeviceClassBufferInt,
+                                                                         &psMemInfo,
+                                                                         &hOSMapInfo);
+        if(psMapDevClassMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        OSMemSet(&psMapDevClassMemOUT->sClientMemInfo,
+                         0,
+                         sizeof(psMapDevClassMemOUT->sClientMemInfo));
+        OSMemSet(&psMapDevClassMemOUT->sClientSyncInfo,
+                         0,
+                         sizeof(psMapDevClassMemOUT->sClientSyncInfo));
+
+        psMapDevClassMemOUT->sClientMemInfo.pvLinAddrKM =
+                        psMemInfo->pvLinAddrKM;
+
+        psMapDevClassMemOUT->sClientMemInfo.pvLinAddr = 0;
+        psMapDevClassMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
+        psMapDevClassMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
+        psMapDevClassMemOUT->sClientMemInfo.ui32AllocSize = psMemInfo->ui32AllocSize;
+        psMapDevClassMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
+
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                          &psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo,
+                                          psMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE,
+                                          psMapDevClassMemIN->hDeviceClassBuffer);
+
+        psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo = IMG_NULL;
+
+        
+        if(psMemInfo->psKernelSyncInfo)
+        {
+                psMapDevClassMemOUT->sClientSyncInfo.psSyncData =
+                        psMemInfo->psKernelSyncInfo->psSyncData;
+                psMapDevClassMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
+                        psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
+                psMapDevClassMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
+                        psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
+
+                psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo =
+                        psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
+
+                psMapDevClassMemOUT->sClientMemInfo.psClientSyncInfo = &psMapDevClassMemOUT->sClientSyncInfo;
+                
+                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                  &psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo,
+                                                  psMemInfo->psKernelSyncInfo,
+                                                  PVRSRV_HANDLE_TYPE_SYNC_INFO,
+                                                  PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                                  psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo);
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVUnmapDeviceClassMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_UNMAP_DEVICECLASS_MEMORY *psUnmapDevClassMemIN,
+                                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvKernelMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvKernelMemInfo,
+                                                   psUnmapDevClassMemIN->psKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVUnmapDeviceClassMemoryKM(pvKernelMemInfo);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psUnmapDevClassMemIN->psKernelMemInfo,
+                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        return 0;
+}
+
+
+#if defined(OS_PVRSRV_WRAP_EXT_MEM_BW)
+IMG_INT
+PVRSRVWrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY *psWrapExtMemIN,
+                                          PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY *psWrapExtMemOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc);
+#else 
+static IMG_INT
+PVRSRVWrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY *psWrapExtMemIN,
+                                          PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY *psWrapExtMemOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemContextInt;
+        PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+        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)
+
+        
+        psWrapExtMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psWrapExtMemIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psWrapExtMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        psWrapExtMemOUT->eError =
+        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+                                   psWrapExtMemIN->hDevMemContext,
+                                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+        if(psWrapExtMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if(psWrapExtMemIN->ui32NumPageTableEntries)
+        {
+                ui32PageTableSize = psWrapExtMemIN->ui32NumPageTableEntries
+                                                * sizeof(IMG_SYS_PHYADDR);
+
+                ASSIGN_AND_EXIT_ON_ERROR(psWrapExtMemOUT->eError,
+                                  OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32PageTableSize,
+                                  (IMG_VOID **)&psSysPAddr, 0,
+                                  "Page Table"));
+
+                if(CopyFromUserWrapper(psPerProc,
+                                                           ui32BridgeID,
+                                                           psSysPAddr,
+                                                           psWrapExtMemIN->psSysPAddr,
+                                                           ui32PageTableSize) != PVRSRV_OK)
+                {
+                        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,      ui32PageTableSize, (IMG_VOID *)psSysPAddr, 0);
+                        
+                        return -EFAULT;
+                }
+        }
+                
+        psWrapExtMemOUT->eError =
+                PVRSRVWrapExtMemoryKM(hDevCookieInt,
+                                                          psPerProc,
+                                                          hDevMemContextInt,
+                                                          psWrapExtMemIN->ui32ByteSize,
+                                                          psWrapExtMemIN->ui32PageOffset,
+                                                          psWrapExtMemIN->bPhysContig,
+                                                          psSysPAddr,
+                                                          psWrapExtMemIN->pvLinAddr,
+                                                          psWrapExtMemIN->ui32Flags,
+                                                          &psMemInfo);
+
+        if(psWrapExtMemIN->ui32NumPageTableEntries)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          ui32PageTableSize,
+                          (IMG_VOID *)psSysPAddr, 0);
+                
+        }
+        
+        if(psWrapExtMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psWrapExtMemOUT->sClientMemInfo.pvLinAddrKM =
+                        psMemInfo->pvLinAddrKM;
+
+        
+        psWrapExtMemOUT->sClientMemInfo.pvLinAddr = 0;
+        psWrapExtMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
+        psWrapExtMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
+        psWrapExtMemOUT->sClientMemInfo.ui32AllocSize = psMemInfo->ui32AllocSize;
+        psWrapExtMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo,
+                                          psMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        
+        psWrapExtMemOUT->sClientSyncInfo.psSyncData =
+                psMemInfo->psKernelSyncInfo->psSyncData;
+        psWrapExtMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
+                psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
+        psWrapExtMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
+                psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
+
+        psWrapExtMemOUT->sClientSyncInfo.hMappingInfo =
+                psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
+
+        psWrapExtMemOUT->sClientMemInfo.psClientSyncInfo = &psWrapExtMemOUT->sClientSyncInfo;
+
+        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)
+
+        return 0;
+}
+#endif 
+
+static IMG_INT
+PVRSRVUnwrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                PVRSRV_BRIDGE_IN_UNWRAP_EXT_MEMORY *psUnwrapExtMemIN,
+                                                PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvMemInfo,
+                                                   psUnwrapExtMemIN->hKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVUnwrapExtMemoryKM((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                   psUnwrapExtMemIN->hKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetFreeDeviceMemBW(IMG_UINT32 ui32BridgeID,
+                                                 PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM *psGetFreeDeviceMemIN,
+                                                 PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM *psGetFreeDeviceMemOUT,
+                                                 PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETFREE_DEVICEMEM);
+
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psGetFreeDeviceMemOUT->eError =
+                PVRSRVGetFreeDeviceMemKM(psGetFreeDeviceMemIN->ui32Flags,
+                                                                 &psGetFreeDeviceMemOUT->ui32Total,
+                                                                 &psGetFreeDeviceMemOUT->ui32Free,
+                                                                 &psGetFreeDeviceMemOUT->ui32LargestBlock);
+
+        return 0;
+}
+
+static IMG_INT
+PVRMMapOSMemHandleToMMapDataBW(IMG_UINT32 ui32BridgeID,
+                                                                  PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA *psMMapDataIN,
+                                                                  PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA *psMMapDataOUT,
+                                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA);
+
+#if defined (__linux__)
+        psMMapDataOUT->eError =
+                PVRMMapOSMemHandleToMMapData(psPerProc,
+                                                                                psMMapDataIN->hMHandle,
+                                                                                &psMMapDataOUT->ui32MMapOffset,
+                                                                                &psMMapDataOUT->ui32ByteOffset,
+                                                                                &psMMapDataOUT->ui32RealByteSize,
+                                                                                &psMMapDataOUT->ui32UserVAddr);
+#else   
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
+
+        psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
+#endif  
+        return 0;
+}
+
+
+static IMG_INT
+PVRMMapReleaseMMapDataBW(IMG_UINT32 ui32BridgeID,
+                                                                  PVRSRV_BRIDGE_IN_RELEASE_MMAP_DATA *psMMapDataIN,
+                                                                  PVRSRV_BRIDGE_OUT_RELEASE_MMAP_DATA *psMMapDataOUT,
+                                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RELEASE_MMAP_DATA);
+
+#if defined (__linux__)
+        psMMapDataOUT->eError =
+                PVRMMapReleaseMMapData(psPerProc,
+                                                                                psMMapDataIN->hMHandle,
+                                                                                &psMMapDataOUT->bMUnmap,
+                                                                                &psMMapDataOUT->ui32RealByteSize,
+                                                                                &psMMapDataOUT->ui32UserVAddr);
+#else
+        
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
+
+        psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
+#endif  
+        return 0;
+}
+
+
+#ifdef PDUMP
+static IMG_INT
+PDumpIsCaptureFrameBW(IMG_UINT32 ui32BridgeID,
+                                          IMG_VOID *psBridgeIn,
+                                          PVRSRV_BRIDGE_OUT_PDUMP_ISCAPTURING *psPDumpIsCapturingOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_ISCAPTURING);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psPDumpIsCapturingOUT->bIsCapturing = PDumpIsCaptureFrameKM();
+        psPDumpIsCapturingOUT->eError = PVRSRV_OK;
+
+        return 0;
+}
+
+static IMG_INT
+PDumpCommentBW(IMG_UINT32 ui32BridgeID,
+                           PVRSRV_BRIDGE_IN_PDUMP_COMMENT *psPDumpCommentIN,
+                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_COMMENT);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psRetOUT->eError = PDumpCommentKM(&psPDumpCommentIN->szComment[0],
+                                                                          psPDumpCommentIN->ui32Flags);
+        return 0;
+}
+
+static IMG_INT
+PDumpSetFrameBW(IMG_UINT32 ui32BridgeID,
+                                PVRSRV_BRIDGE_IN_PDUMP_SETFRAME *psPDumpSetFrameIN,
+                                PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SETFRAME);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psRetOUT->eError = PDumpSetFrameKM(psPDumpSetFrameIN->ui32Frame);
+
+        return 0;
+}
+
+static IMG_INT
+PDumpRegWithFlagsBW(IMG_UINT32 ui32BridgeID,
+                                        PVRSRV_BRIDGE_IN_PDUMP_DUMPREG *psPDumpRegDumpIN,
+                                        PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REG);
+
+        psRetOUT->eError =
+                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;
+}
+
+static IMG_INT
+PDumpRegPolBW(IMG_UINT32 ui32BridgeID,
+                          PVRSRV_BRIDGE_IN_PDUMP_REGPOL *psPDumpRegPolIN,
+                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REGPOL);
+
+        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->szRegRegion,
+                                                           psPDumpRegPolIN->sHWReg.ui32RegAddr, 
+                                                           psPDumpRegPolIN->sHWReg.ui32RegVal,
+                                                           psPDumpRegPolIN->ui32Mask,
+                                                           psPDumpRegPolIN->ui32Flags);
+
+        return 0;
+}
+
+static IMG_INT
+PDumpMemPolBW(IMG_UINT32 ui32BridgeID,
+                          PVRSRV_BRIDGE_IN_PDUMP_MEMPOL *psPDumpMemPolIN,
+                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_MEMPOL);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvMemInfo,
+                                                   psPDumpMemPolIN->psKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PDumpMemPolKM(((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo),
+                                          psPDumpMemPolIN->ui32Offset,
+                                          psPDumpMemPolIN->ui32Value,
+                                          psPDumpMemPolIN->ui32Mask,
+                                          psPDumpMemPolIN->eOperator,
+                                          psPDumpMemPolIN->ui32Flags,
+                                          MAKEUNIQUETAG(pvMemInfo));
+
+        return 0;
+}
+
+static IMG_INT
+PDumpMemBW(IMG_UINT32 ui32BridgeID,
+                   PVRSRV_BRIDGE_IN_PDUMP_DUMPMEM *psPDumpMemDumpIN,
+                   PVRSRV_BRIDGE_RETURN *psRetOUT,
+                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPMEM);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvMemInfo,
+                                                   psPDumpMemDumpIN->psKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PDumpMemUM(psPerProc,
+                                   psPDumpMemDumpIN->pvAltLinAddr,
+                                   psPDumpMemDumpIN->pvLinAddr,
+                                   pvMemInfo,
+                                   psPDumpMemDumpIN->ui32Offset,
+                                   psPDumpMemDumpIN->ui32Bytes,
+                                   psPDumpMemDumpIN->ui32Flags,
+                                   MAKEUNIQUETAG(pvMemInfo));
+
+        return 0;
+}
+
+static IMG_INT
+PDumpBitmapBW(IMG_UINT32 ui32BridgeID,
+                          PVRSRV_BRIDGE_IN_PDUMP_BITMAP *psPDumpBitmapIN,
+                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_HANDLE hDevMemContextInt;
+        
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+
+        psRetOUT->eError =
+                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,
+                                          psPDumpBitmapIN->ui32Flags);
+
+        return 0;
+}
+
+static IMG_INT
+PDumpReadRegBW(IMG_UINT32 ui32BridgeID,
+                           PVRSRV_BRIDGE_IN_PDUMP_READREG *psPDumpReadRegIN,
+                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPREADREG);
+
+        psRetOUT->eError =
+                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,
+                                           psPDumpReadRegIN->ui32Flags);
+
+        return 0;
+}
+
+static IMG_INT
+PDumpDriverInfoBW(IMG_UINT32 ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_PDUMP_DRIVERINFO *psPDumpDriverInfoIN,
+                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 ui32PDumpFlags;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DRIVERINFO);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        ui32PDumpFlags = 0;
+        if(psPDumpDriverInfoIN->bContinuous)
+        {
+                ui32PDumpFlags |= PDUMP_FLAGS_CONTINUOUS;
+        }
+        psRetOUT->eError =
+                PDumpDriverInfoKM(&psPDumpDriverInfoIN->szString[0],
+                                                  ui32PDumpFlags);
+
+        return 0;
+}
+
+static IMG_INT
+PDumpSyncDumpBW(IMG_UINT32 ui32BridgeID,
+                                PVRSRV_BRIDGE_IN_PDUMP_DUMPSYNC *psPDumpSyncDumpIN,
+                                PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 ui32Bytes = psPDumpSyncDumpIN->ui32Bytes;
+        IMG_VOID *pvSyncInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPSYNC);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
+                                                   psPDumpSyncDumpIN->psKernelSyncInfo,
+                                                   PVRSRV_HANDLE_TYPE_SYNC_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PDumpMemUM(psPerProc,
+                                   psPDumpSyncDumpIN->pvAltLinAddr,
+                                   IMG_NULL,
+                                   ((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM,
+                                   psPDumpSyncDumpIN->ui32Offset,
+                                   ui32Bytes,
+                                   0,
+                                   MAKEUNIQUETAG(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM));
+
+        return 0;
+}
+
+static IMG_INT
+PDumpSyncPolBW(IMG_UINT32 ui32BridgeID,
+                           PVRSRV_BRIDGE_IN_PDUMP_SYNCPOL *psPDumpSyncPolIN,
+                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 ui32Offset;
+        IMG_VOID *pvSyncInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SYNCPOL);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
+                                                   psPDumpSyncPolIN->psKernelSyncInfo,
+                                                   PVRSRV_HANDLE_TYPE_SYNC_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if(psPDumpSyncPolIN->bIsRead)
+        {
+                ui32Offset = offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete);
+        }
+        else
+        {
+                ui32Offset = offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete);
+        }
+
+        psRetOUT->eError =
+                PDumpMemPolKM(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM,
+                                          ui32Offset,
+                                          psPDumpSyncPolIN->ui32Value,
+                                          psPDumpSyncPolIN->ui32Mask,
+                                          PDUMP_POLL_OPERATOR_EQUAL,
+                                          0,
+                                          MAKEUNIQUETAG(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM));
+
+        return 0;
+}
+
+
+static IMG_INT
+PDumpCycleCountRegReadBW(IMG_UINT32 ui32BridgeID,
+                                                 PVRSRV_BRIDGE_IN_PDUMP_CYCLE_COUNT_REG_READ *psPDumpCycleCountRegReadIN,
+                                                 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);
+
+        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;
+
+        return 0;
+}
+
+static IMG_INT
+PDumpPDDevPAddrBW(IMG_UINT32 ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_PDUMP_DUMPPDDEVPADDR *psPDumpPDDevPAddrIN,
+                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvMemInfo,
+                                                   psPDumpPDDevPAddrIN->hKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PDumpPDDevPAddrKM((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo,
+                                                  psPDumpPDDevPAddrIN->ui32Offset,
+                                                  psPDumpPDDevPAddrIN->sPDDevPAddr,
+                                                  MAKEUNIQUETAG(pvMemInfo),
+                                                  PDUMP_PD_UNIQUETAG);
+        return 0;
+}
+
+static IMG_INT
+PDumpStartInitPhaseBW(IMG_UINT32 ui32BridgeID,
+                                          IMG_VOID *psBridgeIn,
+                                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_STARTINITPHASE);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psRetOUT->eError = PDumpStartInitPhaseKM();
+
+        return 0;
+}
+
+static IMG_INT
+PDumpStopInitPhaseBW(IMG_UINT32 ui32BridgeID,
+                                          IMG_VOID *psBridgeIn,
+                                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_STOPINITPHASE);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        psRetOUT->eError = PDumpStopInitPhaseKM();
+
+        return 0;
+}
+
+#endif 
+
+
+static IMG_INT
+PVRSRVGetMiscInfoBW(IMG_UINT32 ui32BridgeID,
+                                        PVRSRV_BRIDGE_IN_GET_MISC_INFO *psGetMiscInfoIN,
+                                        PVRSRV_BRIDGE_OUT_GET_MISC_INFO *psGetMiscInfoOUT,
+                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_ERROR eError;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_MISC_INFO);
+
+        OSMemCopy(&psGetMiscInfoOUT->sMiscInfo,
+                  &psGetMiscInfoIN->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_FREEMEM_PRESENT) != 0))
+        {
+                
+                psGetMiscInfoOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+
+        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_FREEMEM_PRESENT) != 0))
+        {
+                
+                ASSIGN_AND_EXIT_ON_ERROR(psGetMiscInfoOUT->eError,
+                                    OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                    psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
+                                    (IMG_VOID **)&psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0,
+                                                        "Output string buffer"));
+
+                psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
+
+                
+                eError = CopyToUserWrapper(psPerProc, ui32BridgeID,
+                                           psGetMiscInfoIN->sMiscInfo.pszMemoryStr,
+                                           psGetMiscInfoOUT->sMiscInfo.pszMemoryStr,
+                                           psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen);
+
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
+                         (IMG_VOID *)psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0);
+                psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = IMG_NULL;
+
+                
+                psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
+
+                if(eError != PVRSRV_OK)
+                {
+                        
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetMiscInfoBW Error copy to user"));
+                        return -EFAULT;
+                }
+        }
+        else
+        {
+                psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
+        }
+
+        
+        if (psGetMiscInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        if (psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT)
+        {
+                psGetMiscInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
+                                                                                                        &psGetMiscInfoOUT->sMiscInfo.sGlobalEventObject.hOSEventKM,
+                                                                                                        psGetMiscInfoOUT->sMiscInfo.sGlobalEventObject.hOSEventKM,
+                                                                                                        PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT,
+                                                                                                        PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+
+                        if (psGetMiscInfoOUT->eError != PVRSRV_OK)
+                        {
+                                return 0;
+                        }
+        }
+
+        if (psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle)
+        {
+                
+                psGetMiscInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
+                                                  &psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle,
+                                                  psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle,
+                                                  PVRSRV_HANDLE_TYPE_SOC_TIMER,
+                                                  PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+
+                if (psGetMiscInfoOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVConnectBW(IMG_UINT32 ui32BridgeID,
+                                PVRSRV_BRIDGE_IN_CONNECT_SERVICES *psConnectServicesIN,
+                                PVRSRV_BRIDGE_OUT_CONNECT_SERVICES *psConnectServicesOUT,
+                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CONNECT_SERVICES);
+
+#if defined(PDUMP)
+        
+        psPerProc->bPDumpPersistent |= ( (psConnectServicesIN->ui32Flags & SRV_FLAGS_PERSIST) != 0) ? IMG_TRUE : IMG_FALSE;
+#else
+        PVR_UNREFERENCED_PARAMETER(psConnectServicesIN);
+#endif
+        psConnectServicesOUT->hKernelServices = psPerProc->hPerProcData;
+        psConnectServicesOUT->eError = PVRSRV_OK;
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVDisconnectBW(IMG_UINT32 ui32BridgeID,
+                                   IMG_VOID *psBridgeIn,
+                                   PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DISCONNECT_SERVICES);
+
+        
+        psRetOUT->eError = PVRSRV_OK;
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVEnumerateDCBW(IMG_UINT32 ui32BridgeID,
+                                        PVRSRV_BRIDGE_IN_ENUMCLASS *psEnumDispClassIN,
+                                        PVRSRV_BRIDGE_OUT_ENUMCLASS *psEnumDispClassOUT,
+                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_CLASS);
+
+        psEnumDispClassOUT->eError =
+                PVRSRVEnumerateDCKM(psEnumDispClassIN->sDeviceClass,
+                                                        &psEnumDispClassOUT->ui32NumDevices,
+                                                        &psEnumDispClassOUT->ui32DevID[0]);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVOpenDCDeviceBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceIN,
+                                         PVRSRV_BRIDGE_OUT_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDispClassInfoInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc, 1)
+
+        psOpenDispClassDeviceOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psOpenDispClassDeviceIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psOpenDispClassDeviceOUT->eError =
+                PVRSRVOpenDCDeviceKM(psPerProc,
+                                                         psOpenDispClassDeviceIN->ui32DeviceID,
+                                                         hDevCookieInt,
+                                                         &hDispClassInfoInt);
+
+        if(psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psOpenDispClassDeviceOUT->hDeviceKM,
+                                          hDispClassInfoInt,
+                                          PVRSRV_HANDLE_TYPE_DISP_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+        COMMIT_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVCloseDCDeviceBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_CLOSE_DISPCLASS_DEVICE *psCloseDispClassDeviceIN,
+                                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfoInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfoInt,
+                                                   psCloseDispClassDeviceIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVCloseDCDeviceKM(pvDispClassInfoInt, IMG_FALSE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psCloseDispClassDeviceIN->hDeviceKM,
+                                                        PVRSRV_HANDLE_TYPE_DISP_INFO);
+        return 0;
+}
+
+static IMG_INT
+PVRSRVEnumDCFormatsBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsIN,
+                                          PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfoInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS);
+
+        psEnumDispClassFormatsOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfoInt,
+                                                   psEnumDispClassFormatsIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psEnumDispClassFormatsOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psEnumDispClassFormatsOUT->eError =
+                PVRSRVEnumDCFormatsKM(pvDispClassInfoInt,
+                                                          &psEnumDispClassFormatsOUT->ui32Count,
+                                                          psEnumDispClassFormatsOUT->asFormat);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVEnumDCDimsBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsIN,
+                                   PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsOUT,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfoInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS);
+
+        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->ui32Count,
+                                                   psEnumDispClassDimsOUT->asDim);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetDCSystemBufferBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferIN,  
+                                                  PVRSRV_BRIDGE_OUT_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hBufferInt;
+        IMG_VOID *pvDispClassInfoInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc, 1)
+
+        psGetDispClassSysBufferOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfoInt,
+                                                   psGetDispClassSysBufferIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDispClassSysBufferOUT->eError =
+                PVRSRVGetDCSystemBufferKM(pvDispClassInfoInt,
+                                                                  &hBufferInt);
+
+        if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+         
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                 &psGetDispClassSysBufferOUT->hBuffer,
+                                                 hBufferInt,
+                                                 PVRSRV_HANDLE_TYPE_DISP_BUFFER,
+                                                 (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
+                                                 psGetDispClassSysBufferIN->hDeviceKM);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetDCInfoBW(IMG_UINT32 ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_GET_DISPCLASS_INFO *psGetDispClassInfoIN,
+                                  PVRSRV_BRIDGE_OUT_GET_DISPCLASS_INFO *psGetDispClassInfoOUT,
+                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_INFO);
+
+        psGetDispClassInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psGetDispClassInfoIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psGetDispClassInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDispClassInfoOUT->eError =
+                PVRSRVGetDCInfoKM(pvDispClassInfo,
+                                                  &psGetDispClassInfoOUT->sDisplayInfo);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVCreateDCSwapChainBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_CREATE_DISPCLASS_SWAPCHAIN *psCreateDispClassSwapChainIN,
+                                                  PVRSRV_BRIDGE_OUT_CREATE_DISPCLASS_SWAPCHAIN *psCreateDispClassSwapChainOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        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)
+
+        psCreateDispClassSwapChainOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psCreateDispClassSwapChainIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+
+        if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        ui32SwapChainID = psCreateDispClassSwapChainIN->ui32SwapChainID;
+
+        psCreateDispClassSwapChainOUT->eError =
+                PVRSRVCreateDCSwapChainKM(psPerProc, pvDispClassInfo,
+                                                                  psCreateDispClassSwapChainIN->ui32Flags,
+                                                                  &psCreateDispClassSwapChainIN->sDstSurfAttrib,
+                                                                  &psCreateDispClassSwapChainIN->sSrcSurfAttrib,
+                                                                  psCreateDispClassSwapChainIN->ui32BufferCount,
+                                                                  psCreateDispClassSwapChainIN->ui32OEMFlags,
+                                                                  &hSwapChainInt,
+                                                                  &ui32SwapChainID);
+
+        if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        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)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVDestroyDCSwapChainBW(IMG_UINT32 ui32BridgeID,
+                                                   PVRSRV_BRIDGE_IN_DESTROY_DISPCLASS_SWAPCHAIN *psDestroyDispClassSwapChainIN,
+                                                   PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSwapChain,
+                                                   psDestroyDispClassSwapChainIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVDestroyDCSwapChainKM(pvSwapChain);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psDestroyDispClassSwapChainIN->hSwapChain,
+                                                        PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSetDCDstRectBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassDstRectIN,
+                                         PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSetDispClassDstRectIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psSetDispClassDstRectIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVSetDCDstRectKM(pvDispClassInfo,
+                                                         pvSwapChain,
+                                                         &psSetDispClassDstRectIN->sRect);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSetDCSrcRectBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassSrcRectIN,
+                                         PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSetDispClassSrcRectIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psSetDispClassSrcRectIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVSetDCSrcRectKM(pvDispClassInfo,
+                                                         pvSwapChain,
+                                                         &psSetDispClassSrcRectIN->sRect);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSetDCDstColourKeyBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSetDispClassColKeyIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psSetDispClassColKeyIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVSetDCDstColourKeyKM(pvDispClassInfo,
+                                                                  pvSwapChain,
+                                                                  psSetDispClassColKeyIN->ui32CKColour);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSetDCSrcColourKeyBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSetDispClassColKeyIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psSetDispClassColKeyIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVSetDCSrcColourKeyKM(pvDispClassInfo,
+                                                                  pvSwapChain,
+                                                                  psSetDispClassColKeyIN->ui32CKColour);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetDCBuffersBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersIN,
+                                         PVRSRV_BRIDGE_OUT_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+        IMG_UINT32 i;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc, PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS)
+
+        psGetDispClassBuffersOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psGetDispClassBuffersIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psGetDispClassBuffersOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDispClassBuffersOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psGetDispClassBuffersIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
+        if(psGetDispClassBuffersOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetDispClassBuffersOUT->eError =
+                PVRSRVGetDCBuffersKM(pvDispClassInfo,
+                                                         pvSwapChain,
+                                                         &psGetDispClassBuffersOUT->ui32BufferCount,
+                                                         psGetDispClassBuffersOUT->ahBuffer);
+        if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        PVR_ASSERT(psGetDispClassBuffersOUT->ui32BufferCount <= PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
+
+        for(i = 0; i < psGetDispClassBuffersOUT->ui32BufferCount; i++)
+        {
+                IMG_HANDLE hBufferExt;
+
+                 
+                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                         &hBufferExt,
+                                                         psGetDispClassBuffersOUT->ahBuffer[i],
+                                                         PVRSRV_HANDLE_TYPE_DISP_BUFFER,
+                                                         (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
+                                                         psGetDispClassBuffersIN->hSwapChain);
+
+                psGetDispClassBuffersOUT->ahBuffer[i] = hBufferExt;
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSwapToDCBufferBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_BUFFER *psSwapDispClassBufferIN,
+                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChainBuf;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSwapDispClassBufferIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupSubHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChainBuf,
+                                                   psSwapDispClassBufferIN->hBuffer,
+                                                   PVRSRV_HANDLE_TYPE_DISP_BUFFER,
+                                                   psSwapDispClassBufferIN->hDeviceKM);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVSwapToDCBufferKM(pvDispClassInfo,
+                                                           pvSwapChainBuf,
+                                                           psSwapDispClassBufferIN->ui32SwapInterval,
+                                                           psSwapDispClassBufferIN->hPrivateTag,
+                                                           psSwapDispClassBufferIN->ui32ClipRectCount,
+                                                           psSwapDispClassBufferIN->sClipRect);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVSwapToDCSystemBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_SYSTEM *psSwapDispClassSystemIN,
+                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvDispClassInfo;
+        IMG_VOID *pvSwapChain;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvDispClassInfo,
+                                                   psSwapDispClassSystemIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_DISP_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupSubHandle(psPerProc->psHandleBase,
+                                                   &pvSwapChain,
+                                                   psSwapDispClassSystemIN->hSwapChain,
+                                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
+                                                   psSwapDispClassSystemIN->hDeviceKM);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+        psRetOUT->eError =
+                PVRSRVSwapToDCSystemKM(pvDispClassInfo,
+                                                           pvSwapChain);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVOpenBCDeviceBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceIN,
+                                         PVRSRV_BRIDGE_OUT_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hBufClassInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc, 1)
+
+        psOpenBufferClassDeviceOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psOpenBufferClassDeviceIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psOpenBufferClassDeviceOUT->eError =
+                PVRSRVOpenBCDeviceKM(psPerProc,
+                                                         psOpenBufferClassDeviceIN->ui32DeviceID,
+                                                         hDevCookieInt,
+                                                         &hBufClassInfo);
+        if(psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psOpenBufferClassDeviceOUT->hDeviceKM,
+                                          hBufClassInfo,
+                                          PVRSRV_HANDLE_TYPE_BUF_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVCloseBCDeviceBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_CLOSE_BUFFERCLASS_DEVICE *psCloseBufferClassDeviceIN,
+                                          PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvBufClassInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvBufClassInfo,
+                                                   psCloseBufferClassDeviceIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_BUF_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVCloseBCDeviceKM(pvBufClassInfo, IMG_FALSE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                                   psCloseBufferClassDeviceIN->hDeviceKM,
+                                                                                   PVRSRV_HANDLE_TYPE_BUF_INFO);
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetBCInfoBW(IMG_UINT32 ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_INFO *psGetBufferClassInfoIN,
+                                  PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_INFO *psGetBufferClassInfoOUT,
+                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvBufClassInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO);
+
+        psGetBufferClassInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvBufClassInfo,
+                                                   psGetBufferClassInfoIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_BUF_INFO);
+        if(psGetBufferClassInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetBufferClassInfoOUT->eError =
+                PVRSRVGetBCInfoKM(pvBufClassInfo,
+                                                  &psGetBufferClassInfoOUT->sBufferInfo);
+        return 0;
+}
+
+static IMG_INT
+PVRSRVGetBCBufferBW(IMG_UINT32 ui32BridgeID,
+                                        PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferIN,
+                                        PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferOUT,
+                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_VOID *pvBufClassInfo;
+        IMG_HANDLE hBufferInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc, 1)
+
+        psGetBufferClassBufferOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &pvBufClassInfo,
+                                                   psGetBufferClassBufferIN->hDeviceKM,
+                                                   PVRSRV_HANDLE_TYPE_BUF_INFO);
+        if(psGetBufferClassBufferOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetBufferClassBufferOUT->eError =
+                PVRSRVGetBCBufferKM(pvBufClassInfo,
+                                                        psGetBufferClassBufferIN->ui32BufferIndex,
+                                                        &hBufferInt);
+
+        if(psGetBufferClassBufferOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+         
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                 &psGetBufferClassBufferOUT->hBuffer,
+                                                 hBufferInt,
+                                                 PVRSRV_HANDLE_TYPE_BUF_BUFFER,
+                                                 (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE |  PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
+                                                 psGetBufferClassBufferIN->hDeviceKM);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc)
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVAllocSharedSysMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemIN,
+                                                         PVRSRV_BRIDGE_OUT_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc, 1)
+
+        psAllocSharedSysMemOUT->eError =
+                PVRSRVAllocSharedSysMemoryKM(psPerProc,
+                                                                         psAllocSharedSysMemIN->ui32Flags,
+                                                                         psAllocSharedSysMemIN->ui32Size,
+                                                                         &psKernelMemInfo);
+        if(psAllocSharedSysMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        OSMemSet(&psAllocSharedSysMemOUT->sClientMemInfo,
+                         0,
+                         sizeof(psAllocSharedSysMemOUT->sClientMemInfo));
+
+        psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddrKM =
+                        psKernelMemInfo->pvLinAddrKM;
+
+        psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddr = 0;
+        psAllocSharedSysMemOUT->sClientMemInfo.ui32Flags =
+                psKernelMemInfo->ui32Flags;
+        psAllocSharedSysMemOUT->sClientMemInfo.ui32AllocSize =
+                psKernelMemInfo->ui32AllocSize;
+        psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psAllocSharedSysMemOUT->sClientMemInfo.hKernelMemInfo,
+                                          psKernelMemInfo,
+                                          PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc)
+
+        return 0;
+}
+
+static IMG_INT
+PVRSRVFreeSharedSysMemoryBW(IMG_UINT32 ui32BridgeID,
+                                                        PVRSRV_BRIDGE_IN_FREE_SHARED_SYS_MEM *psFreeSharedSysMemIN,
+                                                        PVRSRV_BRIDGE_OUT_FREE_SHARED_SYS_MEM *psFreeSharedSysMemOUT,
+                                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM);
+
+        psFreeSharedSysMemOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   (IMG_VOID **)&psKernelMemInfo,
+                                                   psFreeSharedSysMemIN->psKernelMemInfo,
+                                                                                                                                   PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+
+        if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
+                return 0;
+
+        psFreeSharedSysMemOUT->eError =
+                PVRSRVFreeSharedSysMemoryKM(psKernelMemInfo);
+        if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
+                return 0;
+
+        psFreeSharedSysMemOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psFreeSharedSysMemIN->psKernelMemInfo,
+                                                        PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+        return 0;
+}
+
+static IMG_INT
+PVRSRVMapMemInfoMemBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_MAP_MEMINFO_MEM *psMapMemInfoMemIN,
+                                          PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM *psMapMemInfoMemOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+        PVRSRV_HANDLE_TYPE eHandleType;
+        IMG_HANDLE      hParent;
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_MEMINFO_MEM);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc, 2)
+
+        psMapMemInfoMemOUT->eError =
+                PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
+                                                   (IMG_VOID **)&psKernelMemInfo,
+                                                   &eHandleType,
+                                                   psMapMemInfoMemIN->hKernelMemInfo);
+        if(psMapMemInfoMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        switch (eHandleType)
+        {
+#if defined(PVR_SECURE_HANDLES)
+                case PVRSRV_HANDLE_TYPE_MEM_INFO:
+                case PVRSRV_HANDLE_TYPE_MEM_INFO_REF:
+                case PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO:
+#else
+                case PVRSRV_HANDLE_TYPE_NONE:
+#endif
+                        break;
+                default:
+                        psMapMemInfoMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
+                        return 0;
+        }
+
+        
+        psMapMemInfoMemOUT->eError =
+                PVRSRVGetParentHandle(psPerProc->psHandleBase,
+                                        &hParent,
+                                        psMapMemInfoMemIN->hKernelMemInfo,
+                                        eHandleType);
+        if (psMapMemInfoMemOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+        if (hParent == IMG_NULL)
+        {
+                hParent = psMapMemInfoMemIN->hKernelMemInfo;
+        }
+
+        OSMemSet(&psMapMemInfoMemOUT->sClientMemInfo,
+                         0,
+                         sizeof(psMapMemInfoMemOUT->sClientMemInfo));
+
+        psMapMemInfoMemOUT->sClientMemInfo.pvLinAddrKM =
+                        psKernelMemInfo->pvLinAddrKM;
+
+        psMapMemInfoMemOUT->sClientMemInfo.pvLinAddr = 0;
+        psMapMemInfoMemOUT->sClientMemInfo.sDevVAddr =
+                psKernelMemInfo->sDevVAddr;
+        psMapMemInfoMemOUT->sClientMemInfo.ui32Flags =
+                psKernelMemInfo->ui32Flags;
+        psMapMemInfoMemOUT->sClientMemInfo.ui32AllocSize =
+                psKernelMemInfo->ui32AllocSize;
+        psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
+
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                          &psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo,
+                                          psKernelMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                          hParent);
+
+        if(psKernelMemInfo->ui32Flags & PVRSRV_MEM_NO_SYNCOBJ)
+        {
+                
+                OSMemSet(&psMapMemInfoMemOUT->sClientSyncInfo,
+                                 0,
+                                 sizeof (PVRSRV_CLIENT_SYNC_INFO));
+        }
+        else
+        {
+                
+                psMapMemInfoMemOUT->sClientSyncInfo.psSyncData =
+                        psKernelMemInfo->psKernelSyncInfo->psSyncData;
+                psMapMemInfoMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
+                        psKernelMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
+                psMapMemInfoMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
+                        psKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
+
+                psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo =
+                        psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
+
+                psMapMemInfoMemOUT->sClientMemInfo.psClientSyncInfo = &psMapMemInfoMemOUT->sClientSyncInfo;
+
+                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                         &psMapMemInfoMemOUT->sClientSyncInfo.hKernelSyncInfo,
+                                                         psKernelMemInfo->psKernelSyncInfo,
+                                                         PVRSRV_HANDLE_TYPE_SYNC_INFO,
+                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                                         psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo);
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc)
+
+        return 0;
+}
+
+
+
+static IMG_INT
+MMU_GetPDDevPAddrBW(IMG_UINT32 ui32BridgeID,
+                                        PVRSRV_BRIDGE_IN_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrIN,
+                                        PVRSRV_BRIDGE_OUT_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrOUT,
+                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevMemContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR);
+
+        psGetMmuPDDevPAddrOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
+                                                   psGetMmuPDDevPAddrIN->hDevMemContext,
+                                                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+        if(psGetMmuPDDevPAddrOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetMmuPDDevPAddrOUT->sPDDevPAddr =
+                BM_GetDeviceNode(hDevMemContextInt)->pfnMMUGetPDDevPAddr(BM_GetMMUContextFromMemContext(hDevMemContextInt));
+        if(psGetMmuPDDevPAddrOUT->sPDDevPAddr.uiAddr)
+        {
+                psGetMmuPDDevPAddrOUT->eError = PVRSRV_OK;
+        }
+        else
+        {
+                psGetMmuPDDevPAddrOUT->eError = PVRSRV_ERROR_INVALID_PHYS_ADDR;
+        }
+        return 0;
+}
+
+
+
+IMG_INT
+DummyBW(IMG_UINT32 ui32BridgeID,
+                IMG_VOID *psBridgeIn,
+                IMG_VOID *psBridgeOut,
+                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+#if !defined(DEBUG)
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+#endif
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+        PVR_UNREFERENCED_PARAMETER(psBridgeOut);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+
+#if defined(DEBUG_BRIDGE_KM)
+        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 %u mapped to "
+                         "Dummy Wrapper (probably not what you want!)",
+                         __FUNCTION__, ui32BridgeID));
+#endif
+        return -ENOTTY;
+}
+
+
+IMG_VOID
+_SetDispatchTableEntry(IMG_UINT32 ui32Index,
+                                           const IMG_CHAR *pszIOCName,
+                                           BridgeWrapperFunction pfFunction,
+                                           const IMG_CHAR *pszFunctionName)
+{
+        static IMG_UINT32 ui32PrevIndex = ~0UL;         
+#if !defined(DEBUG)
+        PVR_UNREFERENCED_PARAMETER(pszIOCName);
+#endif
+#if !defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE) && !defined(DEBUG_BRIDGE_KM)
+        PVR_UNREFERENCED_PARAMETER(pszFunctionName);
+#endif
+
+#if defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE)
+        
+        PVR_DPF((PVR_DBG_WARNING, "%s: %d %s %s", __FUNCTION__, ui32Index, pszIOCName, pszFunctionName));
+#endif
+
+        
+        if(g_BridgeDispatchTable[ui32Index].pfFunction)
+        {
+#if defined(DEBUG_BRIDGE_KM)
+                PVR_DPF((PVR_DBG_ERROR,
+                                 "%s: BUG!: Adding dispatch table entry for %s clobbers an existing entry for %s",
+                                 __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=%u)",
+                                 __FUNCTION__, pszIOCName, ui32Index));
+#endif
+                PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue."));
+        }
+
+        
+        if((ui32PrevIndex != ~0UL) &&
+           ((ui32Index >= ui32PrevIndex + DISPATCH_TABLE_GAP_THRESHOLD) ||
+                (ui32Index <= ui32PrevIndex)))
+        {
+#if defined(DEBUG_BRIDGE_KM)
+                PVR_DPF((PVR_DBG_WARNING,
+                                 "%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
+                PVR_DPF((PVR_DBG_WARNING,
+                                 "%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."));
+        }
+
+        g_BridgeDispatchTable[ui32Index].pfFunction = pfFunction;
+#if defined(DEBUG_BRIDGE_KM)
+        g_BridgeDispatchTable[ui32Index].pszIOCName = pszIOCName;
+        g_BridgeDispatchTable[ui32Index].pszFunctionName = pszFunctionName;
+        g_BridgeDispatchTable[ui32Index].ui32CallCount = 0;
+        g_BridgeDispatchTable[ui32Index].ui32CopyFromUserTotalBytes = 0;
+#endif
+
+        ui32PrevIndex = ui32Index;
+}
+
+static IMG_INT
+PVRSRVInitSrvConnectBW(IMG_UINT32 ui32BridgeID,
+                                           IMG_VOID *psBridgeIn,
+                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_CONNECT);
+        PVR_UNREFERENCED_PARAMETER(psBridgeIn);
+
+         
+        if((OSProcHasPrivSrvInit() == IMG_FALSE) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
+        {
+                psRetOUT->eError = PVRSRV_ERROR_SRV_CONNECT_FAILED;
+                return 0;
+        }
+
+#if defined (__linux__)
+        PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_TRUE);
+#endif
+        psPerProc->bInitProcess = IMG_TRUE;
+
+        psRetOUT->eError = PVRSRV_OK;
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVInitSrvDisconnectBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_INITSRV_DISCONNECT *psInitSrvDisconnectIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_DISCONNECT);
+
+        if(!psPerProc->bInitProcess)
+        {
+                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))
+                                ? IMG_TRUE : IMG_FALSE);
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVEventObjectWaitBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_EVENT_OBJECT_WAIT *psEventObjectWaitIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hOSEventKM;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_WAIT);
+
+        psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hOSEventKM,
+                                                   psEventObjectWaitIN->hOSEventKM,
+                                                   PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = OSEventObjectWait(hOSEventKM);
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVEventObjectOpenBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_EVENT_OBJECT_OPEN *psEventObjectOpenIN,
+                                                  PVRSRV_BRIDGE_OUT_EVENT_OBJECT_OPEN *psEventObjectOpenOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_OPEN);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc, 1)
+
+        psEventObjectOpenOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &psEventObjectOpenIN->sEventObject.hOSEventKM,
+                                                   psEventObjectOpenIN->sEventObject.hOSEventKM,
+                                                   PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
+
+        if(psEventObjectOpenOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psEventObjectOpenOUT->eError = OSEventObjectOpen(&psEventObjectOpenIN->sEventObject, &psEventObjectOpenOUT->hOSEvent);
+
+        if(psEventObjectOpenOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psEventObjectOpenOUT->hOSEvent,
+                                          psEventObjectOpenOUT->hOSEvent,
+                                          PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc)
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVEventObjectCloseBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_EVENT_OBJECT_CLOSE *psEventObjectCloseIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hOSEventKM;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &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,
+                                                   PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = OSEventObjectClose(&psEventObjectCloseIN->sEventObject, hOSEventKM);
+
+        return 0;
+}
+
+
+typedef struct _MODIFY_SYNC_OP_INFO
+{
+        IMG_HANDLE  hResItem;
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+        IMG_UINT32      ui32ModifyFlags;
+        IMG_UINT32      ui32ReadOpsPendingSnapShot;
+        IMG_UINT32      ui32WriteOpsPendingSnapShot;
+} MODIFY_SYNC_OP_INFO;
+
+
+static PVRSRV_ERROR DoQuerySyncOpsSatisfied(MODIFY_SYNC_OP_INFO *psModSyncOpInfo)
+{
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+
+        psKernelSyncInfo = psModSyncOpInfo->psKernelSyncInfo;
+
+        if (!psKernelSyncInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        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;
+
+        if (!psKernelSyncInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        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);
+        
+
+        
+        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)
+{
+        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,
+                                                                                                        (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)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
+                return 0;
+        }
+
+        if(psModSyncOpInfo->psKernelSyncInfo)
+        {
+                
+                psModifySyncOpsOUT->eError = PVRSRV_ERROR_RETRY;
+                PVR_DPF((PVR_DBG_VERBOSE, "PVRSRVModifyPendingSyncOpsBW: SyncInfo Modification object is not empty"));
+                return 0;
+        }
+
+        
+        psModSyncOpInfo->psKernelSyncInfo = psKernelSyncInfo;
+        psModSyncOpInfo->ui32ModifyFlags = psModifySyncOpsIN->ui32ModifyFlags;
+        psModSyncOpInfo->ui32ReadOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
+        psModSyncOpInfo->ui32WriteOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
+
+        
+
+        psModifySyncOpsOUT->ui32ReadOpsPending = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
+        psModifySyncOpsOUT->ui32WriteOpsPending = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
+
+        if(psModifySyncOpsIN->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC)
+        {
+                psKernelSyncInfo->psSyncData->ui32WriteOpsPending++;
+        }
+
+        if(psModifySyncOpsIN->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC)
+        {
+                psKernelSyncInfo->psSyncData->ui32ReadOpsPending++;
+        }
+
+        
+        psModifySyncOpsOUT->eError = ResManDissociateRes(psModSyncOpInfo->hResItem,
+                                                                                                         psPerProc->hResManContext);
+
+        if (psModifySyncOpsOUT->eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
+                return 0;
+        }
+
+        return 0;
+}
+
+
+static IMG_INT
+PVRSRVModifyCompleteSyncOpsBW(IMG_UINT32                                                        ui32BridgeID,
+                                      PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS         *psModifySyncOpsIN,
+                                          PVRSRV_BRIDGE_RETURN                                                  *psModifySyncOpsOUT,
+                                          PVRSRV_PER_PROCESS_DATA                                               *psPerProc)
+{
+        MODIFY_SYNC_OP_INFO             *psModSyncOpInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS);
+
+        psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                                                        (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(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),
+                                                  ui32MinimumReadOpsComplete,
+                                                  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);
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: PVRSRVReleaseHandle failed"));
+                psFreeSyncInfoOUT->eError = eError;
+                return 0;
+        }
+
+        eError = ResManFreeResByPtr(psSyncInfo->hResItem);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: ResManFreeResByPtr failed"));
+                psFreeSyncInfoOUT->eError = eError;
+                return 0;
+        }
+
+        return 0;
+}
+
+
+PVRSRV_ERROR
+CommonBridgeInit(IMG_VOID)
+{
+        IMG_UINT32 i;
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DEVICES, PVRSRVEnumerateDevicesBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO, PVRSRVAcquireDeviceDataBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_DEVICEINFO, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT, PVRSRVCreateDeviceMemContextBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT, PVRSRVDestroyDeviceMemContextBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO, PVRSRVGetDeviceMemHeapInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_DEVICEMEM, PVRSRVAllocDeviceMemBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEVICEMEM, PVRSRVFreeDeviceMemBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GETFREE_DEVICEMEM, PVRSRVGetFreeDeviceMemBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_COMMANDQUEUE, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_COMMANDQUEUE, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA, PVRMMapOSMemHandleToMMapDataBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CONNECT_SERVICES, PVRSRVConnectBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_DISCONNECT_SERVICES, PVRSRVDisconnectBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_DEVICE_MEM, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVICEMEMINFO, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_RESERVE_DEV_VIRTMEM , DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEV_VIRTMEM, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_EXT_MEMORY, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_EXT_MEMORY, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEV_MEMORY, PVRSRVMapDeviceMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEV_MEMORY, PVRSRVUnmapDeviceMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY, PVRSRVMapDeviceClassMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY, PVRSRVUnmapDeviceClassMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEM_INFO_TO_USER, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_MEM_INFO_FROM_USER, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_EXPORT_DEVICEMEM, PVRSRVExportDeviceMemBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MMAP_DATA, PVRMMapReleaseMMapDataBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PROCESS_SIMISR_EVENT, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_REGISTER_SIM_PROCESS, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNREGISTER_SIM_PROCESS, DummyBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAPPHYSTOUSERSPACE, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAPPHYSTOUSERSPACE, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GETPHYSTOUSERSPACEMAP, DummyBW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_FB_STATS, DummyBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_MISC_INFO, PVRSRVGetMiscInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MISC_INFO, DummyBW);
+
+        
+#if defined (SUPPORT_OVERLAY_ROTATE_BLIT)
+        SetDispatchTableEntry(PVRSRV_BRIDGE_INIT_3D_OVL_BLT_RES, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_DEINIT_3D_OVL_BLT_RES, DummyBW);
+#endif
+
+
+        
+#if defined(PDUMP)
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_INIT, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_MEMPOL, PDumpMemPolBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPMEM, PDumpMemBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REG, PDumpRegWithFlagsBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REGPOL, PDumpRegPolBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_COMMENT, PDumpCommentBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SETFRAME, PDumpSetFrameBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_ISCAPTURING, PDumpIsCaptureFrameBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPBITMAP, PDumpBitmapBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPREADREG, PDumpReadRegBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SYNCPOL, PDumpSyncPolBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPSYNC, PDumpSyncDumpBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DRIVERINFO, PDumpDriverInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR, PDumpPDDevPAddrBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ, PDumpCycleCountRegReadBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STARTINITPHASE, PDumpStartInitPhaseBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STOPINITPHASE, PDumpStopInitPhaseBW);
+#endif 
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_OEMJTABLE, DummyBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_CLASS, PVRSRVEnumerateDCBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE, PVRSRVOpenDCDeviceBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE, PVRSRVCloseDCDeviceBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS, PVRSRVEnumDCFormatsBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS, PVRSRVEnumDCDimsBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER, PVRSRVGetDCSystemBufferBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_INFO, PVRSRVGetDCInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN, PVRSRVCreateDCSwapChainBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN, PVRSRVDestroyDCSwapChainBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT, PVRSRVSetDCDstRectBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT, PVRSRVSetDCSrcRectBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY, PVRSRVSetDCDstColourKeyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY, PVRSRVSetDCSrcColourKeyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS, PVRSRVGetDCBuffersBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER, PVRSRVSwapToDCBufferBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM, PVRSRVSwapToDCSystemBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE, PVRSRVOpenBCDeviceBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE, PVRSRVCloseBCDeviceBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO, PVRSRVGetBCInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER, PVRSRVGetBCBufferBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_EXT_MEMORY, PVRSRVWrapExtMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY, PVRSRVUnwrapExtMemoryBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM, PVRSRVAllocSharedSysMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM, PVRSRVFreeSharedSysMemoryBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEMINFO_MEM, PVRSRVMapMemInfoMemBW);
+
+        
+        SetDispatchTableEntry(PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR, MMU_GetPDDevPAddrBW);
+
+        
+        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_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();
+#endif
+#if defined (SUPPORT_VGX)
+        SetVGXDispatchTableEntry();
+#endif
+#if defined (SUPPORT_MSVDX)
+        SetMSVDXDispatchTableEntry();
+#endif
+
+
+        
+        
+        for(i=0;i<BRIDGE_DISPATCH_TABLE_ENTRY_COUNT;i++)
+        {
+                if(!g_BridgeDispatchTable[i].pfFunction)
+                {
+                        g_BridgeDispatchTable[i].pfFunction = &DummyBW;
+#if defined(DEBUG_BRIDGE_KM)
+                        g_BridgeDispatchTable[i].pszIOCName = "_PVRSRV_BRIDGE_DUMMY";
+                        g_BridgeDispatchTable[i].pszFunctionName = "DummyBW";
+                        g_BridgeDispatchTable[i].ui32CallCount = 0;
+                        g_BridgeDispatchTable[i].ui32CopyFromUserTotalBytes = 0;
+                        g_BridgeDispatchTable[i].ui32CopyToUserTotalBytes = 0;
+#endif
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+IMG_INT BridgedDispatchKM(PVRSRV_PER_PROCESS_DATA * psPerProc,
+                                          PVRSRV_BRIDGE_PACKAGE   * psBridgePackageKM)
+{
+
+        IMG_VOID   * psBridgeIn;
+        IMG_VOID   * psBridgeOut;
+        BridgeWrapperFunction pfBridgeHandler;
+        IMG_UINT32   ui32BridgeID = psBridgePackageKM->ui32BridgeID;
+        IMG_INT      err          = -EFAULT;
+
+#if defined(DEBUG_TRACE_BRIDGE_KM)
+        PVR_DPF((PVR_DBG_ERROR, "%s: %s",
+                         __FUNCTION__,
+                         g_BridgeDispatchTable[ui32BridgeID].pszIOCName));
+#endif
+
+#if defined(DEBUG_BRIDGE_KM)
+        g_BridgeDispatchTable[ui32BridgeID].ui32CallCount++;
+        g_BridgeGlobalStats.ui32IOCTLCount++;
+#endif
+
+        if(!psPerProc->bInitProcess)
+        {
+                if(PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
+                {
+                        if(!PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL))
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: Initialisation failed.  Driver unusable.",
+                                                 __FUNCTION__));
+                                goto return_fault;
+                        }
+                }
+                else
+                {
+                        if(PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING))
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: Initialisation is in progress",
+                                                 __FUNCTION__));
+                                goto return_fault;
+                        }
+                        else
+                        {
+                                
+                                switch(ui32BridgeID)
+                                {
+                                        case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_CONNECT_SERVICES):
+                                        case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_DISCONNECT_SERVICES):
+                                        case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_INITSRV_CONNECT):
+                                        case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_INITSRV_DISCONNECT):
+                                                break;
+                                        default:
+                                                PVR_DPF((PVR_DBG_ERROR, "%s: Driver initialisation not completed yet.",
+                                                                 __FUNCTION__));
+                                                goto return_fault;
+                                }
+                        }
+                }
+        }
+
+
+
+#if defined(__linux__)
+        {
+                
+                SYS_DATA *psSysData;
+
+                SysAcquireData(&psSysData);
+
+                
+                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,
+                                                        psBridgePackageKM->pvParamIn,
+                                                        psBridgePackageKM->ui32InBufferSize))
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: Invalid pvParamIn pointer", __FUNCTION__));
+                        }
+
+                        if(CopyFromUserWrapper(psPerProc,
+                                                       ui32BridgeID,
+                                                                   psBridgeIn,
+                                                                   psBridgePackageKM->pvParamIn,
+                                                                   psBridgePackageKM->ui32InBufferSize)
+                          != PVRSRV_OK)
+                        {
+                                goto return_fault;
+                        }
+                }
+        }
+#else
+        psBridgeIn  = psBridgePackageKM->pvParamIn;
+        psBridgeOut = psBridgePackageKM->pvParamOut;
+#endif
+
+        if(ui32BridgeID >= (BRIDGE_DISPATCH_TABLE_ENTRY_COUNT))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: ui32BridgeID = %d is out if range!",
+                                 __FUNCTION__, ui32BridgeID));
+                goto return_fault;
+        }
+        pfBridgeHandler =
+                (BridgeWrapperFunction)g_BridgeDispatchTable[ui32BridgeID].pfFunction;
+        err = pfBridgeHandler(ui32BridgeID,
+                                                  psBridgeIn,
+                                                  psBridgeOut,
+                                                  psPerProc);
+        if(err < 0)
+        {
+                goto return_fault;
+        }
+
+
+#if defined(__linux__)
+        
+        if(CopyToUserWrapper(psPerProc,
+                                                 ui32BridgeID,
+                                                 psBridgePackageKM->pvParamOut,
+                                                 psBridgeOut,
+                                                 psBridgePackageKM->ui32OutBufferSize)
+           != PVRSRV_OK)
+        {
+                goto return_fault;
+        }
+#endif
+
+        err = 0;
+return_fault:
+        ReleaseHandleBatch(psPerProc);
+        return err;
+}
+
diff --git a/drivers/gpu/pvr/bridged_pvr_bridge.h b/drivers/gpu/pvr/bridged_pvr_bridge.h
new file mode 100644
index 00000000000..004257429bd
--- /dev/null
+++ b/drivers/gpu/pvr/bridged_pvr_bridge.h
@@ -0,0 +1,232 @@
+/**********************************************************************
+ *
+ * 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 __BRIDGED_PVR_BRIDGE_H__
+#define __BRIDGED_PVR_BRIDGE_H__
+
+#include "pvr_bridge.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#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))
+#endif
+
+#ifndef ENOMEM
+#define ENOMEM  12
+#endif
+#ifndef EFAULT
+#define EFAULT  14
+#endif
+#ifndef ENOTTY
+#define ENOTTY  25
+#endif
+
+#if defined(DEBUG_BRIDGE_KM)
+PVRSRV_ERROR
+CopyFromUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
+                                        IMG_UINT32 ui32BridgeID,
+                                        IMG_VOID *pvDest,
+                                        IMG_VOID *pvSrc,
+                                        IMG_UINT32 ui32Size);
+PVRSRV_ERROR
+CopyToUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData, 
+                                  IMG_UINT32 ui32BridgeID,
+                                  IMG_VOID *pvDest,
+                                  IMG_VOID *pvSrc,
+                                  IMG_UINT32 ui32Size);
+#else
+#define CopyFromUserWrapper(pProcData, ui32BridgeID, pvDest, pvSrc, ui32Size) \
+        OSCopyFromUser(pProcData, pvDest, pvSrc, ui32Size)
+#define CopyToUserWrapper(pProcData, ui32BridgeID, pvDest, pvSrc, ui32Size) \
+        OSCopyToUser(pProcData, pvDest, pvSrc, ui32Size)
+#endif
+
+
+#define ASSIGN_AND_RETURN_ON_ERROR(error, src, res)             \
+        do                                                      \
+        {                                                       \
+                (error) = (src);                                \
+                if ((error) != PVRSRV_OK)                       \
+                {                                               \
+                        return (res);                           \
+                }                                               \
+        } while ((error) != PVRSRV_OK);
+
+#define ASSIGN_AND_EXIT_ON_ERROR(error, src)            \
+        ASSIGN_AND_RETURN_ON_ERROR(error, src, 0)
+
+#if defined (PVR_SECURE_HANDLES)
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(NewHandleBatch)
+#endif
+static INLINE PVRSRV_ERROR
+NewHandleBatch(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                        IMG_UINT32 ui32BatchSize)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(!psPerProc->bHandlesBatched);
+
+        eError = PVRSRVNewHandleBatch(psPerProc->psHandleBase, ui32BatchSize);
+
+        if (eError == PVRSRV_OK)
+        {
+                psPerProc->bHandlesBatched = IMG_TRUE;
+        }
+
+        return eError;
+}
+
+#define NEW_HANDLE_BATCH_OR_ERROR(error, psPerProc, ui32BatchSize)      \
+        ASSIGN_AND_EXIT_ON_ERROR(error, NewHandleBatch(psPerProc, ui32BatchSize))
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(CommitHandleBatch)
+#endif
+static INLINE PVRSRV_ERROR
+CommitHandleBatch(PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVR_ASSERT(psPerProc->bHandlesBatched);
+
+        psPerProc->bHandlesBatched = IMG_FALSE;
+
+        return PVRSRVCommitHandleBatch(psPerProc->psHandleBase);
+}
+
+
+#define COMMIT_HANDLE_BATCH_OR_ERROR(error, psPerProc)                  \
+        ASSIGN_AND_EXIT_ON_ERROR(error, CommitHandleBatch(psPerProc))
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(ReleaseHandleBatch)
+#endif
+static INLINE IMG_VOID
+ReleaseHandleBatch(PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        if (psPerProc->bHandlesBatched)
+        {
+                psPerProc->bHandlesBatched = IMG_FALSE;
+
+                PVRSRVReleaseHandleBatch(psPerProc->psHandleBase);
+        }
+}
+#else   
+#define NEW_HANDLE_BATCH_OR_ERROR(error, psPerProc, ui32BatchSize)
+#define COMMIT_HANDLE_BATCH_OR_ERROR(error, psPerProc)
+#define ReleaseHandleBatch(psPerProc)
+#endif  
+
+IMG_INT
+DummyBW(IMG_UINT32 ui32BridgeID,
+                IMG_VOID *psBridgeIn,
+                IMG_VOID *psBridgeOut,
+                PVRSRV_PER_PROCESS_DATA *psPerProc);
+
+typedef IMG_INT (*BridgeWrapperFunction)(IMG_UINT32 ui32BridgeID,
+                                                                         IMG_VOID *psBridgeIn,
+                                                                         IMG_VOID *psBridgeOut,
+                                                                         PVRSRV_PER_PROCESS_DATA *psPerProc);
+
+typedef struct _PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY
+{
+        BridgeWrapperFunction pfFunction; 
+#if defined(DEBUG_BRIDGE_KM)
+        const IMG_CHAR *pszIOCName; 
+        const IMG_CHAR *pszFunctionName; 
+        IMG_UINT32 ui32CallCount; 
+        IMG_UINT32 ui32CopyFromUserTotalBytes; 
+        IMG_UINT32 ui32CopyToUserTotalBytes; 
+#endif
+}PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY;
+
+#if defined(SUPPORT_VGX) || defined(SUPPORT_MSVDX)
+        #if defined(SUPPORT_VGX)
+                #define BRIDGE_DISPATCH_TABLE_ENTRY_COUNT (PVRSRV_BRIDGE_LAST_VGX_CMD+1)
+                #define PVRSRV_BRIDGE_LAST_DEVICE_CMD      PVRSRV_BRIDGE_LAST_VGX_CMD
+        #else
+                #define BRIDGE_DISPATCH_TABLE_ENTRY_COUNT (PVRSRV_BRIDGE_LAST_MSVDX_CMD+1)
+                #define PVRSRV_BRIDGE_LAST_DEVICE_CMD      PVRSRV_BRIDGE_LAST_MSVDX_CMD
+        #endif
+#else
+        #if defined(SUPPORT_SGX)
+                #define BRIDGE_DISPATCH_TABLE_ENTRY_COUNT (PVRSRV_BRIDGE_LAST_SGX_CMD+1)
+                #define PVRSRV_BRIDGE_LAST_DEVICE_CMD      PVRSRV_BRIDGE_LAST_SGX_CMD
+        #else
+                #define BRIDGE_DISPATCH_TABLE_ENTRY_COUNT (PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD+1)
+                #define PVRSRV_BRIDGE_LAST_DEVICE_CMD      PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD
+        #endif
+#endif
+
+extern PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY g_BridgeDispatchTable[BRIDGE_DISPATCH_TABLE_ENTRY_COUNT];
+
+IMG_VOID
+_SetDispatchTableEntry(IMG_UINT32 ui32Index,
+                                           const IMG_CHAR *pszIOCName,
+                                           BridgeWrapperFunction pfFunction,
+                                           const IMG_CHAR *pszFunctionName);
+
+
+ 
+#define SetDispatchTableEntry(ui32Index, pfFunction) \
+        _SetDispatchTableEntry(PVRSRV_GET_BRIDGE_ID(ui32Index), #ui32Index, (BridgeWrapperFunction)pfFunction, #pfFunction)
+
+#define DISPATCH_TABLE_GAP_THRESHOLD 5
+
+#if defined(DEBUG)
+#define PVRSRV_BRIDGE_ASSERT_CMD(X, Y) PVR_ASSERT(X == PVRSRV_GET_BRIDGE_ID(Y))
+#else
+#define PVRSRV_BRIDGE_ASSERT_CMD(X, Y) PVR_UNREFERENCED_PARAMETER(X)
+#endif
+
+
+#if defined(DEBUG_BRIDGE_KM)
+typedef struct _PVRSRV_BRIDGE_GLOBAL_STATS
+{
+        IMG_UINT32 ui32IOCTLCount;
+        IMG_UINT32 ui32TotalCopyFromUserBytes;
+        IMG_UINT32 ui32TotalCopyToUserBytes;
+}PVRSRV_BRIDGE_GLOBAL_STATS;
+
+extern PVRSRV_BRIDGE_GLOBAL_STATS g_BridgeGlobalStats;
+#endif
+
+
+PVRSRV_ERROR CommonBridgeInit(IMG_VOID);
+
+IMG_INT BridgedDispatchKM(PVRSRV_PER_PROCESS_DATA * psPerProc,
+                                          PVRSRV_BRIDGE_PACKAGE   * psBridgePackageKM);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/bridged_support.c b/drivers/gpu/pvr/bridged_support.c
new file mode 100644
index 00000000000..e10e577121f
--- /dev/null
+++ b/drivers/gpu/pvr/bridged_support.c
@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * 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 "servicesint.h"
+#include "bridged_support.h"
+
+
+PVRSRV_ERROR
+PVRSRVLookupOSMemHandle(PVRSRV_HANDLE_BASE *psHandleBase, IMG_HANDLE *phOSMemHandle, IMG_HANDLE hMHandle)
+{
+        IMG_HANDLE hMHandleInt;
+        PVRSRV_HANDLE_TYPE eHandleType;
+        PVRSRV_ERROR eError;
+
+        
+        eError = PVRSRVLookupHandleAnyType(psHandleBase, &hMHandleInt,
+                                                          &eHandleType,
+                                                          hMHandle);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        switch(eHandleType)
+        {
+#if defined(PVR_SECURE_HANDLES)
+                case PVRSRV_HANDLE_TYPE_MEM_INFO:
+                case PVRSRV_HANDLE_TYPE_MEM_INFO_REF:
+                case PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO:
+                {
+                        PVRSRV_KERNEL_MEM_INFO *psMemInfo = (PVRSRV_KERNEL_MEM_INFO *)hMHandleInt;
+
+                        *phOSMemHandle = psMemInfo->sMemBlk.hOSMemHandle;
+
+                        break;
+                }
+                case PVRSRV_HANDLE_TYPE_SYNC_INFO:
+                {
+                        PVRSRV_KERNEL_SYNC_INFO *psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)hMHandleInt;
+                        PVRSRV_KERNEL_MEM_INFO *psMemInfo = psSyncInfo->psSyncDataMemInfoKM;
+                        
+                        *phOSMemHandle = psMemInfo->sMemBlk.hOSMemHandle;
+
+                        break;
+                }
+                case  PVRSRV_HANDLE_TYPE_SOC_TIMER:
+                {
+                        *phOSMemHandle = (IMG_VOID *)hMHandleInt;
+                        break;
+                }
+#else
+                case  PVRSRV_HANDLE_TYPE_NONE:
+                        *phOSMemHandle = (IMG_VOID *)hMHandleInt;
+                        break;
+#endif
+                default:
+                        return PVRSRV_ERROR_BAD_MAPPING;
+        }
+
+        return PVRSRV_OK;
+}
diff --git a/drivers/gpu/pvr/bridged_support.h b/drivers/gpu/pvr/bridged_support.h
new file mode 100644
index 00000000000..371715d6ea8
--- /dev/null
+++ b/drivers/gpu/pvr/bridged_support.h
@@ -0,0 +1,43 @@
+/**********************************************************************
+ *
+ * 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 __BRIDGED_SUPPORT_H__
+#define __BRIDGED_SUPPORT_H__
+
+#include "handle.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+PVRSRV_ERROR PVRSRVLookupOSMemHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phOSMemHandle, IMG_HANDLE hMHandle);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/buffer_manager.c b/drivers/gpu/pvr/buffer_manager.c
new file mode 100644
index 00000000000..cde168391c8
--- /dev/null
+++ b/drivers/gpu/pvr/buffer_manager.c
@@ -0,0 +1,2040 @@
+/**********************************************************************
+ *
+ * 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 "sysconfig.h"
+#include "hash.h"
+#include "ra.h"
+#include "pdump_km.h"
+#include "lists.h"
+
+static IMG_BOOL
+ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags);
+static IMG_VOID
+BM_FreeMemory (IMG_VOID *pH, IMG_UINTPTR_T base, BM_MAPPING *psMapping);
+static IMG_BOOL
+BM_ImportMemory(IMG_VOID *pH, IMG_SIZE_T uSize,
+                                        IMG_SIZE_T *pActualSize, BM_MAPPING **ppsMapping,
+                                        IMG_UINT32 uFlags, IMG_UINTPTR_T *pBase);
+
+static IMG_BOOL
+DevMemoryAlloc (BM_CONTEXT *pBMContext,
+                                BM_MAPPING *pMapping,
+                                IMG_SIZE_T *pActualSize,
+                                IMG_UINT32 uFlags,
+                                IMG_UINT32 dev_vaddr_alignment,
+                                IMG_DEV_VIRTADDR *pDevVAddr);
+static IMG_VOID
+DevMemoryFree (BM_MAPPING *pMapping);
+
+static IMG_BOOL
+AllocMemory (BM_CONTEXT                         *pBMContext,
+                                BM_HEAP                         *psBMHeap,
+                                IMG_DEV_VIRTADDR        *psDevVAddr,
+                                IMG_SIZE_T                      uSize,
+                                IMG_UINT32                      uFlags,
+                                IMG_UINT32                      uDevVAddrAlignment,
+                                BM_BUF                          *pBuf)
+{
+        BM_MAPPING                      *pMapping;
+        IMG_UINTPTR_T           uOffset;
+        RA_ARENA                        *pArena = IMG_NULL;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "AllocMemory (uSize=0x%x, uFlags=0x%x, align=0x%x)",
+                          uSize, uFlags, uDevVAddrAlignment));
+
+        
+
+
+        if(uFlags & PVRSRV_MEM_RAM_BACKED_ALLOCATION)
+        {
+                if(uFlags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR)
+                {
+                        
+                        PVR_DPF ((PVR_DBG_ERROR, "AllocMemory: combination of DevVAddr management and RAM backing mode unsupported"));
+                        return IMG_FALSE;
+                }
+
+                
+
+                
+                if(psBMHeap->ui32Attribs
+                   &    (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+                   |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+                {
+                        
+                        pArena = psBMHeap->pImportArena;
+                        PVR_ASSERT(psBMHeap->sDevArena.psDeviceMemoryHeapInfo->ui32Attribs & PVRSRV_MEM_RAM_BACKED_ALLOCATION);
+                }
+                else
+                {
+                        PVR_DPF ((PVR_DBG_ERROR, "AllocMemory: backing store type doesn't match heap"));
+                        return IMG_FALSE;
+                }
+
+                
+                if (!RA_Alloc(pArena,
+                                          uSize,
+                                          IMG_NULL,
+                                          (IMG_VOID*) &pMapping,
+                                          uFlags,
+                                          uDevVAddrAlignment,
+                                          0,
+                                          (IMG_UINTPTR_T *)&(pBuf->DevVAddr.uiAddr)))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "AllocMemory: RA_Alloc(0x%x) FAILED", uSize));
+                        return IMG_FALSE;
+                }
+
+                uOffset = pBuf->DevVAddr.uiAddr - pMapping->DevVAddr.uiAddr;
+                if(pMapping->CpuVAddr)
+                {
+                        pBuf->CpuVAddr = (IMG_VOID*) ((IMG_UINTPTR_T)pMapping->CpuVAddr + uOffset);
+                }
+                else
+                {
+                        pBuf->CpuVAddr = IMG_NULL;
+                }
+
+                if(uSize == pMapping->uSize)
+                {
+                        pBuf->hOSMemHandle = pMapping->hOSMemHandle;
+                }
+                else
+                {
+                        if(OSGetSubMemHandle(pMapping->hOSMemHandle,
+                                                                 uOffset,
+                                                                 uSize,
+                                                                 psBMHeap->ui32Attribs,
+                                                                 &pBuf->hOSMemHandle)!=PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "AllocMemory: OSGetSubMemHandle FAILED"));
+                                return IMG_FALSE;
+                        }
+                }
+
+                
+                pBuf->CpuPAddr.uiAddr = pMapping->CpuPAddr.uiAddr + uOffset;
+
+                if(uFlags & PVRSRV_MEM_ZERO)
+                {
+                        if(!ZeroBuf(pBuf, pMapping, uSize, psBMHeap->ui32Attribs | uFlags))
+                        {
+                                return IMG_FALSE;
+                        }
+                }
+        }
+        else
+        {
+                if(uFlags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR)
+                {
+                        
+                        PVR_ASSERT(psDevVAddr != IMG_NULL);
+
+                        if (psDevVAddr == IMG_NULL)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "AllocMemory: invalid parameter - psDevVAddr"));
+                                return IMG_FALSE;
+                        }
+
+                        
+                        pBMContext->psDeviceNode->pfnMMUAlloc (psBMHeap->pMMUHeap,
+                                                                                                        uSize,
+                                                                                                        IMG_NULL,
+                                                                                                        PVRSRV_MEM_USER_SUPPLIED_DEVVADDR,
+                                                                                                        uDevVAddrAlignment,
+                                                                                                        psDevVAddr);
+
+                        
+                        pBuf->DevVAddr = *psDevVAddr;
+                }
+                else
+                {
+                        
+
+                        
+                        pBMContext->psDeviceNode->pfnMMUAlloc (psBMHeap->pMMUHeap,
+                                                                                                        uSize,
+                                                                                                        IMG_NULL,
+                                                                                                        0,
+                                                                                                        uDevVAddrAlignment,
+                                                                                                        &pBuf->DevVAddr);
+                }
+
+                
+                if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                        sizeof (struct _BM_MAPPING_),
+                                                        (IMG_PVOID *)&pMapping, IMG_NULL,
+                                                        "Buffer Manager Mapping") != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "AllocMemory: OSAllocMem(0x%x) FAILED", sizeof(*pMapping)));
+                        return IMG_FALSE;
+                }
+
+                
+                pBuf->CpuVAddr = IMG_NULL;
+                pBuf->hOSMemHandle = 0;
+                pBuf->CpuPAddr.uiAddr = 0;
+
+                
+                pMapping->CpuVAddr = IMG_NULL;
+                pMapping->CpuPAddr.uiAddr = 0;
+                pMapping->DevVAddr = pBuf->DevVAddr;
+                pMapping->psSysAddr = IMG_NULL;
+                pMapping->uSize = uSize;
+                pMapping->hOSMemHandle = 0;
+        }
+
+        
+        pMapping->pArena = pArena;
+
+        
+        pMapping->pBMHeap = psBMHeap;
+        pBuf->pMapping = pMapping;
+
+        
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                                "AllocMemory: pMapping=%08x: DevV=%08X CpuV=%08x CpuP=%08X uSize=0x%x",
+                                (IMG_UINTPTR_T)pMapping,
+                                pMapping->DevVAddr.uiAddr,
+                                (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",
+                                (IMG_UINTPTR_T)pBuf,
+                                pBuf->DevVAddr.uiAddr,
+                                (IMG_UINTPTR_T)pBuf->CpuVAddr,
+                                pBuf->CpuPAddr.uiAddr,
+                                uSize));
+
+        
+        PVR_ASSERT(((pBuf->DevVAddr.uiAddr) & (uDevVAddrAlignment - 1)) == 0);
+
+        return IMG_TRUE;
+}
+
+
+static IMG_BOOL
+WrapMemory (BM_HEAP *psBMHeap,
+                        IMG_SIZE_T uSize,
+                        IMG_SIZE_T ui32BaseOffset,
+                        IMG_BOOL bPhysContig,
+                        IMG_SYS_PHYADDR *psAddr,
+                        IMG_VOID *pvCPUVAddr,
+                        IMG_UINT32 uFlags,
+                        BM_BUF *pBuf)
+{
+        IMG_DEV_VIRTADDR DevVAddr = {0};
+        BM_MAPPING *pMapping;
+        IMG_BOOL bResult;
+        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%08x, flags=0x%x)",
+                          (IMG_UINTPTR_T)psBMHeap, uSize, ui32BaseOffset, bPhysContig, (IMG_UINTPTR_T)pvCPUVAddr, uFlags));
+
+        PVR_ASSERT((psAddr->uiAddr & (ui32PageSize - 1)) == 0);
+        
+        PVR_ASSERT(((IMG_UINTPTR_T)pvCPUVAddr & (ui32PageSize - 1)) == 0);
+
+        uSize += ui32BaseOffset;
+        uSize = HOST_PAGEALIGN (uSize);
+
+        
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(*pMapping),
+                                                (IMG_PVOID *)&pMapping, IMG_NULL,
+                                                "Mocked-up mapping") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSAllocMem(0x%x) FAILED",sizeof(*pMapping)));
+                return IMG_FALSE;
+        }
+
+        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,
+                                                        pMapping->CpuVAddr,
+                                                        pMapping->uSize,
+                                                        uFlags,
+                                                        &pMapping->hOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterMem Phys=0x%08X, Size=%d) failed",
+                                        pMapping->CpuPAddr.uiAddr, pMapping->uSize));
+                                goto fail_cleanup;
+                        }
+                }
+                else
+                {
+                        pMapping->eCpuMemoryOrigin = hm_wrapped_scatter_virtaddr;
+                        pMapping->psSysAddr = psAddr;
+
+                        if(OSRegisterDiscontigMem(pMapping->psSysAddr,
+                                                        pMapping->CpuVAddr,
+                                                        pMapping->uSize,
+                                                        uFlags,
+                                                        &pMapping->hOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSRegisterDiscontigMem Size=%d) failed",
+                                        pMapping->uSize));
+                                goto fail_cleanup;
+                        }
+                }
+        }
+        else
+        {
+                if (bPhysContig)
+                {
+                        pMapping->eCpuMemoryOrigin = hm_wrapped;
+                        pMapping->CpuPAddr = SysSysPAddrToCpuPAddr(psAddr[0]);
+
+                        if(OSReservePhys(pMapping->CpuPAddr,
+                                                         pMapping->uSize,
+                                                         uFlags,
+                                                         &pMapping->CpuVAddr,
+                                                         &pMapping->hOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSReservePhys Phys=0x%08X, Size=%d) failed",
+                                        pMapping->CpuPAddr.uiAddr, pMapping->uSize));
+                                goto fail_cleanup;
+                        }
+                }
+                else
+                {
+                        pMapping->eCpuMemoryOrigin = hm_wrapped_scatter;
+                        pMapping->psSysAddr = psAddr;
+
+                        if(OSReserveDiscontigPhys(pMapping->psSysAddr,
+                                                         pMapping->uSize,
+                                                         uFlags,
+                                                         &pMapping->CpuVAddr,
+                                                         &pMapping->hOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSReserveDiscontigPhys Size=%d) failed",
+                                        pMapping->uSize));
+                                goto fail_cleanup;
+                        }
+                }
+        }
+
+        
+        bResult = DevMemoryAlloc(psBMHeap->pBMContext,
+                                                         pMapping,
+                                                         IMG_NULL,
+                                                         uFlags | PVRSRV_MEM_READ | PVRSRV_MEM_WRITE,
+                                                         IMG_CAST_TO_DEVVADDR_UINT(ui32PageSize),
+                                                         &DevVAddr);
+        if (!bResult)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                "WrapMemory: DevMemoryAlloc(0x%x) failed",
+                                pMapping->uSize));
+                goto fail_cleanup;
+        }
+
+        
+        pBuf->CpuPAddr.uiAddr = pMapping->CpuPAddr.uiAddr + ui32BaseOffset;
+        if(!ui32BaseOffset)
+        {
+                pBuf->hOSMemHandle = pMapping->hOSMemHandle;
+        }
+        else
+        {
+                if(OSGetSubMemHandle(pMapping->hOSMemHandle,
+                                                         ui32BaseOffset,
+                                                         (pMapping->uSize-ui32BaseOffset),
+                                                         uFlags,
+                                                         &pBuf->hOSMemHandle)!=PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "WrapMemory: OSGetSubMemHandle failed"));
+                        goto fail_cleanup;
+                }
+        }
+        if(pMapping->CpuVAddr)
+        {
+                pBuf->CpuVAddr = (IMG_VOID*) ((IMG_UINTPTR_T)pMapping->CpuVAddr + ui32BaseOffset);
+        }
+        pBuf->DevVAddr.uiAddr = pMapping->DevVAddr.uiAddr + IMG_CAST_TO_DEVVADDR_UINT(ui32BaseOffset);
+
+        if(uFlags & PVRSRV_MEM_ZERO)
+        {
+                if(!ZeroBuf(pBuf, pMapping, uSize, uFlags))
+                {
+                        return IMG_FALSE;
+                }
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "DevVaddr.uiAddr=%08X", DevVAddr.uiAddr));
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                                "WrapMemory: DevV=%08X CpuP=%08X uSize=0x%x",
+                                pMapping->DevVAddr.uiAddr, pMapping->CpuPAddr.uiAddr, pMapping->uSize));
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                                "WrapMemory: DevV=%08X CpuP=%08X uSize=0x%x",
+                                pBuf->DevVAddr.uiAddr, pBuf->CpuPAddr.uiAddr, uSize));
+
+        pBuf->pMapping = pMapping;
+        return IMG_TRUE;
+
+fail_cleanup:
+        if(ui32BaseOffset && pBuf->hOSMemHandle)
+        {
+                OSReleaseSubMemHandle(pBuf->hOSMemHandle, uFlags);
+        }
+
+        if(pMapping && (pMapping->CpuVAddr || pMapping->hOSMemHandle))
+        {
+                switch(pMapping->eCpuMemoryOrigin)
+                {
+                        case hm_wrapped:
+                                OSUnReservePhys(pMapping->CpuVAddr, pMapping->uSize, uFlags, pMapping->hOSMemHandle);
+                                break;
+                        case hm_wrapped_virtaddr:
+                                OSUnRegisterMem(pMapping->CpuVAddr, pMapping->uSize, uFlags, pMapping->hOSMemHandle);
+                                break;
+                        case hm_wrapped_scatter:
+                                OSUnReserveDiscontigPhys(pMapping->CpuVAddr, pMapping->uSize, uFlags, pMapping->hOSMemHandle);
+                                break;
+                        case hm_wrapped_scatter_virtaddr:
+                                OSUnRegisterDiscontigMem(pMapping->CpuVAddr, pMapping->uSize, uFlags, pMapping->hOSMemHandle);
+                                break;
+                        default:
+                                break;
+                }
+
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+        
+
+        return IMG_FALSE;
+}
+
+
+static IMG_BOOL
+ZeroBuf(BM_BUF *pBuf, BM_MAPPING *pMapping, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags)
+{
+        IMG_VOID *pvCpuVAddr;
+
+        if(pBuf->CpuVAddr)
+        {
+                OSMemSet(pBuf->CpuVAddr, 0, ui32Bytes);
+        }
+        else if(pMapping->eCpuMemoryOrigin == hm_contiguous
+                        || pMapping->eCpuMemoryOrigin == hm_wrapped)
+        {
+                pvCpuVAddr = OSMapPhysToLin(pBuf->CpuPAddr,
+                                                                        ui32Bytes,
+                                                                        PVRSRV_HAP_KERNEL_ONLY
+                                                                        | (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK),
+                                                                        IMG_NULL);
+                if(!pvCpuVAddr)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "ZeroBuf: OSMapPhysToLin for contiguous buffer failed"));
+                        return IMG_FALSE;
+                }
+                OSMemSet(pvCpuVAddr, 0, ui32Bytes);
+                OSUnMapPhysToLin(pvCpuVAddr,
+                                                 ui32Bytes,
+                                                 PVRSRV_HAP_KERNEL_ONLY
+                                                 | (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK),
+                                                 IMG_NULL);
+        }
+        else
+        {
+                IMG_SIZE_T ui32BytesRemaining = ui32Bytes;
+                IMG_SIZE_T ui32CurrentOffset = 0;
+                IMG_CPU_PHYADDR CpuPAddr;
+
+                
+                PVR_ASSERT(pBuf->hOSMemHandle);
+
+                while(ui32BytesRemaining > 0)
+                {
+                        IMG_SIZE_T ui32BlockBytes = MIN(ui32BytesRemaining, HOST_PAGESIZE());
+                        CpuPAddr = OSMemHandleToCpuPAddr(pBuf->hOSMemHandle, ui32CurrentOffset);
+                        
+                        if(CpuPAddr.uiAddr & (HOST_PAGESIZE() -1))
+                        {
+                                ui32BlockBytes =
+                                        MIN(ui32BytesRemaining, (IMG_UINT32)(HOST_PAGEALIGN(CpuPAddr.uiAddr) - CpuPAddr.uiAddr));
+                        }
+
+                        pvCpuVAddr = OSMapPhysToLin(CpuPAddr,
+                                                                                ui32BlockBytes,
+                                                                                PVRSRV_HAP_KERNEL_ONLY
+                                                                                | (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK),
+                                                                                IMG_NULL);
+                        if(!pvCpuVAddr)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "ZeroBuf: OSMapPhysToLin while zeroing non-contiguous memory FAILED"));
+                                return IMG_FALSE;
+                        }
+                        OSMemSet(pvCpuVAddr, 0, ui32BlockBytes);
+                        OSUnMapPhysToLin(pvCpuVAddr,
+                                                         ui32BlockBytes,
+                                                         PVRSRV_HAP_KERNEL_ONLY
+                                                         | (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK),
+                                                         IMG_NULL);
+
+                        ui32BytesRemaining -= ui32BlockBytes;
+                        ui32CurrentOffset += ui32BlockBytes;
+                }
+        }
+
+        return IMG_TRUE;
+}
+
+static IMG_VOID
+FreeBuf (BM_BUF *pBuf, IMG_UINT32 ui32Flags, IMG_BOOL bFromAllocator)
+{
+        BM_MAPPING *pMapping;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                        "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 ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+                {
+                        
+                        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)
+                {
+            
+                        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))
+                        {
+                                
+
+
+                                PVR_ASSERT(pBuf->ui32ExportCount == 0)
+                                RA_Free (pBuf->pMapping->pArena, pBuf->DevVAddr.uiAddr, IMG_FALSE);
+                        }
+                }
+                else
+                {
+                        if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+                        {
+                                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;
+                                }
+                        }
+                        if (bFromAllocator)
+                                DevMemoryFree (pMapping);
+
+                        if ((pBuf->ui32ExportCount == 0) && (pBuf->ui32RefCount == 0))
+                        {
+                                
+                                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_BUF), pBuf, IMG_NULL);
+                
+        }
+}
+
+static PVRSRV_ERROR BM_DestroyContext_AnyCb(BM_HEAP *psBMHeap)
+{
+        if(psBMHeap->ui32Attribs
+        &       (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+                |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+        {
+                if (psBMHeap->pImportArena)
+                {
+                        IMG_BOOL bTestDelete = RA_TestDelete(psBMHeap->pImportArena);
+                        if (!bTestDelete)
+                        {
+                                PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext_AnyCb: RA_TestDelete failed"));
+                                return PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP;
+                        }
+                }
+        }
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR
+BM_DestroyContext(IMG_HANDLE    hBMContext,
+                                  IMG_BOOL              *pbDestroyed)
+{
+        PVRSRV_ERROR eError;
+        BM_CONTEXT *pBMContext = (BM_CONTEXT*)hBMContext;
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "BM_DestroyContext"));
+
+        if (pbDestroyed != IMG_NULL)
+        {
+                *pbDestroyed = IMG_FALSE;
+        }
+
+        
+
+        if (pBMContext == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: Invalid handle"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        pBMContext->ui32RefCount--;
+
+        if (pBMContext->ui32RefCount > 0)
+        {
+                
+                return PVRSRV_OK;
+        }
+
+        
+
+
+        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"));
+#if 0
+                
+                
+                
+                
+                PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: Cleaning up with ResManFreeSpecial"));
+                if(ResManFreeSpecial() != PVRSRV_OK)
+                {
+                        PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeSpecial failed %d",eError));
+                }
+                
+#endif
+                return eError;
+        }
+        else
+        {
+                
+                eError = ResManFreeResByPtr(pBMContext->hResItem);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyContext: ResManFreeResByPtr failed %d",eError));
+                        return eError;
+                }
+
+                
+                if (pbDestroyed != IMG_NULL)
+                {
+                        *pbDestroyed = IMG_TRUE;
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+
+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
+        &       (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+                |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+        {
+                if (psBMHeap->pImportArena)
+                {
+                        RA_Delete (psBMHeap->pImportArena);
+                }
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_DestroyContext: backing store type unsupported"));
+                return PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE;
+        }
+
+        
+        psDeviceNode->pfnMMUDelete(psBMHeap->pMMUHeap);
+
+        
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+        
+
+        return PVRSRV_OK;
+}
+
+
+static PVRSRV_ERROR BM_DestroyContextCallBack(IMG_PVOID         pvParam,
+                                                                                          IMG_UINT32    ui32Param)
+{
+        BM_CONTEXT *pBMContext = pvParam;
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        PVRSRV_ERROR eError;
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        
+
+        psDeviceNode = pBMContext->psDeviceNode;
+
+        
+
+        eError = List_BM_HEAP_PVRSRV_ERROR_Any_va(pBMContext->psBMHeap,
+                                                                                &BM_DestroyContextCallBack_AnyVaCb,
+                                                                                psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+        
+
+        if (pBMContext->psMMUContext)
+        {
+                psDeviceNode->pfnMMUFinalise(pBMContext->psMMUContext);
+        }
+
+        
+
+        if (pBMContext->pBufferHash)
+        {
+                HASH_Delete(pBMContext->pBufferHash);
+        }
+
+        if (pBMContext == psDeviceNode->sDevMemoryInfo.pBMKernelContext)
+        {
+                
+                psDeviceNode->sDevMemoryInfo.pBMKernelContext = IMG_NULL;
+        }
+        else
+        {
+                
+                List_BM_CONTEXT_Remove(pBMContext);
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_CONTEXT), pBMContext, IMG_NULL);
+        
+
+        return PVRSRV_OK;
+}
+
+
+static IMG_HANDLE BM_CreateContext_IncRefCount_AnyVaCb(BM_CONTEXT *pBMContext, va_list va)
+{
+        PRESMAN_CONTEXT hResManContext;
+        hResManContext = va_arg(va, PRESMAN_CONTEXT);
+        if(ResManFindResourceByPtr(hResManContext, pBMContext->hResItem) == PVRSRV_OK)
+        {
+                
+                pBMContext->ui32RefCount++;
+                return pBMContext;
+        }
+        return IMG_NULL;
+}
+
+static IMG_VOID BM_CreateContext_InsertHeap_ForEachVaCb(BM_HEAP *psBMHeap, va_list va)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        BM_CONTEXT *pBMContext;
+        psDeviceNode = va_arg(va, PVRSRV_DEVICE_NODE*);
+        pBMContext = va_arg(va, BM_CONTEXT*);
+        switch(psBMHeap->sDevArena.DevMemHeapType)
+        {
+                case DEVICE_MEMORY_HEAP_SHARED:
+                case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+                {
+                        
+                        psDeviceNode->pfnMMUInsertHeap(pBMContext->psMMUContext, psBMHeap->pMMUHeap);
+                        break;
+                }
+        }
+}
+
+IMG_HANDLE
+BM_CreateContext(PVRSRV_DEVICE_NODE                     *psDeviceNode,
+                                 IMG_DEV_PHYADDR                        *psPDDevPAddr,
+                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                 IMG_BOOL                                       *pbCreated)
+{
+        BM_CONTEXT                      *pBMContext;
+        DEVICE_MEMORY_INFO      *psDevMemoryInfo;
+        IMG_BOOL                        bKernelContext;
+        PRESMAN_CONTEXT         hResManContext;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "BM_CreateContext"));
+
+        if (psPerProc == IMG_NULL)
+        {
+                bKernelContext = IMG_TRUE;
+                hResManContext = psDeviceNode->hResManContext;
+        }
+        else
+        {
+                bKernelContext = IMG_FALSE;
+                hResManContext = psPerProc->hResManContext;
+        }
+
+        if (pbCreated != IMG_NULL)
+        {
+                *pbCreated = IMG_FALSE;
+        }
+
+        
+        psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
+
+        if (bKernelContext == IMG_FALSE)
+        {
+                IMG_HANDLE res = (IMG_HANDLE) List_BM_CONTEXT_Any_va(psDevMemoryInfo->pBMContext,
+                                                                                                                        &BM_CreateContext_IncRefCount_AnyVaCb,
+                                                                                                                        hResManContext);
+                if (res)
+                {
+                        return res;
+                }
+        }
+
+        
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof (struct _BM_CONTEXT_),
+                                         (IMG_PVOID *)&pBMContext, IMG_NULL,
+                                         "Buffer Manager Context") != PVRSRV_OK)
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_CreateContext: Alloc failed"));
+                return IMG_NULL;
+        }
+        OSMemSet(pBMContext, 0, sizeof (BM_CONTEXT));
+
+        
+        pBMContext->psDeviceNode = psDeviceNode;
+
+        
+        
+        pBMContext->pBufferHash = HASH_Create(32);
+        if (pBMContext->pBufferHash==IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_CreateContext: HASH_Create failed"));
+                goto cleanup;
+        }
+
+        if(psDeviceNode->pfnMMUInitialise(psDeviceNode,
+                                                                                &pBMContext->psMMUContext,
+                                                                                psPDDevPAddr) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_CreateContext: MMUInitialise failed"));
+                goto cleanup;
+        }
+
+        if(bKernelContext)
+        {
+                
+                PVR_ASSERT(psDevMemoryInfo->pBMKernelContext == IMG_NULL);
+                psDevMemoryInfo->pBMKernelContext = pBMContext;
+        }
+        else
+        {
+                
+
+
+
+
+                PVR_ASSERT(psDevMemoryInfo->pBMKernelContext);
+
+                if (psDevMemoryInfo->pBMKernelContext == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_CreateContext: psDevMemoryInfo->pBMKernelContext invalid"));
+                        goto cleanup;
+                }
+
+                PVR_ASSERT(psDevMemoryInfo->pBMKernelContext->psBMHeap);
+
+                
+
+
+
+                pBMContext->psBMSharedHeap = psDevMemoryInfo->pBMKernelContext->psBMHeap;
+
+                
+
+
+                List_BM_HEAP_ForEach_va(pBMContext->psBMSharedHeap,
+                                                                &BM_CreateContext_InsertHeap_ForEachVaCb,
+                                                                psDeviceNode,
+                                                                pBMContext);
+
+                
+                List_BM_CONTEXT_Insert(&psDevMemoryInfo->pBMContext, pBMContext);
+        }
+
+        
+        pBMContext->ui32RefCount++;
+
+        
+        pBMContext->hResItem = ResManRegisterRes(hResManContext,
+                                                                                        RESMAN_TYPE_DEVICEMEM_CONTEXT,
+                                                                                        pBMContext,
+                                                                                        0,
+                                                                                        &BM_DestroyContextCallBack);
+        if (pBMContext->hResItem == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_CreateContext: ResManRegisterRes failed"));
+                goto cleanup;
+        }
+
+        if (pbCreated != IMG_NULL)
+        {
+                *pbCreated = IMG_TRUE;
+        }
+        return (IMG_HANDLE)pBMContext;
+
+cleanup:
+        (IMG_VOID)BM_DestroyContextCallBack(pBMContext, 0);
+
+        return IMG_NULL;
+}
+
+
+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*);
+        if (psBMHeap->sDevArena.ui32HeapID ==  psDevMemHeapInfo->ui32HeapID)
+        {
+                
+                return psBMHeap;
+        }
+        else
+        {
+                return IMG_NULL;
+        }
+}
+
+IMG_HANDLE
+BM_CreateHeap (IMG_HANDLE hBMContext,
+                           DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo)
+{
+        BM_CONTEXT *pBMContext = (BM_CONTEXT*)hBMContext;
+        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,
+                                                                                                 psDevMemHeapInfo);
+
+                if (psBMHeap)
+                {
+                        return psBMHeap;
+                }
+        }
+
+
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof (BM_HEAP),
+                                                (IMG_PVOID *)&psBMHeap, IMG_NULL,
+                                                "Buffer Manager Heap") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: Alloc failed"));
+                return IMG_NULL;
+        }
+
+        OSMemSet (psBMHeap, 0, sizeof (BM_HEAP));
+
+        psBMHeap->sDevArena.ui32HeapID = psDevMemHeapInfo->ui32HeapID;
+        psBMHeap->sDevArena.pszName = psDevMemHeapInfo->pszName;
+        psBMHeap->sDevArena.BaseDevVAddr = psDevMemHeapInfo->sDevVAddrBase;
+        psBMHeap->sDevArena.ui32Size = psDevMemHeapInfo->ui32HeapSize;
+        psBMHeap->sDevArena.DevMemHeapType = psDevMemHeapInfo->DevMemHeapType;
+        psBMHeap->sDevArena.ui32DataPageSize = psDevMemHeapInfo->ui32DataPageSize;
+        psBMHeap->sDevArena.psDeviceMemoryHeapInfo = psDevMemHeapInfo;
+        psBMHeap->ui32Attribs = psDevMemHeapInfo->ui32Attribs;
+
+        
+        psBMHeap->pBMContext = pBMContext;
+
+        psBMHeap->pMMUHeap = psDeviceNode->pfnMMUCreate (pBMContext->psMMUContext,
+                                                                                                        &psBMHeap->sDevArena,
+                                                                                                        &psBMHeap->pVMArena,
+                                                                                                        &psBMHeap->psMMUAttrib);
+        if (!psBMHeap->pMMUHeap)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: MMUCreate failed"));
+                goto ErrorExit;
+        }
+
+        
+        psBMHeap->pImportArena = RA_Create (psDevMemHeapInfo->pszBSName,
+                                                                                0, 0, IMG_NULL,
+                                                                                MAX(HOST_PAGESIZE(), psBMHeap->sDevArena.ui32DataPageSize),
+                                                                                &BM_ImportMemory,
+                                                                                &BM_FreeMemory,
+                                                                                IMG_NULL,
+                                                                                psBMHeap);
+        if(psBMHeap->pImportArena == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: RA_Create failed"));
+                goto ErrorExit;
+        }
+
+        if(psBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG)
+        {
+                
+
+
+
+                psBMHeap->pLocalDevMemArena = psDevMemHeapInfo->psLocalDevMemArena;
+                if(psBMHeap->pLocalDevMemArena == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_CreateHeap: LocalDevMemArena null"));
+                        goto ErrorExit;
+                }
+        }
+
+        
+        List_BM_HEAP_Insert(&pBMContext->psBMHeap, psBMHeap);
+
+        return (IMG_HANDLE)psBMHeap;
+
+        
+ErrorExit:
+
+        
+        if (psBMHeap->pMMUHeap != IMG_NULL)
+        {
+                psDeviceNode->pfnMMUDelete (psBMHeap->pMMUHeap);
+                psDeviceNode->pfnMMUFinalise (pBMContext->psMMUContext);
+        }
+
+        
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+        
+
+        return IMG_NULL;
+}
+
+IMG_VOID
+BM_DestroyHeap (IMG_HANDLE hDevMemHeap)
+{
+        BM_HEAP* psBMHeap = (BM_HEAP*)hDevMemHeap;
+        PVRSRV_DEVICE_NODE *psDeviceNode = psBMHeap->pBMContext->psDeviceNode;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "BM_DestroyHeap"));
+
+        if(psBMHeap)
+        {
+                
+                if(psBMHeap->ui32Attribs
+                &       (PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG
+                        |PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
+                {
+                        if (psBMHeap->pImportArena)
+                        {
+                                RA_Delete (psBMHeap->pImportArena);
+                        }
+                }
+                else
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_DestroyHeap: backing store type unsupported"));
+                        return;
+                }
+
+                
+                psDeviceNode->pfnMMUDelete (psBMHeap->pMMUHeap);
+
+                
+                List_BM_HEAP_Remove(psBMHeap);
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_HEAP), psBMHeap, IMG_NULL);
+                
+        }
+        else
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_DestroyHeap: invalid heap handle"));
+        }
+}
+
+
+IMG_BOOL
+BM_Reinitialise (PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+
+        PVR_DPF((PVR_DBG_MESSAGE, "BM_Reinitialise"));
+        PVR_UNREFERENCED_PARAMETER(psDeviceNode);
+
+
+        return IMG_TRUE;
+}
+
+IMG_BOOL
+BM_Alloc (  IMG_HANDLE                  hDevMemHeap,
+                        IMG_DEV_VIRTADDR        *psDevVAddr,
+                        IMG_SIZE_T                      uSize,
+                        IMG_UINT32                      *pui32Flags,
+                        IMG_UINT32                      uDevVAddrAlignment,
+                        BM_HANDLE                       *phBuf)
+{
+        BM_BUF *pBuf;
+        BM_CONTEXT *pBMContext;
+        BM_HEAP *psBMHeap;
+        SYS_DATA *psSysData;
+        IMG_UINT32 uFlags;
+
+        if (pui32Flags == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_Alloc: invalid parameter"));
+                PVR_DBG_BREAK;
+                return IMG_FALSE;
+        }
+
+        uFlags = *pui32Flags;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                  "BM_Alloc (uSize=0x%x, uFlags=0x%x, uDevVAddrAlignment=0x%x)",
+                        uSize, uFlags, uDevVAddrAlignment));
+
+        SysAcquireData(&psSysData);
+
+        psBMHeap = (BM_HEAP*)hDevMemHeap;
+        pBMContext = psBMHeap->pBMContext;
+
+        if(uDevVAddrAlignment == 0)
+        {
+                uDevVAddrAlignment = 1;
+        }
+
+        
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                   sizeof (BM_BUF),
+                                   (IMG_PVOID *)&pBuf, IMG_NULL,
+                                   "Buffer Manager buffer") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_Alloc: BM_Buf alloc FAILED"));
+                return IMG_FALSE;
+        }
+        OSMemSet(pBuf, 0, sizeof (BM_BUF));
+
+        
+        if (AllocMemory(pBMContext,
+                                        psBMHeap,
+                                        psDevVAddr,
+                                        uSize,
+                                        uFlags,
+                                        uDevVAddrAlignment,
+                                        pBuf) != IMG_TRUE)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL);
+                
+                PVR_DPF((PVR_DBG_ERROR, "BM_Alloc: AllocMemory FAILED"));
+                return IMG_FALSE;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                  "BM_Alloc (uSize=0x%x, uFlags=0x%x)",
+                  uSize, uFlags));
+
+        
+        pBuf->ui32RefCount = 1;
+        *phBuf = (BM_HANDLE)pBuf;
+        *pui32Flags = uFlags | psBMHeap->ui32Attribs;
+
+        
+        if(uFlags & PVRSRV_HAP_CACHETYPE_MASK)
+        {
+                *pui32Flags &= ~PVRSRV_HAP_CACHETYPE_MASK;
+                *pui32Flags |= (uFlags & PVRSRV_HAP_CACHETYPE_MASK);
+        }
+
+        return IMG_TRUE;
+}
+
+
+
+#if defined(PVR_LMA)
+static IMG_BOOL
+ValidSysPAddrArrayForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR *psSysPAddr, IMG_UINT32 ui32PageCount, IMG_SIZE_T ui32PageSize)
+{
+        IMG_UINT32 i;
+
+        for (i = 0; i < ui32PageCount; i++)
+        {
+                IMG_SYS_PHYADDR sStartSysPAddr = psSysPAddr[i];
+                IMG_SYS_PHYADDR sEndSysPAddr;
+
+                if (!SysVerifySysPAddrToDevPAddr(psDeviceNode->sDevId.eDeviceType, sStartSysPAddr))
+                {
+                        return IMG_FALSE;
+                }
+
+                sEndSysPAddr.uiAddr = sStartSysPAddr.uiAddr + ui32PageSize;
+
+                if (!SysVerifySysPAddrToDevPAddr(psDeviceNode->sDevId.eDeviceType, sEndSysPAddr))
+                {
+                        return IMG_FALSE;
+                }
+        }
+
+        return IMG_TRUE;
+}
+
+static IMG_BOOL
+ValidSysPAddrRangeForDev(PVRSRV_DEVICE_NODE *psDeviceNode, IMG_SYS_PHYADDR sStartSysPAddr, IMG_SIZE_T ui32Range)
+{
+        IMG_SYS_PHYADDR sEndSysPAddr;
+
+        if (!SysVerifySysPAddrToDevPAddr(psDeviceNode->sDevId.eDeviceType, sStartSysPAddr))
+        {
+                return IMG_FALSE;
+        }
+
+        sEndSysPAddr.uiAddr = sStartSysPAddr.uiAddr + ui32Range;
+
+        if (!SysVerifySysPAddrToDevPAddr(psDeviceNode->sDevId.eDeviceType, sEndSysPAddr))
+        {
+                return IMG_FALSE;
+        }
+
+        return IMG_TRUE;
+}
+
+#define WRAP_MAPPING_SIZE(ui32ByteSize, ui32PageOffset) HOST_PAGEALIGN((ui32ByteSize) + (ui32PageOffset))
+
+#define WRAP_PAGE_COUNT(ui32ByteSize, ui32PageOffset, ui32HostPageSize) (WRAP_MAPPING_SIZE(ui32ByteSize, ui32PageOffset) / (ui32HostPageSize))
+
+#endif
+
+
+IMG_BOOL
+BM_Wrap (       IMG_HANDLE hDevMemHeap,
+                        IMG_SIZE_T ui32Size,
+                        IMG_SIZE_T ui32Offset,
+                        IMG_BOOL bPhysContig,
+                        IMG_SYS_PHYADDR *psSysAddr,
+                        IMG_VOID *pvCPUVAddr,
+                        IMG_UINT32 *pui32Flags,
+                        BM_HANDLE *phBuf)
+{
+        BM_BUF *pBuf;
+        BM_CONTEXT *psBMContext;
+        BM_HEAP *psBMHeap;
+        SYS_DATA *psSysData;
+        IMG_SYS_PHYADDR sHashAddress;
+        IMG_UINT32 uFlags;
+
+        psBMHeap = (BM_HEAP*)hDevMemHeap;
+        psBMContext = psBMHeap->pBMContext;
+
+        uFlags = psBMHeap->ui32Attribs & (PVRSRV_HAP_CACHETYPE_MASK | PVRSRV_HAP_MAPTYPE_MASK);
+
+        if ((pui32Flags != IMG_NULL) && ((*pui32Flags & PVRSRV_HAP_CACHETYPE_MASK) != 0))
+        {
+                uFlags &= ~PVRSRV_HAP_CACHETYPE_MASK;
+                uFlags |= *pui32Flags & PVRSRV_HAP_CACHETYPE_MASK;
+        }
+
+        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, (IMG_UINTPTR_T)pvCPUVAddr, uFlags));
+
+        SysAcquireData(&psSysData);
+
+#if defined(PVR_LMA)
+        if (bPhysContig)
+        {
+                if (!ValidSysPAddrRangeForDev(psBMContext->psDeviceNode, *psSysAddr, WRAP_MAPPING_SIZE(ui32Size, ui32Offset)))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: System address range invalid for device"));
+                        return IMG_FALSE;
+                }
+        }
+        else
+        {
+                IMG_SIZE_T ui32HostPageSize = HOST_PAGESIZE();
+
+                if (!ValidSysPAddrArrayForDev(psBMContext->psDeviceNode, psSysAddr, WRAP_PAGE_COUNT(ui32Size, ui32Offset, ui32HostPageSize), ui32HostPageSize))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: Array of system addresses invalid for device"));
+                        return IMG_FALSE;
+                }
+        }
+#endif
+        
+        sHashAddress = psSysAddr[0];
+
+        
+        sHashAddress.uiAddr += ui32Offset;
+
+        
+        pBuf = (BM_BUF *)HASH_Retrieve(psBMContext->pBufferHash, sHashAddress.uiAddr);
+
+        if(pBuf)
+        {
+                IMG_SIZE_T ui32MappingSize = HOST_PAGEALIGN (ui32Size + ui32Offset);
+
+                
+                if(pBuf->pMapping->uSize == ui32MappingSize && (pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped ||
+                                                                                                                pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped_virtaddr))
+                {
+                        PVR_DPF((PVR_DBG_MESSAGE,
+                                        "BM_Wrap (Matched previous Wrap! uSize=0x%x, uOffset=0x%x, SysAddr=%08X)",
+                                        ui32Size, ui32Offset, sHashAddress.uiAddr));
+
+                        pBuf->ui32RefCount++;
+                        *phBuf = (BM_HANDLE)pBuf;
+                        if(pui32Flags)
+                                *pui32Flags = uFlags;
+
+                        return IMG_TRUE;
+                }
+        }
+
+        
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof (BM_BUF),
+                                                (IMG_PVOID *)&pBuf, IMG_NULL,
+                                                "Buffer Manager buffer") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: BM_Buf alloc FAILED"));
+                return IMG_FALSE;
+        }
+        OSMemSet(pBuf, 0, sizeof (BM_BUF));
+
+        
+        if (WrapMemory (psBMHeap, ui32Size, ui32Offset, bPhysContig, psSysAddr, pvCPUVAddr, uFlags, pBuf) != IMG_TRUE)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_Wrap: WrapMemory FAILED"));
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof (BM_BUF), pBuf, IMG_NULL);
+                
+                return IMG_FALSE;
+        }
+
+        
+        if(pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped || pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped_virtaddr)
+        {
+                
+                PVR_ASSERT(SysSysPAddrToCpuPAddr(sHashAddress).uiAddr == pBuf->CpuPAddr.uiAddr);
+
+                if (!HASH_Insert (psBMContext->pBufferHash, sHashAddress.uiAddr, (IMG_UINTPTR_T)pBuf))
+                {
+                        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, devVAddr=%08X)",
+                        ui32Size, uFlags, pBuf->DevVAddr.uiAddr));
+
+        
+        pBuf->ui32RefCount = 1;
+        *phBuf = (BM_HANDLE)pBuf;
+        if(pui32Flags)
+        {
+                
+                *pui32Flags = (uFlags & ~PVRSRV_HAP_MAPTYPE_MASK) | PVRSRV_HAP_MULTI_PROCESS;
+        }
+
+        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,
+                IMG_UINT32 ui32Flags)
+{
+        BM_BUF *pBuf = (BM_BUF *)hBuf;
+        SYS_DATA *psSysData;
+        IMG_SYS_PHYADDR sHashAddr;
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "BM_Free (h=0x%x)", (IMG_UINTPTR_T)hBuf));
+        PVR_ASSERT (pBuf!=IMG_NULL);
+
+        if (pBuf == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_Free: invalid parameter"));
+                return;
+        }
+
+        SysAcquireData(&psSysData);
+
+        pBuf->ui32RefCount--;
+
+        if(pBuf->ui32RefCount == 0)
+        {
+                if(pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped || pBuf->pMapping->eCpuMemoryOrigin == hm_wrapped_virtaddr)
+                {
+                        sHashAddr = SysCpuPAddrToSysPAddr(pBuf->CpuPAddr);
+
+                        HASH_Remove (pBuf->pMapping->pBMHeap->pBMContext->pBufferHash,  (IMG_UINTPTR_T)sHashAddr.uiAddr);
+                }
+                FreeBuf (pBuf, ui32Flags, IMG_TRUE);
+        }
+}
+
+
+IMG_CPU_VIRTADDR
+BM_HandleToCpuVaddr (BM_HANDLE hBuf)
+{
+        BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+        PVR_ASSERT (pBuf != IMG_NULL);
+        if (pBuf == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_HandleToCpuVaddr: invalid parameter"));
+                return IMG_NULL;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                                "BM_HandleToCpuVaddr(h=0x%x)=0x%x",
+                                (IMG_UINTPTR_T)hBuf, (IMG_UINTPTR_T)pBuf->CpuVAddr));
+        return pBuf->CpuVAddr;
+}
+
+
+IMG_DEV_VIRTADDR
+BM_HandleToDevVaddr (BM_HANDLE hBuf)
+{
+        BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+        PVR_ASSERT (pBuf != IMG_NULL);
+        if (pBuf == IMG_NULL)
+        {
+                IMG_DEV_VIRTADDR        DevVAddr = {0};
+                PVR_DPF((PVR_DBG_ERROR, "BM_HandleToDevVaddr: invalid parameter"));
+                return DevVAddr;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToDevVaddr(h=0x%x)=%08X", (IMG_UINTPTR_T)hBuf, pBuf->DevVAddr.uiAddr));
+        return pBuf->DevVAddr;
+}
+
+
+IMG_SYS_PHYADDR
+BM_HandleToSysPaddr (BM_HANDLE hBuf)
+{
+        BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+        PVR_ASSERT (pBuf != IMG_NULL);
+
+        if (pBuf == IMG_NULL)
+        {
+                IMG_SYS_PHYADDR PhysAddr = {0};
+                PVR_DPF((PVR_DBG_ERROR, "BM_HandleToSysPaddr: invalid parameter"));
+                return PhysAddr;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "BM_HandleToSysPaddr(h=0x%x)=%08X", (IMG_UINTPTR_T)hBuf, pBuf->CpuPAddr.uiAddr));
+        return SysCpuPAddrToSysPAddr (pBuf->CpuPAddr);
+}
+
+IMG_HANDLE
+BM_HandleToOSMemHandle(BM_HANDLE hBuf)
+{
+        BM_BUF *pBuf = (BM_BUF *)hBuf;
+
+        PVR_ASSERT (pBuf != IMG_NULL);
+
+        if (pBuf == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_HandleToOSMemHandle: invalid parameter"));
+                return IMG_NULL;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                                "BM_HandleToOSMemHandle(h=0x%x)=0x%x",
+                                (IMG_UINTPTR_T)hBuf, (IMG_UINTPTR_T)pBuf->hOSMemHandle));
+        return pBuf->hOSMemHandle;
+}
+
+static IMG_BOOL
+DevMemoryAlloc (BM_CONTEXT *pBMContext,
+                                BM_MAPPING *pMapping,
+                                IMG_SIZE_T *pActualSize,
+                                IMG_UINT32 uFlags,
+                                IMG_UINT32 dev_vaddr_alignment,
+                                IMG_DEV_VIRTADDR *pDevVAddr)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+#ifdef PDUMP
+        IMG_UINT32 ui32PDumpSize = pMapping->uSize;
+#endif
+
+        psDeviceNode = pBMContext->psDeviceNode;
+
+        if(uFlags & PVRSRV_MEM_INTERLEAVED)
+        {
+                
+                pMapping->uSize *= 2;
+        }
+
+#ifdef PDUMP
+        if(uFlags & PVRSRV_MEM_DUMMY)
+        {
+                
+                ui32PDumpSize = pMapping->pBMHeap->sDevArena.ui32DataPageSize;
+        }
+#endif
+
+        
+        if (!psDeviceNode->pfnMMUAlloc (pMapping->pBMHeap->pMMUHeap,
+                                                                        pMapping->uSize,
+                                                                        pActualSize,
+                                                                        0,
+                                                                        dev_vaddr_alignment,
+                                                                        &(pMapping->DevVAddr)))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "DevMemoryAlloc ERROR MMU_Alloc"));
+                return IMG_FALSE;
+        }
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+        EnableHostAccess(pBMContext->psMMUContext);
+#endif
+
+        
+        
+        PDUMPMALLOCPAGES(&psDeviceNode->sDevId, pMapping->DevVAddr.uiAddr, pMapping->CpuVAddr, pMapping->hOSMemHandle, ui32PDumpSize, pMapping->pBMHeap->sDevArena.ui32DataPageSize, (IMG_HANDLE)pMapping);
+
+        switch (pMapping->eCpuMemoryOrigin)
+        {
+                case hm_wrapped:
+                case hm_wrapped_virtaddr:
+                case hm_contiguous:
+                {
+                        psDeviceNode->pfnMMUMapPages (  pMapping->pBMHeap->pMMUHeap,
+                                                        pMapping->DevVAddr,
+                                                        SysCpuPAddrToSysPAddr (pMapping->CpuPAddr),
+                                                        pMapping->uSize,
+                                                        uFlags,
+                                                        (IMG_HANDLE)pMapping);
+
+                        *pDevVAddr = pMapping->DevVAddr;
+                        break;
+                }
+                case hm_env:
+                {
+                        psDeviceNode->pfnMMUMapShadow ( pMapping->pBMHeap->pMMUHeap,
+                                                        pMapping->DevVAddr,
+                                                        pMapping->uSize,
+                                                        pMapping->CpuVAddr,
+                                                        pMapping->hOSMemHandle,
+                                                        pDevVAddr,
+                                                        uFlags,
+                                                        (IMG_HANDLE)pMapping);
+                        break;
+                }
+                case hm_wrapped_scatter:
+                case hm_wrapped_scatter_virtaddr:
+                {
+                        psDeviceNode->pfnMMUMapScatter (pMapping->pBMHeap->pMMUHeap,
+                                                        pMapping->DevVAddr,
+                                                        pMapping->psSysAddr,
+                                                        pMapping->uSize,
+                                                        uFlags,
+                                                        (IMG_HANDLE)pMapping);
+
+                        *pDevVAddr = pMapping->DevVAddr;
+                        break;
+                }
+                default:
+                        PVR_DPF((PVR_DBG_ERROR,
+                                "Illegal value %d for pMapping->eCpuMemoryOrigin",
+                                pMapping->eCpuMemoryOrigin));
+                        return IMG_FALSE;
+        }
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+        DisableHostAccess(pBMContext->psMMUContext);
+#endif
+
+        return IMG_TRUE;
+}
+
+static IMG_VOID
+DevMemoryFree (BM_MAPPING *pMapping)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+#ifdef PDUMP
+        IMG_UINT32 ui32PSize;
+#endif
+
+#ifdef PDUMP
+        
+        if(pMapping->ui32Flags & PVRSRV_MEM_DUMMY)
+        {
+                
+                ui32PSize = pMapping->pBMHeap->sDevArena.ui32DataPageSize;
+        }
+        else
+        {
+                ui32PSize = pMapping->uSize;
+        }
+
+        PDUMPFREEPAGES(pMapping->pBMHeap,
+                    pMapping->DevVAddr,
+                    ui32PSize,
+                    pMapping->pBMHeap->sDevArena.ui32DataPageSize,
+                    (IMG_HANDLE)pMapping,
+                    (pMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED) ? IMG_TRUE : IMG_FALSE);
+#endif
+
+        psDeviceNode = pMapping->pBMHeap->pBMContext->psDeviceNode;
+
+        psDeviceNode->pfnMMUFree (pMapping->pBMHeap->pMMUHeap, pMapping->DevVAddr, IMG_CAST_TO_DEVVADDR_UINT(pMapping->uSize));
+}
+
+static IMG_BOOL
+BM_ImportMemory (IMG_VOID *pH,
+                          IMG_SIZE_T uRequestSize,
+                          IMG_SIZE_T *pActualSize,
+                          BM_MAPPING **ppsMapping,
+                          IMG_UINT32 uFlags,
+                          IMG_UINTPTR_T *pBase)
+{
+        BM_MAPPING *pMapping;
+        BM_HEAP *pBMHeap = pH;
+        BM_CONTEXT *pBMContext = pBMHeap->pBMContext;
+        IMG_BOOL bResult;
+        IMG_SIZE_T uSize;
+        IMG_SIZE_T uPSize;
+        IMG_UINT32 uDevVAddrAlignment = 0;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "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);
+
+        if (ppsMapping == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_ImportMemory: invalid parameter"));
+                goto fail_exit;
+        }
+
+        uSize = HOST_PAGEALIGN (uRequestSize);
+        PVR_ASSERT (uSize >= uRequestSize);
+
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof (BM_MAPPING),
+                                                (IMG_PVOID *)&pMapping, IMG_NULL,
+                                                "Buffer Manager Mapping") != PVRSRV_OK)
+        {
+                PVR_DPF ((PVR_DBG_ERROR, "BM_ImportMemory: failed BM_MAPPING alloc"));
+                goto fail_exit;
+        }
+
+        pMapping->hOSMemHandle = 0;
+        pMapping->CpuVAddr = 0;
+        pMapping->DevVAddr.uiAddr = 0;
+        pMapping->CpuPAddr.uiAddr = 0;
+        pMapping->uSize = uSize;
+        pMapping->pBMHeap = pBMHeap;
+        pMapping->ui32Flags = uFlags;
+
+        
+        if (pActualSize)
+        {
+                *pActualSize = uSize;
+        }
+
+        
+        if(pMapping->ui32Flags & PVRSRV_MEM_DUMMY)
+        {
+                uPSize = pBMHeap->sDevArena.ui32DataPageSize;
+        }
+        else
+        {
+                uPSize = pMapping->uSize;
+        }
+
+        
+
+        if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
+        {
+                IMG_UINT32 ui32Attribs = pBMHeap->ui32Attribs;
+
+                
+                if (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
+                {
+                        ui32Attribs &= ~PVRSRV_HAP_CACHETYPE_MASK;
+                        ui32Attribs |= (pMapping->ui32Flags & PVRSRV_HAP_CACHETYPE_MASK);
+                }
+
+                
+                if (OSAllocPages(ui32Attribs,
+                                                 uPSize,
+                                                 pBMHeap->sDevArena.ui32DataPageSize,
+                                                 (IMG_VOID **)&pMapping->CpuVAddr,
+                                                 &pMapping->hOSMemHandle) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,
+                                        "BM_ImportMemory: OSAllocPages(0x%x) failed",
+                                        uPSize));
+                        goto fail_mapping_alloc;
+                }
+
+                
+                pMapping->eCpuMemoryOrigin = hm_env;
+        }
+        else if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG)
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+                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);
+                }
+
+                if (!RA_Alloc (pBMHeap->pLocalDevMemArena,
+                                           uPSize,
+                                           IMG_NULL,
+                                           IMG_NULL,
+                                           0,
+                                           pBMHeap->sDevArena.ui32DataPageSize,
+                                           0,
+                                           (IMG_UINTPTR_T *)&sSysPAddr.uiAddr))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_ImportMemory: RA_Alloc(0x%x) FAILED", uPSize));
+                        goto fail_mapping_alloc;
+                }
+
+                
+                pMapping->CpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                if(OSReservePhys(pMapping->CpuPAddr,
+                                                 uPSize,
+                                                 ui32Attribs,
+                                                 &pMapping->CpuVAddr,
+                                                 &pMapping->hOSMemHandle) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "BM_ImportMemory: OSReservePhys failed"));
+                        goto fail_dev_mem_alloc;
+                }
+
+                
+                pMapping->eCpuMemoryOrigin = hm_contiguous;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_ImportMemory: Invalid backing store type"));
+                goto fail_mapping_alloc;
+        }
+
+        
+        bResult = DevMemoryAlloc (pBMContext,
+                                                                pMapping,
+                                                                IMG_NULL,
+                                                                uFlags,
+                                                                uDevVAddrAlignment,
+                                                                &pMapping->DevVAddr);
+        if (!bResult)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                "BM_ImportMemory: DevMemoryAlloc(0x%x) failed",
+                                pMapping->uSize));
+                goto fail_dev_mem_alloc;
+        }
+
+        
+        
+        PVR_ASSERT (uDevVAddrAlignment>1?(pMapping->DevVAddr.uiAddr%uDevVAddrAlignment)==0:1);
+
+        *pBase = pMapping->DevVAddr.uiAddr;
+        *ppsMapping = pMapping;
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "BM_ImportMemory: IMG_TRUE"));
+        return IMG_TRUE;
+
+fail_dev_mem_alloc:
+        if (pMapping && (pMapping->CpuVAddr || pMapping->hOSMemHandle))
+        {
+                
+                if(pMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED)
+                {
+                        pMapping->uSize /= 2;
+                }
+
+                if(pMapping->ui32Flags & PVRSRV_MEM_DUMMY)
+                {
+                        uPSize = pBMHeap->sDevArena.ui32DataPageSize;
+                }
+                else
+                {
+                        uPSize = pMapping->uSize;
+                }
+
+                if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
+                {
+                        OSFreePages(pBMHeap->ui32Attribs,
+                                                  uPSize,
+                                                  (IMG_VOID *)pMapping->CpuVAddr,
+                                                  pMapping->hOSMemHandle);
+                }
+                else
+                {
+                        IMG_SYS_PHYADDR sSysPAddr;
+
+                        if(pMapping->CpuVAddr)
+                        {
+                                OSUnReservePhys(pMapping->CpuVAddr,
+                                                                uPSize,
+                                                                pBMHeap->ui32Attribs,
+                                                                pMapping->hOSMemHandle);
+                        }
+                        sSysPAddr = SysCpuPAddrToSysPAddr(pMapping->CpuPAddr);
+                        RA_Free (pBMHeap->pLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+                }
+        }
+fail_mapping_alloc:
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), pMapping, IMG_NULL);
+        
+fail_exit:
+        return IMG_FALSE;
+}
+
+
+static IMG_VOID
+BM_FreeMemory (IMG_VOID *h, IMG_UINTPTR_T _base, BM_MAPPING *psMapping)
+{
+        BM_HEAP *pBMHeap = h;
+        IMG_SIZE_T uPSize;
+
+        PVR_UNREFERENCED_PARAMETER (_base);
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "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);
+
+        if (psMapping == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_FreeMemory: invalid parameter"));
+                return;
+        }
+
+        DevMemoryFree (psMapping);
+
+        
+        if((psMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED) != 0)
+        {
+                psMapping->uSize /= 2;
+        }
+
+        if(psMapping->ui32Flags & PVRSRV_MEM_DUMMY)
+        {
+                uPSize = psMapping->pBMHeap->sDevArena.ui32DataPageSize;
+        }
+        else
+        {
+                uPSize = psMapping->uSize;
+        }
+
+        if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG)
+        {
+                OSFreePages(pBMHeap->ui32Attribs,
+                                                uPSize,
+                                                (IMG_VOID *) psMapping->CpuVAddr,
+                                                psMapping->hOSMemHandle);
+        }
+        else if(pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG)
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+
+                OSUnReservePhys(psMapping->CpuVAddr, uPSize, pBMHeap->ui32Attribs, psMapping->hOSMemHandle);
+
+                sSysPAddr = SysCpuPAddrToSysPAddr(psMapping->CpuPAddr);
+
+                RA_Free (pBMHeap->pLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR, "BM_FreeMemory: Invalid backing store type"));
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_MAPPING), psMapping, IMG_NULL);
+        
+
+        PVR_DPF((PVR_DBG_MESSAGE,
+                        "..BM_FreeMemory (h=0x%x, base=0x%x)",
+                        (IMG_UINTPTR_T)h, _base));
+}
+
+IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                                IMG_DEV_VIRTADDR sDevVPageAddr,
+                                                                IMG_DEV_PHYADDR *psDevPAddr)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "BM_GetPhysPageAddr"));
+
+        PVR_ASSERT (psMemInfo && psDevPAddr)
+
+        
+        PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+        psDeviceNode = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pBMContext->psDeviceNode;
+
+        *psDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->pMMUHeap,
+                                                                                                sDevVPageAddr);
+}
+
+
+MMU_CONTEXT* BM_GetMMUContext(IMG_HANDLE hDevMemHeap)
+{
+        BM_HEAP *pBMHeap = (BM_HEAP*)hDevMemHeap;
+
+        PVR_DPF((PVR_DBG_VERBOSE, "BM_GetMMUContext"));
+
+        return pBMHeap->pBMContext->psMMUContext;
+}
+
+MMU_CONTEXT* BM_GetMMUContextFromMemContext(IMG_HANDLE hDevMemContext)
+{
+        BM_CONTEXT *pBMContext = (BM_CONTEXT*)hDevMemContext;
+
+        PVR_DPF ((PVR_DBG_VERBOSE, "BM_GetMMUContextFromMemContext"));
+
+        return pBMContext->psMMUContext;
+}
+
+IMG_HANDLE BM_GetMMUHeap(IMG_HANDLE hDevMemHeap)
+{
+        PVR_DPF((PVR_DBG_VERBOSE, "BM_GetMMUHeap"));
+
+        return (IMG_HANDLE)((BM_HEAP*)hDevMemHeap)->pMMUHeap;
+}
+
+
+PVRSRV_DEVICE_NODE* BM_GetDeviceNode(IMG_HANDLE hDevMemContext)
+{
+        PVR_DPF((PVR_DBG_VERBOSE, "BM_GetDeviceNode"));
+
+        return ((BM_CONTEXT*)hDevMemContext)->psDeviceNode;
+}
+
+
+IMG_HANDLE BM_GetMappingHandle(PVRSRV_KERNEL_MEM_INFO *psMemInfo)
+{
+        PVR_DPF((PVR_DBG_VERBOSE, "BM_GetMappingHandle"));
+
+        return ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->hOSMemHandle;
+}
+
diff --git a/drivers/gpu/pvr/buffer_manager.h b/drivers/gpu/pvr/buffer_manager.h
new file mode 100644
index 00000000000..1467cd3939f
--- /dev/null
+++ b/drivers/gpu/pvr/buffer_manager.h
@@ -0,0 +1,210 @@
+/**********************************************************************
+ *
+ * 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 _BUFFER_MANAGER_H_
+#define _BUFFER_MANAGER_H_
+
+#include "img_types.h"
+#include "ra.h"
+#include "perproc.h"
+
+#if defined(__cplusplus)
+extern "C"{
+#endif
+
+typedef struct _BM_HEAP_ BM_HEAP;
+
+struct _BM_MAPPING_
+{
+        enum
+        {
+                hm_wrapped = 1,         
+                hm_wrapped_scatter,     
+                hm_wrapped_virtaddr, 
+                hm_wrapped_scatter_virtaddr, 
+                hm_env,                         
+                hm_contiguous           
+        } eCpuMemoryOrigin;
+
+        BM_HEAP                         *pBMHeap;       
+        RA_ARENA                        *pArena;        
+
+        IMG_CPU_VIRTADDR        CpuVAddr;
+        IMG_CPU_PHYADDR         CpuPAddr;
+        IMG_DEV_VIRTADDR        DevVAddr;
+        IMG_SYS_PHYADDR         *psSysAddr;
+        IMG_SIZE_T                      uSize;
+    IMG_HANDLE          hOSMemHandle;
+        IMG_UINT32                      ui32Flags;
+};
+
+typedef struct _BM_BUF_
+{
+        IMG_CPU_VIRTADDR        *CpuVAddr;
+    IMG_VOID            *hOSMemHandle;
+        IMG_CPU_PHYADDR         CpuPAddr;
+        IMG_DEV_VIRTADDR        DevVAddr;
+
+        BM_MAPPING                      *pMapping;
+        IMG_UINT32                      ui32RefCount;
+        IMG_UINT32                      ui32ExportCount;
+} BM_BUF;
+
+struct _BM_HEAP_
+{
+        IMG_UINT32                              ui32Attribs;
+        BM_CONTEXT                              *pBMContext;
+        RA_ARENA                                *pImportArena;
+        RA_ARENA                                *pLocalDevMemArena;
+        RA_ARENA                                *pVMArena;
+        DEV_ARENA_DESCRIPTOR    sDevArena;
+        MMU_HEAP                                *pMMUHeap;
+        PDUMP_MMU_ATTRIB                *psMMUAttrib;
+        
+        struct _BM_HEAP_                *psNext;
+        struct _BM_HEAP_                **ppsThis;
+};
+
+struct _BM_CONTEXT_
+{
+        MMU_CONTEXT     *psMMUContext;
+
+        
+         BM_HEAP *psBMHeap;
+
+        
+         BM_HEAP *psBMSharedHeap;
+
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        
+        HASH_TABLE *pBufferHash;
+
+        
+        IMG_HANDLE hResItem;
+
+        IMG_UINT32 ui32RefCount;
+
+        
+
+        struct _BM_CONTEXT_ *psNext;
+        struct _BM_CONTEXT_ **ppsThis;
+};
+
+
+
+typedef IMG_VOID *BM_HANDLE;
+
+#define BP_POOL_MASK         0x7
+
+#define BP_CONTIGUOUS                   (1 << 3)
+#define BP_PARAMBUFFER                  (1 << 4)
+
+#define BM_MAX_DEVMEM_ARENAS  2
+
+IMG_HANDLE
+BM_CreateContext(PVRSRV_DEVICE_NODE                     *psDeviceNode,
+                                 IMG_DEV_PHYADDR                        *psPDDevPAddr,
+                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                 IMG_BOOL                                       *pbCreated);
+
+
+PVRSRV_ERROR
+BM_DestroyContext (IMG_HANDLE hBMContext,
+                                        IMG_BOOL *pbCreated);
+
+
+IMG_HANDLE
+BM_CreateHeap (IMG_HANDLE hBMContext,
+                                DEVICE_MEMORY_HEAP_INFO *psDevMemHeapInfo);
+
+IMG_VOID
+BM_DestroyHeap (IMG_HANDLE hDevMemHeap);
+
+
+IMG_BOOL
+BM_Reinitialise (PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_BOOL
+BM_Alloc (IMG_HANDLE                    hDevMemHeap,
+                        IMG_DEV_VIRTADDR        *psDevVAddr,
+                        IMG_SIZE_T                      uSize,
+                        IMG_UINT32                      *pui32Flags,
+                        IMG_UINT32                      uDevVAddrAlignment,
+                        BM_HANDLE                       *phBuf);
+
+IMG_BOOL
+BM_Wrap (       IMG_HANDLE hDevMemHeap,
+                    IMG_SIZE_T ui32Size,
+                        IMG_SIZE_T ui32Offset,
+                        IMG_BOOL bPhysContig,
+                        IMG_SYS_PHYADDR *psSysAddr,
+                        IMG_VOID *pvCPUVAddr,
+                        IMG_UINT32 *pui32Flags,
+                        BM_HANDLE *phBuf);
+
+IMG_VOID
+BM_Free (BM_HANDLE hBuf,
+                IMG_UINT32 ui32Flags);
+
+
+IMG_CPU_VIRTADDR
+BM_HandleToCpuVaddr (BM_HANDLE hBuf);
+
+IMG_DEV_VIRTADDR
+BM_HandleToDevVaddr (BM_HANDLE hBuf);
+
+IMG_SYS_PHYADDR
+BM_HandleToSysPaddr (BM_HANDLE hBuf);
+
+IMG_HANDLE
+BM_HandleToOSMemHandle (BM_HANDLE hBuf);
+
+IMG_VOID BM_GetPhysPageAddr(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                                IMG_DEV_VIRTADDR sDevVPageAddr,
+                                                                IMG_DEV_PHYADDR *psDevPAddr);
+
+MMU_CONTEXT* BM_GetMMUContext(IMG_HANDLE hDevMemHeap);
+
+MMU_CONTEXT* BM_GetMMUContextFromMemContext(IMG_HANDLE hDevMemContext);
+
+IMG_HANDLE BM_GetMMUHeap(IMG_HANDLE hDevMemHeap);
+
+PVRSRV_DEVICE_NODE* BM_GetDeviceNode(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
+
+#endif
+
diff --git a/drivers/gpu/pvr/device.h b/drivers/gpu/pvr/device.h
new file mode 100644
index 00000000000..2488aa9de36
--- /dev/null
+++ b/drivers/gpu/pvr/device.h
@@ -0,0 +1,316 @@
+/**********************************************************************
+ *
+ * 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 __DEVICE_H__
+#define __DEVICE_H__
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+        
+#include "ra.h"                 
+#include "resman.h"             
+
+typedef struct _BM_CONTEXT_ BM_CONTEXT;
+
+typedef struct _MMU_HEAP_ MMU_HEAP;
+typedef struct _MMU_CONTEXT_ MMU_CONTEXT;
+
+#define PVRSRV_BACKINGSTORE_SYSMEM_CONTIG               (1<<(PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT+0))
+#define PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG    (1<<(PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT+1))
+#define PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG             (1<<(PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT+2))
+#define PVRSRV_BACKINGSTORE_LOCALMEM_NONCONTIG  (1<<(PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT+3))
+
+typedef IMG_UINT32 DEVICE_MEMORY_HEAP_TYPE;
+#define DEVICE_MEMORY_HEAP_PERCONTEXT           0
+#define DEVICE_MEMORY_HEAP_KERNEL                       1
+#define DEVICE_MEMORY_HEAP_SHARED                       2
+#define DEVICE_MEMORY_HEAP_SHARED_EXPORTED      3
+
+#define PVRSRV_DEVICE_NODE_FLAGS_PORT80DISPLAY  1
+#define PVRSRV_DEVICE_NODE_FLAGS_MMU_OPT_INV    2       
+
+typedef struct _DEVICE_MEMORY_HEAP_INFO_
+{
+        
+        IMG_UINT32                              ui32HeapID;
+
+        
+        IMG_CHAR                                *pszName;
+
+        
+        IMG_CHAR                                *pszBSName;
+        
+        
+        IMG_DEV_VIRTADDR                sDevVAddrBase;
+
+        
+        IMG_UINT32                              ui32HeapSize;
+
+        
+        IMG_UINT32                              ui32Attribs;
+
+        
+        DEVICE_MEMORY_HEAP_TYPE DevMemHeapType;
+        
+        
+        IMG_HANDLE                              hDevMemHeap;
+        
+        
+        RA_ARENA                                *psLocalDevMemArena;
+
+        
+        IMG_UINT32                              ui32DataPageSize;
+
+        IMG_UINT32                              ui32XTileStride;
+
+} DEVICE_MEMORY_HEAP_INFO;
+
+typedef struct _DEVICE_MEMORY_INFO_
+{
+        
+        IMG_UINT32                              ui32AddressSpaceSizeLog2;
+
+        
+
+
+        IMG_UINT32                              ui32Flags;
+
+        
+        IMG_UINT32                              ui32HeapCount;
+        
+        
+        IMG_UINT32                              ui32SyncHeapID;
+        
+        
+        IMG_UINT32                              ui32MappingHeapID;
+
+        
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+
+        
+    BM_CONTEXT                          *pBMKernelContext;
+
+        
+    BM_CONTEXT                          *pBMContext;
+
+} DEVICE_MEMORY_INFO;
+
+
+typedef struct DEV_ARENA_DESCRIPTOR_TAG
+{
+        IMG_UINT32                              ui32HeapID;             
+
+        IMG_CHAR                                *pszName;               
+
+        IMG_DEV_VIRTADDR                BaseDevVAddr;   
+
+        IMG_UINT32                              ui32Size;               
+
+        DEVICE_MEMORY_HEAP_TYPE DevMemHeapType;
+
+        
+        IMG_UINT32                              ui32DataPageSize;
+
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeapInfo;
+
+} 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_DEVICE_IDENTIFIER        sDevId;
+        IMG_UINT32                                      ui32RefCount;
+
+        
+
+        
+        PVRSRV_ERROR                    (*pfnInitDevice) (IMG_VOID*);
+        
+        PVRSRV_ERROR                    (*pfnDeInitDevice) (IMG_VOID*);
+
+        
+        PVRSRV_ERROR                    (*pfnInitDeviceCompatCheck) (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**,PDUMP_MMU_ATTRIB **ppsMMUAttrib);
+        IMG_VOID                                (*pfnMMUDelete)(MMU_HEAP*);
+        IMG_BOOL                                (*pfnMMUAlloc)(MMU_HEAP*pMMU,
+                                                                                   IMG_SIZE_T uSize,
+                                                                                   IMG_SIZE_T *pActualSize,
+                                                                                   IMG_UINT32 uFlags,
+                                                                                   IMG_UINT32 uDevVAddrAlignment,
+                                                                                   IMG_DEV_VIRTADDR *pDevVAddr);
+        IMG_VOID                                (*pfnMMUFree)(MMU_HEAP*,IMG_DEV_VIRTADDR,IMG_UINT32);
+        IMG_VOID                                (*pfnMMUEnable)(MMU_HEAP*);
+        IMG_VOID                                (*pfnMMUDisable)(MMU_HEAP*);
+        IMG_VOID                                (*pfnMMUMapPages)(MMU_HEAP *pMMU,
+                                                                                          IMG_DEV_VIRTADDR devVAddr,
+                                                                                          IMG_SYS_PHYADDR SysPAddr,
+                                                                                          IMG_SIZE_T uSize,
+                                                                                          IMG_UINT32 ui32MemFlags,
+                                                                                          IMG_HANDLE hUniqueTag);
+        IMG_VOID                                (*pfnMMUMapShadow)(MMU_HEAP            *pMMU,
+                                                                                           IMG_DEV_VIRTADDR    MapBaseDevVAddr,
+                                                                                           IMG_SIZE_T          uSize, 
+                                                                                           IMG_CPU_VIRTADDR    CpuVAddr,
+                                                                                           IMG_HANDLE          hOSMemHandle,
+                                                                                           IMG_DEV_VIRTADDR    *pDevVAddr,
+                                                                                           IMG_UINT32 ui32MemFlags,
+                                                                                           IMG_HANDLE hUniqueTag);
+        IMG_VOID                                (*pfnMMUUnmapPages)(MMU_HEAP *pMMU,
+                                                                                                IMG_DEV_VIRTADDR dev_vaddr,
+                                                                                                IMG_UINT32 ui32PageCount,
+                                                                                                IMG_HANDLE hUniqueTag);
+
+        IMG_VOID                                (*pfnMMUMapScatter)(MMU_HEAP *pMMU,
+                                                                                                IMG_DEV_VIRTADDR DevVAddr,
+                                                                                                IMG_SYS_PHYADDR *psSysAddr,
+                                                                                                IMG_SIZE_T uSize,
+                                                                                                IMG_UINT32 ui32MemFlags,
+                                                                                                IMG_HANDLE hUniqueTag);
+
+        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;
+        
+        IMG_UINT32                              ui32SOCInterruptBit;
+        
+        IMG_VOID                                (*pfnDeviceMISR)(IMG_VOID*);
+
+        
+        IMG_VOID                                (*pfnDeviceCommandComplete)(struct _PVRSRV_DEVICE_NODE_ *psDeviceNode);
+        
+        IMG_BOOL                                bReProcessDeviceCommandComplete;
+        
+        
+        DEVICE_MEMORY_INFO              sDevMemoryInfo;
+
+        
+        IMG_VOID                                *pvDevice;
+        IMG_UINT32                              ui32pvDeviceSize; 
+                
+        
+        PRESMAN_CONTEXT                 hResManContext;
+        
+        
+        PSYS_DATA                               psSysData;
+        
+        
+        RA_ARENA                                *psLocalDevMemArena;
+        
+        IMG_UINT32                              ui32Flags;
+        
+        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_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*),
+                                                                                          IMG_UINT32 ui32SOCInterruptBit,
+                                                                                          IMG_UINT32 *pui32DeviceIndex );
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInitialiseDevice(IMG_UINT32 ui32DevIndex);
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFinaliseSystem(IMG_BOOL bInitSuccesful);
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDevInitCompatCheck(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDeinitialiseDevice(IMG_UINT32 ui32DevIndex);
+
+#if !defined(USE_CODE)
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PollForValueKM(volatile IMG_UINT32* pui32LinMemAddr,
+                                                                                                   IMG_UINT32 ui32Value,
+                                                                                                   IMG_UINT32 ui32Mask,
+                                                                                                   IMG_UINT32 ui32Waitus,
+                                                                                                   IMG_UINT32 ui32Tries);
+
+#endif 
+
+
+#if defined (USING_ISR_INTERRUPTS)
+PVRSRV_ERROR IMG_CALLCONV PollForInterruptKM(IMG_UINT32 ui32Value,
+                                                                IMG_UINT32 ui32Mask,
+                                                                IMG_UINT32 ui32Waitus,
+                                                                IMG_UINT32 ui32Tries);
+#endif 
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInit(PSYS_DATA psSysData);
+IMG_VOID IMG_CALLCONV PVRSRVDeInit(PSYS_DATA psSysData);
+IMG_BOOL IMG_CALLCONV PVRSRVDeviceLISR(PVRSRV_DEVICE_NODE *psDeviceNode);
+IMG_BOOL IMG_CALLCONV PVRSRVSystemLISR(IMG_VOID *pvSysData);
+IMG_VOID IMG_CALLCONV PVRSRVMISR(IMG_VOID *pvSysData);
+
+#if defined(__cplusplus)
+}
+#endif
+        
+#endif 
+
diff --git a/drivers/gpu/pvr/deviceclass.c b/drivers/gpu/pvr/deviceclass.c
new file mode 100644
index 00000000000..869253b2ecb
--- /dev/null
+++ b/drivers/gpu/pvr/deviceclass.c
@@ -0,0 +1,2012 @@
+/**********************************************************************
+ *
+ * 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 "buffer_manager.h"
+#include "kernelbuffer.h"
+#include "kerneldisplay.h"
+#include "pvr_bridge_km.h"
+#include "pdump_km.h"
+#include "deviceid.h"
+
+#include "lists.h"
+
+PVRSRV_ERROR AllocateDeviceID(SYS_DATA *psSysData, IMG_UINT32 *pui32DevID);
+PVRSRV_ERROR FreeDeviceID(SYS_DATA *psSysData, IMG_UINT32 ui32DevID);
+
+#if defined(SUPPORT_MISR_IN_THREAD)
+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
+{
+        
+        PVRSRV_DEVICECLASS_BUFFER sDeviceClassBuffer;
+
+        struct PVRSRV_DISPLAYCLASS_INFO_TAG *psDCInfo;
+        struct PVRSRV_DC_SWAPCHAIN_TAG *psSwapChain;
+} PVRSRV_DC_BUFFER;
+
+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;
+        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;
+        IMG_UINT32                                                      ui32DeviceID;
+        IMG_HANDLE                                                      hExtDevice;
+        PPVRSRV_DC_SRV2DISP_KMJTABLE            psFuncTable;
+        IMG_HANDLE                                                      hDevMemContext;
+        PVRSRV_DC_BUFFER                                        sSystemBuffer;
+        struct PVRSRV_DC_SWAPCHAIN_TAG          *psDCSwapChainShared;
+} PVRSRV_DISPLAYCLASS_INFO;
+
+
+typedef struct PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO_TAG
+{
+        PVRSRV_DISPLAYCLASS_INFO                        *psDCInfo;
+        PRESMAN_ITEM                                            hResItem;
+} PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO;
+
+
+typedef struct PVRSRV_BC_SRV2BUFFER_KMJTABLE_TAG *PPVRSRV_BC_SRV2BUFFER_KMJTABLE;
+
+typedef struct PVRSRV_BC_BUFFER_TAG
+{
+        
+        PVRSRV_DEVICECLASS_BUFFER sDeviceClassBuffer;
+
+        struct PVRSRV_BUFFERCLASS_INFO_TAG *psBCInfo;
+} PVRSRV_BC_BUFFER;
+
+
+typedef struct PVRSRV_BUFFERCLASS_INFO_TAG
+{
+        IMG_UINT32                                                      ui32RefCount;
+        IMG_UINT32                                                      ui32DeviceID;
+        IMG_HANDLE                                                      hExtDevice;
+        PPVRSRV_BC_SRV2BUFFER_KMJTABLE          psFuncTable;
+        IMG_HANDLE                                                      hDevMemContext;
+        
+        IMG_UINT32                                                      ui32BufferCount;
+        PVRSRV_BC_BUFFER                                        *psBuffer;
+
+} PVRSRV_BUFFERCLASS_INFO;
+
+
+typedef struct PVRSRV_BUFFERCLASS_PERCONTEXT_INFO_TAG
+{
+        PVRSRV_BUFFERCLASS_INFO                         *psBCInfo;
+        IMG_HANDLE                                                      hResItem;
+} PVRSRV_BUFFERCLASS_PERCONTEXT_INFO;
+
+
+static PVRSRV_DISPLAYCLASS_INFO* DCDeviceHandleToDCInfo (IMG_HANDLE hDeviceKM)
+{
+        PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
+
+        psDCPerContextInfo = (PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *)hDeviceKM;
+
+        return psDCPerContextInfo->psDCInfo;
+}
+
+
+static PVRSRV_BUFFERCLASS_INFO* BCDeviceHandleToBCInfo (IMG_HANDLE hDeviceKM)
+{
+        PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *psBCPerContextInfo;
+
+        psBCPerContextInfo = (PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *)hDeviceKM;
+
+        return psBCPerContextInfo->psBCInfo;
+}
+
+static IMG_VOID PVRSRVEnumerateDCKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+{
+        IMG_UINT *pui32DevCount;
+        IMG_UINT32 **ppui32DevID;
+        PVRSRV_DEVICE_CLASS peDeviceClass;
+
+        pui32DevCount = va_arg(va, IMG_UINT*);
+        ppui32DevID = va_arg(va, IMG_UINT32**);
+        peDeviceClass = va_arg(va, PVRSRV_DEVICE_CLASS);
+
+        if      ((psDeviceNode->sDevId.eDeviceClass == peDeviceClass)
+        &&      (psDeviceNode->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_EXT))
+        {
+                (*pui32DevCount)++;
+                if(*ppui32DevID)
+                {
+                        *(*ppui32DevID)++ = psDeviceNode->sDevId.ui32DeviceIndex;
+                }
+        }
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVEnumerateDCKM (PVRSRV_DEVICE_CLASS DeviceClass,
+                                                                  IMG_UINT32 *pui32DevCount,
+                                                                  IMG_UINT32 *pui32DevID )
+{
+        
+        IMG_UINT                        ui32DevCount = 0;
+        SYS_DATA                        *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        
+        List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+                                                                                &PVRSRVEnumerateDCKM_ForEachVaCb,
+                                                                                &ui32DevCount,
+                                                                                &pui32DevID,
+                                                                                DeviceClass);
+
+        if(pui32DevCount)
+        {
+                *pui32DevCount = ui32DevCount;
+        }
+        else if(pui32DevID == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDCKM: Invalid parameters"));
+                return (PVRSRV_ERROR_INVALID_PARAMS);
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static
+PVRSRV_ERROR PVRSRVRegisterDCDeviceKM (PVRSRV_DC_SRV2DISP_KMJTABLE *psFuncTable,
+                                                                           IMG_UINT32 *pui32DeviceID)
+{
+        PVRSRV_DISPLAYCLASS_INFO        *psDCInfo = IMG_NULL;
+        PVRSRV_DEVICE_NODE                      *psDeviceNode;
+        SYS_DATA                                        *psSysData;
+
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        SysAcquireData(&psSysData);
+
+        
+
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(*psDCInfo),
+                                         (IMG_VOID **)&psDCInfo, IMG_NULL,
+                                         "Display Class Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psDCInfo alloc"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+        OSMemSet (psDCInfo, 0, sizeof(*psDCInfo));
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         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;
+        }
+        OSMemSet (psDCInfo->psFuncTable, 0, sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE));
+
+        
+        *psDCInfo->psFuncTable = *psFuncTable;
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(PVRSRV_DEVICE_NODE),
+                                         (IMG_VOID **)&psDeviceNode, IMG_NULL,
+                                         "Device Node") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDCDeviceKM: Failed psDeviceNode alloc"));
+                goto ErrorExit;
+        }
+        OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
+
+        psDeviceNode->pvDevice = (IMG_VOID*)psDCInfo;
+        psDeviceNode->ui32pvDeviceSize = sizeof(*psDCInfo);
+        psDeviceNode->ui32RefCount = 1;
+        psDeviceNode->sDevId.eDeviceType = PVRSRV_DEVICE_TYPE_EXT;
+        psDeviceNode->sDevId.eDeviceClass = PVRSRV_DEVICE_CLASS_DISPLAY;
+        psDeviceNode->psSysData = psSysData;
+
+        
+        if (AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to allocate Device ID"));
+                goto ErrorExit;
+        }
+        psDCInfo->ui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
+        if (pui32DeviceID)
+        {
+                *pui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
+        }
+
+        
+        SysRegisterExternalDevice(psDeviceNode);
+
+        
+        List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        if(psDCInfo->psFuncTable)
+        {
+                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;
+}
+
+static PVRSRV_ERROR PVRSRVRemoveDCDeviceKM(IMG_UINT32 ui32DevIndex)
+{
+        SYS_DATA                                        *psSysData;
+        PVRSRV_DEVICE_NODE                      *psDeviceNode;
+        PVRSRV_DISPLAYCLASS_INFO        *psDCInfo;
+
+        SysAcquireData(&psSysData);
+
+        
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)
+                List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                           &MatchDeviceKM_AnyVaCb,
+                                                                           ui32DevIndex,
+                                                                           IMG_FALSE,
+                                                                           PVRSRV_DEVICE_CLASS_DISPLAY);
+        if (!psDeviceNode)
+        {
+                
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: requested device %d not present", ui32DevIndex));
+                return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
+        }
+
+        
+        psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
+
+        
+
+
+        if(psDCInfo->ui32RefCount == 0)
+        {
+                
+
+                List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
+
+                
+                SysRemoveExternalDevice(psDeviceNode);
+
+                
+
+
+                PVR_ASSERT(psDCInfo->ui32RefCount == 0);
+                (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SRV2DISP_KMJTABLE), psDCInfo->psFuncTable, IMG_NULL);
+                psDCInfo->psFuncTable = IMG_NULL;
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_INFO), psDCInfo, IMG_NULL);
+                
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
+                
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveDCDeviceKM: failed as %d Services DC API connections are still open", psDCInfo->ui32RefCount));
+                return PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static
+PVRSRV_ERROR PVRSRVRegisterBCDeviceKM (PVRSRV_BC_SRV2BUFFER_KMJTABLE *psFuncTable,
+                                                                           IMG_UINT32   *pui32DeviceID)
+{
+        PVRSRV_BUFFERCLASS_INFO *psBCInfo = IMG_NULL;
+        PVRSRV_DEVICE_NODE              *psDeviceNode;
+        SYS_DATA                                *psSysData;
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+        SysAcquireData(&psSysData);
+
+        
+
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(*psBCInfo),
+                                         (IMG_VOID **)&psBCInfo, IMG_NULL,
+                                         "Buffer Class Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psBCInfo alloc"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+        OSMemSet (psBCInfo, 0, sizeof(*psBCInfo));
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE),
+                                         (IMG_VOID **)&psBCInfo->psFuncTable, IMG_NULL,
+                                         "Function table for SRVKM->BUFFER") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psFuncTable alloc"));
+                goto ErrorExit;
+        }
+        OSMemSet (psBCInfo->psFuncTable, 0, sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE));
+
+        
+        *psBCInfo->psFuncTable = *psFuncTable;
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(PVRSRV_DEVICE_NODE),
+                                         (IMG_VOID **)&psDeviceNode, IMG_NULL,
+                                         "Device Node") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed psDeviceNode alloc"));
+                goto ErrorExit;
+        }
+        OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE));
+
+        psDeviceNode->pvDevice = (IMG_VOID*)psBCInfo;
+        psDeviceNode->ui32pvDeviceSize = sizeof(*psBCInfo);
+        psDeviceNode->ui32RefCount = 1;
+        psDeviceNode->sDevId.eDeviceType = PVRSRV_DEVICE_TYPE_EXT;
+        psDeviceNode->sDevId.eDeviceClass = PVRSRV_DEVICE_CLASS_BUFFER;
+        psDeviceNode->psSysData = psSysData;
+
+        
+        if (AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterBCDeviceKM: Failed to allocate Device ID"));
+                goto ErrorExit;
+        }
+        psBCInfo->ui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
+        if (pui32DeviceID)
+        {
+                *pui32DeviceID = psDeviceNode->sDevId.ui32DeviceIndex;
+        }
+
+        
+        List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode);
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        if(psBCInfo->psFuncTable)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PPVRSRV_BC_SRV2BUFFER_KMJTABLE), psBCInfo->psFuncTable, IMG_NULL);
+                psBCInfo->psFuncTable = IMG_NULL;
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_INFO), psBCInfo, IMG_NULL);
+        
+
+        return PVRSRV_ERROR_OUT_OF_MEMORY;
+}
+
+
+static PVRSRV_ERROR PVRSRVRemoveBCDeviceKM(IMG_UINT32 ui32DevIndex)
+{
+        SYS_DATA                                        *psSysData;
+        PVRSRV_DEVICE_NODE                      *psDevNode;
+        PVRSRV_BUFFERCLASS_INFO         *psBCInfo;
+
+        SysAcquireData(&psSysData);
+
+        
+        psDevNode = (PVRSRV_DEVICE_NODE*)
+                List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                           &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_NO_DEVICENODE_FOUND;
+        }
+
+        
+        
+        psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDevNode->pvDevice;
+
+        
+
+
+        if(psBCInfo->ui32RefCount == 0)
+        {
+                
+
+                List_PVRSRV_DEVICE_NODE_Remove(psDevNode);
+
+                
+
+
+                (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+                
+                
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_SRV2BUFFER_KMJTABLE), psBCInfo->psFuncTable, IMG_NULL);
+                psBCInfo->psFuncTable = IMG_NULL;
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_INFO), psBCInfo, IMG_NULL);
+                
+                (IMG_VOID)OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDevNode, IMG_NULL);
+                
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRemoveBCDeviceKM: failed as %d Services BC API connections are still open", psBCInfo->ui32RefCount));
+                return PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVCloseDCDeviceKM (IMG_HANDLE  hDeviceKM,
+                                                                        IMG_BOOL        bResManCallback)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
+
+        PVR_UNREFERENCED_PARAMETER(bResManCallback);
+
+        psDCPerContextInfo = (PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *)hDeviceKM;
+
+        
+        eError = ResManFreeResByPtr(psDCPerContextInfo->hResItem);
+
+        return eError;
+}
+
+
+static PVRSRV_ERROR CloseDCDeviceCallBack(IMG_PVOID             pvParam,
+                                                                                  IMG_UINT32    ui32Param)
+{
+        PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        psDCPerContextInfo = (PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *)pvParam;
+        psDCInfo = psDCPerContextInfo->psDCInfo;
+
+        psDCInfo->ui32RefCount--;
+        if(psDCInfo->ui32RefCount == 0)
+        {
+                
+                psDCInfo->psFuncTable->pfnCloseDCDevice(psDCInfo->hExtDevice);
+
+                if (--psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+                {
+                        PVRSRVFreeSyncInfoKM(psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
+                }
+
+                psDCInfo->hDevMemContext = IMG_NULL;
+                psDCInfo->hExtDevice = IMG_NULL;
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO), psDCPerContextInfo, IMG_NULL);
+        
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVOpenDCDeviceKM (PVRSRV_PER_PROCESS_DATA      *psPerProc,
+                                                                   IMG_UINT32                           ui32DeviceID,
+                                                                   IMG_HANDLE                           hDevCookie,
+                                                                   IMG_HANDLE                           *phDeviceKM)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
+        PVRSRV_DEVICE_NODE      *psDeviceNode;
+        SYS_DATA                        *psSysData;
+        PVRSRV_ERROR eError;
+
+        if(!phDeviceKM || !hDevCookie)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Invalid params"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        SysAcquireData(&psSysData);
+
+        
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)
+                        List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                   &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_NO_DEVICENODE_FOUND;
+        }
+        psDCInfo = (PVRSRV_DISPLAYCLASS_INFO*)psDeviceNode->pvDevice;
+
+        
+
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(*psDCPerContextInfo),
+                                  (IMG_VOID **)&psDCPerContextInfo, IMG_NULL,
+                                  "Display Class per Context Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Failed psDCPerContextInfo alloc"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+        OSMemSet(psDCPerContextInfo, 0, sizeof(*psDCPerContextInfo));
+
+        if(psDCInfo->ui32RefCount++ == 0)
+        {
+
+                psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
+
+                
+                psDCInfo->hDevMemContext = (IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext;
+
+                
+                eError = PVRSRVAllocSyncInfoKM(IMG_NULL,
+                                                                        (IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext,
+                                                                        &psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Failed sync info alloc"));
+                        psDCInfo->ui32RefCount--;
+                        return eError;
+                }
+
+                
+                eError = psDCInfo->psFuncTable->pfnOpenDCDevice(ui32DeviceID,
+                                                                &psDCInfo->hExtDevice,
+                                                                (PVRSRV_SYNC_DATA*)psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenDCDeviceKM: Failed to open external DC device"));
+                        psDCInfo->ui32RefCount--;
+                        PVRSRVFreeSyncInfoKM(psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo);
+                        return eError;
+                }
+
+                psDCInfo->sSystemBuffer.sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
+        }
+
+        psDCPerContextInfo->psDCInfo = psDCInfo;
+        psDCPerContextInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                                                         RESMAN_TYPE_DISPLAYCLASS_DEVICE,
+                                                                                                         psDCPerContextInfo,
+                                                                                                         0,
+                                                                                                         &CloseDCDeviceCallBack);
+
+        
+        *phDeviceKM = (IMG_HANDLE)psDCPerContextInfo;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVEnumDCFormatsKM (IMG_HANDLE hDeviceKM,
+                                                                        IMG_UINT32 *pui32Count,
+                                                                        DISPLAY_FORMAT *psFormat)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+
+        if(!hDeviceKM || !pui32Count || !psFormat)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumDCFormatsKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
+        
+        return psDCInfo->psFuncTable->pfnEnumDCFormats(psDCInfo->hExtDevice, pui32Count, psFormat);
+}
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVEnumDCDimsKM (IMG_HANDLE hDeviceKM,
+                                                                 DISPLAY_FORMAT *psFormat,
+                                                                 IMG_UINT32 *pui32Count,
+                                                                 DISPLAY_DIMS *psDim)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+
+        if(!hDeviceKM || !pui32Count || !psFormat)      
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumDCDimsKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
+        
+        return psDCInfo->psFuncTable->pfnEnumDCDims(psDCInfo->hExtDevice, psFormat, pui32Count, psDim);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVGetDCSystemBufferKM (IMG_HANDLE hDeviceKM,
+                                                                                IMG_HANDLE *phBuffer)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        IMG_HANDLE hExtBuffer;
+
+        if(!hDeviceKM || !phBuffer)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCSystemBufferKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
+        
+        eError = psDCInfo->psFuncTable->pfnGetDCSystemBuffer(psDCInfo->hExtDevice, &hExtBuffer);
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCSystemBufferKM: Failed to get valid buffer handle from external driver"));
+                return eError;
+        }
+
+        
+        psDCInfo->sSystemBuffer.sDeviceClassBuffer.pfnGetBufferAddr = psDCInfo->psFuncTable->pfnGetBufferAddr;
+        psDCInfo->sSystemBuffer.sDeviceClassBuffer.hDevMemContext = psDCInfo->hDevMemContext;
+        psDCInfo->sSystemBuffer.sDeviceClassBuffer.hExtDevice = psDCInfo->hExtDevice;
+        psDCInfo->sSystemBuffer.sDeviceClassBuffer.hExtBuffer = hExtBuffer;
+
+        psDCInfo->sSystemBuffer.psDCInfo = psDCInfo;
+
+        
+        *phBuffer = (IMG_HANDLE)&(psDCInfo->sSystemBuffer);
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVGetDCInfoKM (IMG_HANDLE hDeviceKM,
+                                                                DISPLAY_INFO *psDisplayInfo)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_ERROR eError;
+
+        if(!hDeviceKM || !psDisplayInfo)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCInfoKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+
+        
+        eError = psDCInfo->psFuncTable->pfnGetDCInfo(psDCInfo->hExtDevice, psDisplayInfo);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        if (psDisplayInfo->ui32MaxSwapChainBuffers > PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS)
+        {
+                psDisplayInfo->ui32MaxSwapChainBuffers = PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(IMG_HANDLE hSwapChainRef)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_DC_SWAPCHAIN_REF *psSwapChainRef;
+
+        if(!hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDestroyDCSwapChainKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psSwapChainRef = hSwapChainRef;
+
+        eError = ResManFreeResByPtr(psSwapChainRef->hResItem);
+
+        return eError;
+}
+
+
+static PVRSRV_ERROR DestroyDCSwapChain(PVRSRV_DC_SWAPCHAIN *psSwapChain)
+{
+        PVRSRV_ERROR                            eError;
+        PVRSRV_DISPLAYCLASS_INFO        *psDCInfo = psSwapChain->psDCInfo;
+        IMG_UINT32 i;
+
+
+        
+        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);
+
+        
+        eError = psDCInfo->psFuncTable->pfnDestroyDCSwapChain(psDCInfo->hExtDevice,
+                                                                                                                        psSwapChain->hExtSwapChain);
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DestroyDCSwapChainCallBack: Failed to destroy DC swap chain"));
+                return eError;
+        }
+
+        
+        for(i=0; i<psSwapChain->ui32BufferCount; i++)
+        {
+                if(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
+                {
+                        if (--psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+                        {
+                                PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+                        }
+                }
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL);
+        
+
+        return eError;
+}
+
+
+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,
+                                                                                IMG_HANDLE                              hDeviceKM,
+                                                                                IMG_UINT32                              ui32Flags,
+                                                                                DISPLAY_SURF_ATTRIBUTES *psDstSurfAttrib,
+                                                                                DISPLAY_SURF_ATTRIBUTES *psSrcSurfAttrib,
+                                                                                IMG_UINT32                              ui32BufferCount,
+                                                                                IMG_UINT32                              ui32OEMFlags,
+                                                                                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
+        || !phSwapChainRef
+        || !pui32SwapChainID)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if (ui32BufferCount > PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Too many buffers"));
+                return PVRSRV_ERROR_TOOMANYBUFFERS;
+        }
+
+        if (ui32BufferCount < 2)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Too few buffers"));
+                return PVRSRV_ERROR_TOO_FEW_BUFFERS;
+        }
+
+        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)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed psSwapChain alloc"));
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorExit;
+        }
+        OSMemSet (psSwapChain, 0, sizeof(PVRSRV_DC_SWAPCHAIN));
+
+        
+        eError = PVRSRVCreateCommandQueueKM(1024, &psQueue);
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed to create CmdQueue"));
+                goto ErrorExit;
+        }
+
+        
+        psSwapChain->psQueue = psQueue;
+
+        
+        for(i=0; i<ui32BufferCount; i++)
+        {
+                eError = PVRSRVAllocSyncInfoKM(IMG_NULL,
+                                                                                psDCInfo->hDevMemContext,
+                                                                                &psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDCSwapChainKM: Failed to alloc syninfo for psSwapChain"));
+                        goto ErrorExit;
+                }
+
+                psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
+
+                
+                psSwapChain->asBuffer[i].sDeviceClassBuffer.pfnGetBufferAddr = psDCInfo->psFuncTable->pfnGetBufferAddr;
+                psSwapChain->asBuffer[i].sDeviceClassBuffer.hDevMemContext = psDCInfo->hDevMemContext;
+                psSwapChain->asBuffer[i].sDeviceClassBuffer.hExtDevice = psDCInfo->hExtDevice;
+
+                
+                psSwapChain->asBuffer[i].psDCInfo = psDCInfo;
+                psSwapChain->asBuffer[i].psSwapChain = psSwapChain;
+
+                
+                apsSyncData[i] = (PVRSRV_SYNC_DATA*)psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM;
+        }
+
+        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,
+                                                                                                                psDstSurfAttrib,
+                                                                                                                psSrcSurfAttrib,
+                                                                                                                ui32BufferCount,
+                                                                                                                apsSyncData,
+                                                                                                                ui32OEMFlags,
+                                                                                                                &psSwapChain->hExtSwapChain,
+                                                                                                                &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;
+
+        
+        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;
+
+        
+        *phSwapChainRef= (IMG_HANDLE)psSwapChainRef;
+
+        return eError;
+
+ErrorExit:
+
+        for(i=0; i<ui32BufferCount; i++)
+        {
+                if(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo)
+                {
+                        if (--psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount == 0)
+                        {
+                                PVRSRVFreeSyncInfoKM(psSwapChain->asBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+                        }
+                }
+        }
+
+        if(psQueue)
+        {
+                PVRSRVDestroyCommandQueueKM(psQueue);
+        }
+
+        if(psSwapChain)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_DC_SWAPCHAIN), psSwapChain, IMG_NULL);
+                
+        }
+
+        return eError;
+}
+
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetDCDstRectKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChainRef,
+                                                                  IMG_RECT              *psRect)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_SWAPCHAIN *psSwapChain;
+
+        if(!hDeviceKM || !hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCDstRectKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
+
+        return psDCInfo->psFuncTable->pfnSetDCDstRect(psDCInfo->hExtDevice,
+                                                                                                        psSwapChain->hExtSwapChain,
+                                                                                                        psRect);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetDCSrcRectKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChainRef,
+                                                                  IMG_RECT              *psRect)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_SWAPCHAIN *psSwapChain;
+
+        if(!hDeviceKM || !hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCSrcRectKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
+
+        return psDCInfo->psFuncTable->pfnSetDCSrcRect(psDCInfo->hExtDevice,
+                                                                                                        psSwapChain->hExtSwapChain,
+                                                                                                        psRect);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetDCDstColourKeyKM(IMG_HANDLE       hDeviceKM,
+                                                                           IMG_HANDLE   hSwapChainRef,
+                                                                           IMG_UINT32   ui32CKColour)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_SWAPCHAIN *psSwapChain;
+
+        if(!hDeviceKM || !hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCDstColourKeyKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
+
+        return psDCInfo->psFuncTable->pfnSetDCDstColourKey(psDCInfo->hExtDevice,
+                                                                                                                psSwapChain->hExtSwapChain,
+                                                                                                                ui32CKColour);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetDCSrcColourKeyKM(IMG_HANDLE       hDeviceKM,
+                                                                           IMG_HANDLE   hSwapChainRef,
+                                                                           IMG_UINT32   ui32CKColour)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_SWAPCHAIN *psSwapChain;
+
+        if(!hDeviceKM || !hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSetDCSrcColourKeyKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
+
+        return psDCInfo->psFuncTable->pfnSetDCSrcColourKey(psDCInfo->hExtDevice,
+                                                                                                                psSwapChain->hExtSwapChain,
+                                                                                                                ui32CKColour);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVGetDCBuffersKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChainRef,
+                                                                  IMG_UINT32    *pui32BufferCount,
+                                                                  IMG_HANDLE    *phBuffer)
+{
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_SWAPCHAIN *psSwapChain;
+        IMG_HANDLE ahExtBuffer[PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS];
+        PVRSRV_ERROR eError;
+        IMG_UINT32 i;
+
+        if(!hDeviceKM || !hSwapChainRef || !phBuffer)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetDCBuffersKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        psSwapChain = ((PVRSRV_DC_SWAPCHAIN_REF*)hSwapChainRef)->psSwapChain;
+
+        
+        eError = psDCInfo->psFuncTable->pfnGetDCBuffers(psDCInfo->hExtDevice,
+                                                                                                        psSwapChain->hExtSwapChain,
+                                                                                                        pui32BufferCount,
+                                                                                                        ahExtBuffer);
+
+        PVR_ASSERT(*pui32BufferCount <= PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
+
+        
+
+
+        for(i=0; i<*pui32BufferCount; i++)
+        {
+                psSwapChain->asBuffer[i].sDeviceClassBuffer.hExtBuffer = ahExtBuffer[i];
+                phBuffer[i] = (IMG_HANDLE)&psSwapChain->asBuffer[i];
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSwapToDCBufferKM(IMG_HANDLE  hDeviceKM,
+                                                                        IMG_HANDLE      hBuffer,
+                                                                        IMG_UINT32      ui32SwapInterval,
+                                                                        IMG_HANDLE      hPrivateTag,
+                                                                        IMG_UINT32      ui32ClipRectCount,
+                                                                        IMG_RECT        *psClipRect)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_DISPLAYCLASS_INFO *psDCInfo;
+        PVRSRV_DC_BUFFER *psBuffer;
+        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;
+
+        if(!hDeviceKM || !hBuffer || !psClipRect)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+#if defined(SUPPORT_LMA)
+        eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+#endif 
+
+        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(bAddReferenceToLast && psBuffer->psSwapChain->psLastFlipBuffer &&
+                psBuffer != psBuffer->psSwapChain->psLastFlipBuffer)
+        {
+                apsSrcSync[1] = psBuffer->psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo;
+                
+
+
+                ui32NumSrcSyncs++;
+        }
+
+        
+        eError = PVRSRVInsertCommandKM (psQueue,
+                                                                        &psCommand,
+                                                                        psDCInfo->ui32DeviceID,
+                                                                        ui16SwapCommandID,
+                                                                        0,
+                                                                        IMG_NULL,
+                                                                        ui32NumSrcSyncs,
+                                                                        apsSrcSync,
+                                                                        sizeof(DISPLAYCLASS_FLIP_COMMAND) + (sizeof(IMG_RECT) * ui32ClipRectCount));
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to get space in queue"));
+                goto Exit;
+        }
+
+        
+        psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)psCommand->pvData;
+
+        
+        psFlipCmd->hExtDevice = psDCInfo->hExtDevice;
+
+        
+        psFlipCmd->hExtSwapChain = psBuffer->psSwapChain->hExtSwapChain;
+
+        
+        psFlipCmd->hExtBuffer = psBuffer->sDeviceClassBuffer.hExtBuffer;
+
+        
+        psFlipCmd->hPrivateTag = hPrivateTag;
+
+        
+        psFlipCmd->ui32ClipRectCount = ui32ClipRectCount;
+        
+        psFlipCmd->psClipRect = (IMG_RECT*)((IMG_UINT8*)psFlipCmd + sizeof(DISPLAYCLASS_FLIP_COMMAND)); 
+        
+        for(i=0; i<ui32ClipRectCount; i++)
+        {
+                psFlipCmd->psClipRect[i] = psClipRect[i];
+        }
+
+        
+        psFlipCmd->ui32SwapInterval = ui32SwapInterval;
+
+        
+        eError = PVRSRVSubmitCommandKM (psQueue, psCommand);
+        if (eError != PVRSRV_OK)
+        {
+                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)
+                {
+                        goto ProcessedQueues;
+                }
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+        } END_LOOP_UNTIL_TIMEOUT();
+
+        PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCBufferKM: Failed to process queues"));
+
+        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
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSwapToDCSystemKM(IMG_HANDLE  hDeviceKM,
+                                                                        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 || !hSwapChainRef)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+#if defined(SUPPORT_LMA)
+        eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+#endif 
+
+        psDCInfo = DCDeviceHandleToDCInfo(hDeviceKM);
+        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(bAddReferenceToLast && psSwapChain->psLastFlipBuffer)
+        {
+                
+                if (apsSrcSync[0] != psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo)
+                {
+                        apsSrcSync[1] = psSwapChain->psLastFlipBuffer->sDeviceClassBuffer.psKernelSyncInfo;
+                        
+
+
+                        ui32NumSrcSyncs++;
+                }
+        }
+
+        
+        eError = PVRSRVInsertCommandKM (psQueue,
+                                                                        &psCommand,
+                                                                        psDCInfo->ui32DeviceID,
+                                                                        ui16SwapCommandID,
+                                                                        0,
+                                                                        IMG_NULL,
+                                                                        ui32NumSrcSyncs,
+                                                                        apsSrcSync,
+                                                                        sizeof(DISPLAYCLASS_FLIP_COMMAND));
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Failed to get space in queue"));
+                goto Exit;
+        }
+
+        
+        psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)psCommand->pvData;
+
+        
+        psFlipCmd->hExtDevice = psDCInfo->hExtDevice;
+
+        
+        psFlipCmd->hExtSwapChain = psSwapChain->hExtSwapChain;
+
+        
+        psFlipCmd->hExtBuffer = psDCInfo->sSystemBuffer.sDeviceClassBuffer.hExtBuffer;
+
+        
+        psFlipCmd->hPrivateTag = IMG_NULL;
+
+        
+        psFlipCmd->ui32ClipRectCount = 0;
+
+        psFlipCmd->ui32SwapInterval = 1;
+
+        
+        eError = PVRSRVSubmitCommandKM (psQueue, psCommand);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Failed to submit command"));
+                goto Exit;
+        }
+
+        
+
+
+
+
+
+
+         
+        LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+        {
+                if(PVRSRVProcessQueues(KERNEL_ID, IMG_FALSE) != PVRSRV_ERROR_PROCESSING_BLOCKED)
+                {
+                        goto ProcessedQueues;
+                }
+
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+        } END_LOOP_UNTIL_TIMEOUT();
+
+        PVR_DPF((PVR_DBG_ERROR,"PVRSRVSwapToDCSystemKM: Failed to process queues"));
+        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
+        return eError;
+}
+
+
+static
+PVRSRV_ERROR PVRSRVRegisterSystemISRHandler (PFN_ISR_HANDLER    pfnISRHandler,
+                                                                                         IMG_VOID                       *pvISRHandlerData,
+                                                                                         IMG_UINT32                     ui32ISRSourceMask,
+                                                                                         IMG_UINT32                     ui32DeviceID)
+{
+        SYS_DATA                        *psSysData;
+        PVRSRV_DEVICE_NODE      *psDevNode;
+
+        PVR_UNREFERENCED_PARAMETER(ui32ISRSourceMask);
+
+        SysAcquireData(&psSysData);
+
+        
+        psDevNode = (PVRSRV_DEVICE_NODE*)
+                                List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                                &MatchDeviceKM_AnyVaCb,
+                                                                                                ui32DeviceID,
+                                                                                                IMG_TRUE);
+
+        if (psDevNode == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterSystemISRHandler: Failed to get psDevNode"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_NO_DEVICENODE_FOUND;
+        }
+
+        
+        psDevNode->pvISRData = (IMG_VOID*) pvISRHandlerData;
+
+        
+        psDevNode->pfnDeviceISR = pfnISRHandler;
+
+        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);
+                }
+        }
+}
+
+
+IMG_VOID IMG_CALLCONV PVRSRVSetDCState(IMG_UINT32 ui32State)
+{
+        SYS_DATA                                        *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+                                                                                &PVRSRVSetDCState_ForEachVaCb,
+                                                                                ui32State);
+}
+
+
+IMG_EXPORT
+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;
+#if defined(SUPPORT_MISR_IN_THREAD)
+        psJTable->pfnPVRSRVCmdComplete = &OSVSyncMISR;
+#else
+        psJTable->pfnPVRSRVCmdComplete = &PVRSRVCommandCompleteKM;
+#endif
+        psJTable->pfnPVRSRVRegisterSystemISRHandler = &PVRSRVRegisterSystemISRHandler;
+        psJTable->pfnPVRSRVRegisterPowerDevice = &PVRSRVRegisterPowerDevice;
+#if defined(SUPPORT_CUSTOM_SWAP_OPERATIONS)
+        psJTable->pfnPVRSRVFreeCmdCompletePacket = &PVRSRVFreeCommandCompletePacketKM;
+#endif
+
+        return IMG_TRUE;
+}
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVCloseBCDeviceKM (IMG_HANDLE  hDeviceKM,
+                                                                        IMG_BOOL        bResManCallback)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *psBCPerContextInfo;
+
+        PVR_UNREFERENCED_PARAMETER(bResManCallback);
+
+        psBCPerContextInfo = (PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *)hDeviceKM;
+
+        
+        eError = ResManFreeResByPtr(psBCPerContextInfo->hResItem);
+
+        return eError;
+}
+
+
+static PVRSRV_ERROR CloseBCDeviceCallBack(IMG_PVOID             pvParam,
+                                                                                  IMG_UINT32    ui32Param)
+{
+        PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *psBCPerContextInfo;
+        PVRSRV_BUFFERCLASS_INFO *psBCInfo;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        psBCPerContextInfo = (PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *)pvParam;
+        psBCInfo = psBCPerContextInfo->psBCInfo;
+
+        psBCInfo->ui32RefCount--;
+        if(psBCInfo->ui32RefCount == 0)
+        {
+                IMG_UINT32 i;
+
+                
+                psBCInfo->psFuncTable->pfnCloseBCDevice(psBCInfo->ui32DeviceID, psBCInfo->hExtDevice);
+
+                
+                for(i=0; i<psBCInfo->ui32BufferCount; i++)
+                {
+                        if(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);
+                        psBCInfo->psBuffer = IMG_NULL;
+                }
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_PERCONTEXT_INFO), psBCPerContextInfo, IMG_NULL);
+        
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVOpenBCDeviceKM (PVRSRV_PER_PROCESS_DATA      *psPerProc,
+                                                                   IMG_UINT32                           ui32DeviceID,
+                                                                   IMG_HANDLE                           hDevCookie,
+                                                                   IMG_HANDLE                           *phDeviceKM)
+{
+        PVRSRV_BUFFERCLASS_INFO *psBCInfo;
+        PVRSRV_BUFFERCLASS_PERCONTEXT_INFO      *psBCPerContextInfo;
+        PVRSRV_DEVICE_NODE              *psDeviceNode;
+        SYS_DATA                                *psSysData;
+        IMG_UINT32                              i;
+        PVRSRV_ERROR                    eError;
+
+        if(!phDeviceKM || !hDevCookie)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Invalid params"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        SysAcquireData(&psSysData);
+
+        
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)
+                        List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                   &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_NO_DEVICENODE_FOUND;
+        }
+        psBCInfo = (PVRSRV_BUFFERCLASS_INFO*)psDeviceNode->pvDevice;
+
+        
+
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(*psBCPerContextInfo),
+                                  (IMG_VOID **)&psBCPerContextInfo, IMG_NULL,
+                                  "Buffer Class per Context Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed psBCPerContextInfo alloc"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+        OSMemSet(psBCPerContextInfo, 0, sizeof(*psBCPerContextInfo));
+
+        if(psBCInfo->ui32RefCount++ == 0)
+        {
+                BUFFER_INFO sBufferInfo;
+
+                psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
+
+                
+                psBCInfo->hDevMemContext = (IMG_HANDLE)psDeviceNode->sDevMemoryInfo.pBMKernelContext;
+
+                
+                eError = psBCInfo->psFuncTable->pfnOpenBCDevice(ui32DeviceID, &psBCInfo->hExtDevice);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to open external BC device"));
+                        return eError;
+                }
+
+                
+                eError = psBCInfo->psFuncTable->pfnGetBCInfo(psBCInfo->hExtDevice, &sBufferInfo);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM : Failed to get BC Info"));
+                        return eError;
+                }
+
+                
+                psBCInfo->ui32BufferCount = sBufferInfo.ui32BufferCount;
+                
+
+                
+                eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                          sizeof(PVRSRV_BC_BUFFER) * sBufferInfo.ui32BufferCount,
+                                                          (IMG_VOID **)&psBCInfo->psBuffer,
+                                                          IMG_NULL,
+                                                          "Array of Buffer Class Buffer");
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to allocate BC buffers"));
+                        return eError;
+                }
+                OSMemSet (psBCInfo->psBuffer,
+                                        0,
+                                        sizeof(PVRSRV_BC_BUFFER) * sBufferInfo.ui32BufferCount);
+
+                for(i=0; i<psBCInfo->ui32BufferCount; i++)
+                {
+                        
+                        eError = PVRSRVAllocSyncInfoKM(IMG_NULL,
+                                                                                psBCInfo->hDevMemContext,
+                                                                                &psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo);
+                        if(eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed sync info alloc"));
+                                goto ErrorExit;
+                        }
+
+                        psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->ui32RefCount++;
+                        
+                        
+
+
+                        eError = psBCInfo->psFuncTable->pfnGetBCBuffer(psBCInfo->hExtDevice,
+                                                                                                                        i,
+                                                                                                                        psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo->psSyncData,
+                                                                                                                        &psBCInfo->psBuffer[i].sDeviceClassBuffer.hExtBuffer);
+                        if(eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOpenBCDeviceKM: Failed to get BC buffers"));
+                                goto ErrorExit;
+                        }
+
+                        
+                        psBCInfo->psBuffer[i].sDeviceClassBuffer.pfnGetBufferAddr = psBCInfo->psFuncTable->pfnGetBufferAddr;
+                        psBCInfo->psBuffer[i].sDeviceClassBuffer.hDevMemContext = psBCInfo->hDevMemContext;
+                        psBCInfo->psBuffer[i].sDeviceClassBuffer.hExtDevice = psBCInfo->hExtDevice;
+                }
+        }
+
+        psBCPerContextInfo->psBCInfo = psBCInfo;
+        psBCPerContextInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                                                         RESMAN_TYPE_BUFFERCLASS_DEVICE,
+                                                                                                         psBCPerContextInfo,
+                                                                                                         0,
+                                                                                                         &CloseBCDeviceCallBack);
+
+        
+        *phDeviceKM = (IMG_HANDLE)psBCPerContextInfo;
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        
+        for(i=0; i<psBCInfo->ui32BufferCount; i++)
+        {
+                if(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);
+                psBCInfo->psBuffer = IMG_NULL;
+        }
+
+        return eError;
+}
+
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVGetBCInfoKM (IMG_HANDLE hDeviceKM,
+                                                                BUFFER_INFO *psBufferInfo)
+{
+        PVRSRV_BUFFERCLASS_INFO *psBCInfo;
+        PVRSRV_ERROR                    eError;
+
+        if(!hDeviceKM || !psBufferInfo)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCInfoKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psBCInfo = BCDeviceHandleToBCInfo(hDeviceKM);
+
+        eError = psBCInfo->psFuncTable->pfnGetBCInfo(psBCInfo->hExtDevice, psBufferInfo);
+
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCInfoKM : Failed to get BC Info"));
+                return eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVGetBCBufferKM (IMG_HANDLE hDeviceKM,
+                                                                  IMG_UINT32 ui32BufferIndex,
+                                                                  IMG_HANDLE *phBuffer)
+{
+        PVRSRV_BUFFERCLASS_INFO *psBCInfo;
+
+        if(!hDeviceKM || !phBuffer)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCBufferKM: Invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psBCInfo = BCDeviceHandleToBCInfo(hDeviceKM);
+
+        if(ui32BufferIndex < psBCInfo->ui32BufferCount)
+        {
+                *phBuffer = (IMG_HANDLE)&psBCInfo->psBuffer[ui32BufferIndex];
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetBCBufferKM: Buffer index %d out of range (%d)", ui32BufferIndex,psBCInfo->ui32BufferCount));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+IMG_BOOL PVRGetBufferClassJTable(PVRSRV_BC_BUFFER2SRV_KMJTABLE *psJTable)
+{
+        psJTable->ui32TableSize = sizeof(PVRSRV_BC_BUFFER2SRV_KMJTABLE);
+
+        psJTable->pfnPVRSRVRegisterBCDevice = &PVRSRVRegisterBCDeviceKM;
+        psJTable->pfnPVRSRVScheduleDevices = &PVRSRVScheduleDevicesKM;
+        psJTable->pfnPVRSRVRemoveBCDevice = &PVRSRVRemoveBCDeviceKM;
+
+        return IMG_TRUE;
+}
+
diff --git a/drivers/gpu/pvr/deviceid.h b/drivers/gpu/pvr/deviceid.h
new file mode 100644
index 00000000000..b6fe92163ec
--- /dev/null
+++ b/drivers/gpu/pvr/deviceid.h
@@ -0,0 +1,36 @@
+/**********************************************************************
+ *
+ * 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 
diff --git a/drivers/gpu/pvr/devicemem.c b/drivers/gpu/pvr/devicemem.c
new file mode 100644
index 00000000000..f15ff9143eb
--- /dev/null
+++ b/drivers/gpu/pvr/devicemem.c
@@ -0,0 +1,1554 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "services_headers.h"
+#include "buffer_manager.h"
+#include "pdump_km.h"
+#include "pvr_bridge_km.h"
+
+static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE           hDevCookie,
+                                                                        IMG_HANDLE              hDevMemHeap,
+                                                                        IMG_UINT32              ui32Flags,
+                                                                        IMG_SIZE_T              ui32Size,
+                                                                        IMG_SIZE_T              ui32Alignment,
+                                                                        PVRSRV_KERNEL_MEM_INFO  **ppsMemInfo);
+
+typedef struct _RESMAN_MAP_DEVICE_MEM_DATA_
+{
+        
+        PVRSRV_KERNEL_MEM_INFO  *psMemInfo;
+        
+        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,
+                                                                                                        PVRSRV_HEAP_INFO *psHeapInfo)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_UINT32 ui32HeapCount;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+        IMG_UINT32 i;
+
+        if (hDevCookie == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetDeviceMemHeapsKM: hDevCookie invalid"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
+
+        
+        ui32HeapCount = psDeviceNode->sDevMemoryInfo.ui32HeapCount;
+        psDeviceMemoryHeap = psDeviceNode->sDevMemoryInfo.psDeviceMemoryHeap;
+
+        
+        PVR_ASSERT(ui32HeapCount <= PVRSRV_MAX_CLIENT_HEAPS);
+
+        
+        for(i=0; i<ui32HeapCount; i++)
+        {
+                
+                psHeapInfo[i].ui32HeapID = psDeviceMemoryHeap[i].ui32HeapID;
+                psHeapInfo[i].hDevMemHeap = psDeviceMemoryHeap[i].hDevMemHeap;
+                psHeapInfo[i].sDevVAddrBase = psDeviceMemoryHeap[i].sDevVAddrBase;
+                psHeapInfo[i].ui32HeapByteSize = psDeviceMemoryHeap[i].ui32HeapSize;
+                psHeapInfo[i].ui32Attribs = psDeviceMemoryHeap[i].ui32Attribs;
+        }
+
+        for(; i < PVRSRV_MAX_CLIENT_HEAPS; i++)
+        {
+                OSMemSet(psHeapInfo + i, 0, sizeof(*psHeapInfo));
+                psHeapInfo[i].ui32HeapID = (IMG_UINT32)PVRSRV_UNDEFINED_HEAP_ID;
+        }
+
+        return PVRSRV_OK;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDeviceMemContextKM(IMG_HANDLE                                     hDevCookie,
+                                                                                                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                                                                                                 IMG_HANDLE                             *phDevMemContext,
+                                                                                                                 IMG_UINT32                             *pui32ClientHeapCount,
+                                                                                                                 PVRSRV_HEAP_INFO                       *psHeapInfo,
+                                                                                                                 IMG_BOOL                                       *pbCreated,
+                                                                                                                 IMG_BOOL                                       *pbShared)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_UINT32 ui32HeapCount, ui32ClientHeapCount=0;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+        IMG_HANDLE hDevMemContext;
+        IMG_HANDLE hDevMemHeap;
+        IMG_DEV_PHYADDR sPDDevPAddr;
+        IMG_UINT32 i;
+
+#if !defined(PVR_SECURE_HANDLES)
+        PVR_UNREFERENCED_PARAMETER(pbShared);
+#endif
+
+        if (hDevCookie == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVCreateDeviceMemContextKM: hDevCookie invalid"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
+
+        
+
+        ui32HeapCount = psDeviceNode->sDevMemoryInfo.ui32HeapCount;
+        psDeviceMemoryHeap = psDeviceNode->sDevMemoryInfo.psDeviceMemoryHeap;
+
+        
+
+        PVR_ASSERT(ui32HeapCount <= PVRSRV_MAX_CLIENT_HEAPS);
+
+        
+
+        hDevMemContext = BM_CreateContext(psDeviceNode,
+                                                                          &sPDDevPAddr,
+                                                                          psPerProc,
+                                                                          pbCreated);
+        if (hDevMemContext == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateDeviceMemContextKM: Failed BM_CreateContext"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        
+        for(i=0; i<ui32HeapCount; i++)
+        {
+                switch(psDeviceMemoryHeap[i].DevMemHeapType)
+                {
+                        case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+                        {
+                                
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapID = psDeviceMemoryHeap[i].ui32HeapID;
+                                psHeapInfo[ui32ClientHeapCount].hDevMemHeap = psDeviceMemoryHeap[i].hDevMemHeap;
+                                psHeapInfo[ui32ClientHeapCount].sDevVAddrBase = psDeviceMemoryHeap[i].sDevVAddrBase;
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapByteSize = psDeviceMemoryHeap[i].ui32HeapSize;
+                                psHeapInfo[ui32ClientHeapCount].ui32Attribs = psDeviceMemoryHeap[i].ui32Attribs;
+#if defined(PVR_SECURE_HANDLES)
+                                pbShared[ui32ClientHeapCount] = IMG_TRUE;
+#endif
+                                ui32ClientHeapCount++;
+                                break;
+                        }
+                        case DEVICE_MEMORY_HEAP_PERCONTEXT:
+                        {
+                                hDevMemHeap = BM_CreateHeap(hDevMemContext,
+                                                                                        &psDeviceMemoryHeap[i]);
+
+                                
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapID = psDeviceMemoryHeap[i].ui32HeapID;
+                                psHeapInfo[ui32ClientHeapCount].hDevMemHeap = hDevMemHeap;
+                                psHeapInfo[ui32ClientHeapCount].sDevVAddrBase = psDeviceMemoryHeap[i].sDevVAddrBase;
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapByteSize = psDeviceMemoryHeap[i].ui32HeapSize;
+                                psHeapInfo[ui32ClientHeapCount].ui32Attribs = psDeviceMemoryHeap[i].ui32Attribs;
+#if defined(PVR_SECURE_HANDLES)
+                                pbShared[ui32ClientHeapCount] = IMG_FALSE;
+#endif
+
+                                ui32ClientHeapCount++;
+                                break;
+                        }
+                }
+        }
+
+        
+        *pui32ClientHeapCount = ui32ClientHeapCount;
+        *phDevMemContext = hDevMemContext;
+
+        return PVRSRV_OK;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDeviceMemContextKM(IMG_HANDLE hDevCookie,
+                                                                                                                  IMG_HANDLE hDevMemContext,
+                                                                                                                  IMG_BOOL *pbDestroyed)
+{
+        PVR_UNREFERENCED_PARAMETER(hDevCookie);
+
+        return BM_DestroyContext(hDevMemContext, pbDestroyed);
+}
+
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfoKM(IMG_HANDLE                                       hDevCookie,
+                                                                                                                 IMG_HANDLE                             hDevMemContext,
+                                                                                                                 IMG_UINT32                             *pui32ClientHeapCount,
+                                                                                                                 PVRSRV_HEAP_INFO                       *psHeapInfo,
+                                                                                                                 IMG_BOOL                                       *pbShared)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_UINT32 ui32HeapCount, ui32ClientHeapCount=0;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+        IMG_HANDLE hDevMemHeap;
+        IMG_UINT32 i;
+
+#if !defined(PVR_SECURE_HANDLES)
+        PVR_UNREFERENCED_PARAMETER(pbShared);
+#endif
+
+        if (hDevCookie == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetDeviceMemHeapInfoKM: hDevCookie invalid"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevCookie;
+
+        
+
+        ui32HeapCount = psDeviceNode->sDevMemoryInfo.ui32HeapCount;
+        psDeviceMemoryHeap = psDeviceNode->sDevMemoryInfo.psDeviceMemoryHeap;
+
+        
+
+        PVR_ASSERT(ui32HeapCount <= PVRSRV_MAX_CLIENT_HEAPS);
+
+        
+        for(i=0; i<ui32HeapCount; i++)
+        {
+                switch(psDeviceMemoryHeap[i].DevMemHeapType)
+                {
+                        case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+                        {
+                                
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapID = psDeviceMemoryHeap[i].ui32HeapID;
+                                psHeapInfo[ui32ClientHeapCount].hDevMemHeap = psDeviceMemoryHeap[i].hDevMemHeap;
+                                psHeapInfo[ui32ClientHeapCount].sDevVAddrBase = psDeviceMemoryHeap[i].sDevVAddrBase;
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapByteSize = psDeviceMemoryHeap[i].ui32HeapSize;
+                                psHeapInfo[ui32ClientHeapCount].ui32Attribs = psDeviceMemoryHeap[i].ui32Attribs;
+#if defined(PVR_SECURE_HANDLES)
+                                pbShared[ui32ClientHeapCount] = IMG_TRUE;
+#endif
+                                ui32ClientHeapCount++;
+                                break;
+                        }
+                        case DEVICE_MEMORY_HEAP_PERCONTEXT:
+                        {
+                                hDevMemHeap = BM_CreateHeap(hDevMemContext,
+                                                                                        &psDeviceMemoryHeap[i]);
+
+                                
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapID = psDeviceMemoryHeap[i].ui32HeapID;
+                                psHeapInfo[ui32ClientHeapCount].hDevMemHeap = hDevMemHeap;
+                                psHeapInfo[ui32ClientHeapCount].sDevVAddrBase = psDeviceMemoryHeap[i].sDevVAddrBase;
+                                psHeapInfo[ui32ClientHeapCount].ui32HeapByteSize = psDeviceMemoryHeap[i].ui32HeapSize;
+                                psHeapInfo[ui32ClientHeapCount].ui32Attribs = psDeviceMemoryHeap[i].ui32Attribs;
+#if defined(PVR_SECURE_HANDLES)
+                                pbShared[ui32ClientHeapCount] = IMG_FALSE;
+#endif
+
+                                ui32ClientHeapCount++;
+                                break;
+                        }
+                }
+        }
+
+        
+        *pui32ClientHeapCount = ui32ClientHeapCount;
+
+        return PVRSRV_OK;
+}
+
+
+static PVRSRV_ERROR AllocDeviceMem(IMG_HANDLE           hDevCookie,
+                                                                        IMG_HANDLE              hDevMemHeap,
+                                                                        IMG_UINT32              ui32Flags,
+                                                                        IMG_SIZE_T              ui32Size,
+                                                                        IMG_SIZE_T              ui32Alignment,
+                                                                        PVRSRV_KERNEL_MEM_INFO  **ppsMemInfo)
+{
+        PVRSRV_KERNEL_MEM_INFO  *psMemInfo;
+        BM_HANDLE               hBuffer;
+        
+        PVRSRV_MEMBLK   *psMemBlock;
+        IMG_BOOL                bBMError;
+
+        PVR_UNREFERENCED_PARAMETER(hDevCookie);
+
+        *ppsMemInfo = IMG_NULL;
+
+        if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                                        sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                        (IMG_VOID **)&psMemInfo, IMG_NULL,
+                                        "Kernel Memory Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"AllocDeviceMem: Failed to alloc memory for block"));
+                return (PVRSRV_ERROR_OUT_OF_MEMORY);
+        }
+
+        OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+
+        psMemBlock = &(psMemInfo->sMemBlk);
+
+        
+        psMemInfo->ui32Flags = ui32Flags | PVRSRV_MEM_RAM_BACKED_ALLOCATION;
+
+        bBMError = BM_Alloc (hDevMemHeap,
+                                                        IMG_NULL,
+                                                        ui32Size,
+                                                        &psMemInfo->ui32Flags,
+                                                        IMG_CAST_TO_DEVVADDR_UINT(ui32Alignment),
+                                                        &hBuffer);
+
+        if (!bBMError)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"AllocDeviceMem: BM_Alloc Failed"));
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+                
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        
+        psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
+        psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
+
+        
+        psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
+
+        
+
+        psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
+
+        psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
+
+        psMemInfo->ui32AllocSize = ui32Size;
+
+        
+        psMemInfo->pvSysBackupBuffer = IMG_NULL;
+
+        
+        *ppsMemInfo = psMemInfo;
+
+        
+        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)
+{
+        BM_HANDLE               hBuffer;
+
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        hBuffer = psMemInfo->sMemBlk.hBuffer;
+
+        
+        BM_Free(hBuffer, psMemInfo->ui32Flags);
+
+        if(psMemInfo->pvSysBackupBuffer)
+        {
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, psMemInfo->ui32AllocSize, psMemInfo->pvSysBackupBuffer, IMG_NULL);
+                psMemInfo->pvSysBackupBuffer = IMG_NULL;
+        }
+
+        OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+        
+
+        return(PVRSRV_OK);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE                                      hDevCookie,
+                                                                                                IMG_HANDLE                                      hDevMemContext,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO         **ppsKernelSyncInfo)
+{
+        IMG_HANDLE hSyncDevMemHeap;
+        DEVICE_MEMORY_INFO *psDevMemoryInfo;
+        BM_CONTEXT *pBMContext;
+        PVRSRV_ERROR eError;
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+        PVRSRV_SYNC_DATA *psSyncData;
+
+        eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                                                sizeof(PVRSRV_KERNEL_SYNC_INFO),
+                                                (IMG_VOID **)&psKernelSyncInfo, IMG_NULL,
+                                                "Kernel Synchronization Info");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSyncInfoKM: Failed to alloc memory"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        psKernelSyncInfo->ui32RefCount = 0;
+
+        
+        pBMContext = (BM_CONTEXT*)hDevMemContext;
+        psDevMemoryInfo = &pBMContext->psDeviceNode->sDevMemoryInfo;
+
+        
+        hSyncDevMemHeap = psDevMemoryInfo->psDeviceMemoryHeap[psDevMemoryInfo->ui32SyncHeapID].hDevMemHeap;
+
+        
+
+
+        eError = AllocDeviceMem(hDevCookie,
+                                                        hSyncDevMemHeap,
+                                                        PVRSRV_MEM_CACHE_CONSISTENT,
+                                                        sizeof(PVRSRV_SYNC_DATA),
+                                                        sizeof(IMG_UINT32),
+                                                        &psKernelSyncInfo->psSyncDataMemInfoKM);
+
+        if (eError != PVRSRV_OK)
+        {
+
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSyncInfoKM: Failed to alloc memory"));
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL);
+                
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        
+        psKernelSyncInfo->psSyncData = psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM;
+        psSyncData = psKernelSyncInfo->psSyncData;
+
+        psSyncData->ui32WriteOpsPending = 0;
+        psSyncData->ui32WriteOpsComplete = 0;
+        psSyncData->ui32ReadOpsPending = 0;
+        psSyncData->ui32ReadOpsComplete = 0;
+        psSyncData->ui32LastOpDumpVal = 0;
+        psSyncData->ui32LastReadOpDumpVal = 0;
+
+#if defined(PDUMP)
+        PDUMPMEM(psKernelSyncInfo->psSyncDataMemInfoKM->pvLinAddrKM,
+                        psKernelSyncInfo->psSyncDataMemInfoKM,
+                        0,
+                        psKernelSyncInfo->psSyncDataMemInfoKM->ui32AllocSize,
+                        PDUMP_FLAGS_CONTINUOUS,
+                        MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
+#endif
+
+        psKernelSyncInfo->sWriteOpsCompleteDevVAddr.uiAddr = psKernelSyncInfo->psSyncDataMemInfoKM->sDevVAddr.uiAddr + offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete);
+        psKernelSyncInfo->sReadOpsCompleteDevVAddr.uiAddr = psKernelSyncInfo->psSyncDataMemInfoKM->sDevVAddr.uiAddr + offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete);
+
+        
+        psKernelSyncInfo->psSyncDataMemInfoKM->psKernelSyncInfo = IMG_NULL;
+
+        
+        *ppsKernelSyncInfo = psKernelSyncInfo;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfoKM(PVRSRV_KERNEL_SYNC_INFO  *psKernelSyncInfo)
+{
+        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;
+
+        
+        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;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        
+        psMemInfo->ui32RefCount--;
+
+        
+        if((psMemInfo->ui32Flags & PVRSRV_MEM_EXPORTED) && (bFromAllocator == IMG_TRUE))
+        {
+                IMG_HANDLE hMemInfo = IMG_NULL;
+
+                
+                eError = PVRSRVFindHandle(KERNEL_HANDLE_BASE,
+                                                                 &hMemInfo,
+                                                                 psMemInfo,
+                                                                 PVRSRV_HANDLE_TYPE_MEM_INFO);
+                if(eError != PVRSRV_OK)
+                {
+                        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, "FreeMemCallBackCommon: PVRSRVReleaseHandle failed for exported meminfo"));
+                        return eError;
+                }
+        }
+
+        
+        if (psMemInfo->ui32RefCount == 0)
+        {
+                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;
+                }
+        }
+
+        
+        
+        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,
+                                                                                                PVRSRV_KERNEL_MEM_INFO  *psMemInfo)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_UNREFERENCED_PARAMETER(hDevCookie);
+
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if (psMemInfo->sMemBlk.hResItem != IMG_NULL)
+        {
+                eError = ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
+        }
+        else
+        {
+                
+                eError = FreeDeviceMemCallBack(psMemInfo, 0);
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV _PVRSRVAllocDeviceMemKM(IMG_HANDLE                                    hDevCookie,
+                                                                                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                                                                                 IMG_HANDLE                                     hDevMemHeap,
+                                                                                                 IMG_UINT32                                     ui32Flags,
+                                                                                                 IMG_SIZE_T                                     ui32Size,
+                                                                                                 IMG_SIZE_T                                     ui32Alignment,
+                                                                                                 PVRSRV_KERNEL_MEM_INFO         **ppsMemInfo)
+{
+        PVRSRV_KERNEL_MEM_INFO  *psMemInfo;
+        PVRSRV_ERROR                    eError;
+        BM_HEAP                                 *psBMHeap;
+        IMG_HANDLE                              hDevMemContext;
+
+        if (!hDevMemHeap ||
+                (ui32Size == 0))
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        if (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)
+        {
+                 
+                if (((ui32Size % HOST_PAGESIZE()) != 0) ||
+                        ((ui32Alignment % HOST_PAGESIZE()) != 0))
+                {
+                        return PVRSRV_ERROR_INVALID_PARAMS;
+                }
+        }
+
+        eError = AllocDeviceMem(hDevCookie,
+                                                        hDevMemHeap,
+                                                        ui32Flags,
+                                                        ui32Size,
+                                                        ui32Alignment,
+                                                        &psMemInfo);
+
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        if (ui32Flags & PVRSRV_MEM_NO_SYNCOBJ)
+        {
+                psMemInfo->psKernelSyncInfo = IMG_NULL;
+        }
+        else
+        {
+                
+
+
+                psBMHeap = (BM_HEAP*)hDevMemHeap;
+                hDevMemContext = (IMG_HANDLE)psBMHeap->pBMContext;
+                eError = PVRSRVAllocSyncInfoKM(hDevCookie,
+                                                                           hDevMemContext,
+                                                                           &psMemInfo->psKernelSyncInfo);
+                if(eError != PVRSRV_OK)
+                {
+                        goto free_mainalloc;
+                }
+                psMemInfo->psKernelSyncInfo->ui32RefCount++;
+        }
+
+        
+        *ppsMemInfo = psMemInfo;
+
+        if (ui32Flags & PVRSRV_MEM_NO_RESMAN)
+        {
+                psMemInfo->sMemBlk.hResItem = IMG_NULL;
+        }
+        else
+        {
+                
+                psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                                                                RESMAN_TYPE_DEVICEMEM_ALLOCATION,
+                                                                                                                psMemInfo,
+                                                                                                                0,
+                                                                                                                &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);
+
+free_mainalloc:
+        FreeDeviceMem(psMemInfo);
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDissociateDeviceMemKM(IMG_HANDLE              hDevCookie,
+                                                                                                          PVRSRV_KERNEL_MEM_INFO *psMemInfo)
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_DEVICE_NODE      *psDeviceNode = hDevCookie;
+
+        PVR_UNREFERENCED_PARAMETER(hDevCookie);
+
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        eError = ResManDissociateRes(psMemInfo->sMemBlk.hResItem, psDeviceNode->hResManContext);
+
+        PVR_ASSERT(eError == PVRSRV_OK);
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetFreeDeviceMemKM(IMG_UINT32 ui32Flags,
+                                                                                                   IMG_SIZE_T *pui32Total,
+                                                                                                   IMG_SIZE_T *pui32Free,
+                                                                                                   IMG_SIZE_T *pui32LargestBlock)
+{
+        
+
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        PVR_UNREFERENCED_PARAMETER(pui32Total);
+        PVR_UNREFERENCED_PARAMETER(pui32Free);
+        PVR_UNREFERENCED_PARAMETER(pui32LargestBlock);
+
+        return PVRSRV_OK;
+}
+
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnwrapExtMemoryKM (PVRSRV_KERNEL_MEM_INFO       *psMemInfo)
+{
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        return ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
+}
+
+
+static PVRSRV_ERROR UnwrapExtMemoryCallBack(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 PVRSRVWrapExtMemoryKM(IMG_HANDLE                              hDevCookie,
+                                                                                                PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                                                                                IMG_HANDLE                              hDevMemContext,
+                                                                                                IMG_SIZE_T                              ui32ByteSize,
+                                                                                                IMG_SIZE_T                              ui32PageOffset,
+                                                                                                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_HANDLE                      hDevMemHeap = IMG_NULL;
+        PVRSRV_DEVICE_NODE* psDeviceNode;
+        BM_HANDLE                       hBuffer;
+        PVRSRV_MEMBLK           *psMemBlock;
+        IMG_BOOL                        bBMError;
+        BM_HEAP                         *psBMHeap;
+        PVRSRV_ERROR            eError;
+        IMG_VOID                        *pvPageAlignedCPUVAddr;
+        IMG_SYS_PHYADDR         *psIntSysPAddr = IMG_NULL;
+        IMG_HANDLE                      hOSWrapMem = IMG_NULL;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;    
+        IMG_UINT32              i;
+        IMG_SIZE_T              ui32PageCount = 0;
+        
+        
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)hDevCookie;
+        PVR_ASSERT(psDeviceNode != IMG_NULL);
+
+        if (psDeviceNode == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVWrapExtMemoryKM: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if(pvLinAddr)
+        {
+                
+                ui32PageOffset = (IMG_UINTPTR_T)pvLinAddr & (ui32HostPageSize - 1);
+
+                
+                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),
+                                                (IMG_VOID **)&psIntSysPAddr, IMG_NULL,
+                                                "Array of Page Addresses") != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+
+                eError = OSAcquirePhysPageAddr(pvPageAlignedCPUVAddr,
+                                                                                ui32PageCount * ui32HostPageSize,
+                                                                                psIntSysPAddr,
+                                                                                &hOSWrapMem);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
+                        eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                        goto ErrorExitPhase1;
+                }
+
+                
+                psExtSysPAddr = psIntSysPAddr;
+
+                
+
+                bPhysContig = IMG_FALSE;
+        }
+        else
+        {
+                
+        }
+        
+        
+        psDevMemoryInfo = &((BM_CONTEXT*)hDevMemContext)->psDeviceNode->sDevMemoryInfo;
+        psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
+        for(i=0; i<PVRSRV_MAX_CLIENT_HEAPS; i++)
+        {
+                if(HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) == psDevMemoryInfo->ui32MappingHeapID)
+                {
+                        if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
+                        {
+                                
+                                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_UNABLE_TO_FIND_MAPPING_HEAP;
+                goto ErrorExitPhase2;
+        }
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                        (IMG_VOID **)&psMemInfo, IMG_NULL,
+                                        "Kernel Memory Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: Failed to alloc memory for block"));
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorExitPhase2;
+        }
+
+        OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+        psMemInfo->ui32Flags = ui32Flags;
+
+        psMemBlock = &(psMemInfo->sMemBlk);
+
+        bBMError = BM_Wrap(hDevMemHeap,
+                                           ui32ByteSize,
+                                           ui32PageOffset,
+                                           bPhysContig,
+                                           psExtSysPAddr,
+                                           IMG_NULL,
+                                           &psMemInfo->ui32Flags,
+                                           &hBuffer);
+        if (!bBMError)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVWrapExtMemoryKM: BM_Wrap Failed"));
+                eError = PVRSRV_ERROR_BAD_MAPPING;
+                goto ErrorExitPhase3;
+        }
+
+        
+        psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
+        psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
+        psMemBlock->hOSWrapMem = hOSWrapMem;
+        psMemBlock->psIntSysPAddr = psIntSysPAddr;
+
+        
+        psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
+
+        
+        psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
+        psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
+        psMemInfo->ui32AllocSize = ui32ByteSize;
+
+        
+
+        psMemInfo->pvSysBackupBuffer = IMG_NULL;
+
+        
+
+
+        psBMHeap = (BM_HEAP*)hDevMemHeap;
+        hDevMemContext = (IMG_HANDLE)psBMHeap->pBMContext;
+        eError = PVRSRVAllocSyncInfoKM(hDevCookie,
+                                                                        hDevMemContext,
+                                                                        &psMemInfo->psKernelSyncInfo);
+        if(eError != PVRSRV_OK)
+        {
+                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);
+
+        
+        *ppsMemInfo = psMemInfo;
+
+        return PVRSRV_OK;
+
+        
+
+ErrorExitPhase4:
+        if(psMemInfo)
+        {
+                FreeDeviceMem(psMemInfo);
+                
+
+
+                psMemInfo = IMG_NULL;
+        }
+
+ErrorExitPhase3:
+        if(psMemInfo)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+                
+        }
+
+ErrorExitPhase2:
+        if(psIntSysPAddr)
+        {
+                OSReleasePhysPageAddr(hOSWrapMem);
+        }
+
+ErrorExitPhase1:
+        if(psIntSysPAddr)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageCount * sizeof(IMG_SYS_PHYADDR), psIntSysPAddr, IMG_NULL);
+                
+        }
+        
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceMemoryKM (PVRSRV_KERNEL_MEM_INFO *psMemInfo)
+{
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        return ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
+}
+
+
+static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam,
+                                                                                          IMG_UINT32 ui32Param)
+{
+        PVRSRV_ERROR                            eError;
+        RESMAN_MAP_DEVICE_MEM_DATA      *psMapData = pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        if(psMapData->psMemInfo->sMemBlk.psIntSysPAddr)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMapData->psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
+                psMapData->psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
+        }
+
+        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)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free DST meminfo"));
+                return eError;
+        }
+
+        
+        eError = FreeMemCallBackCommon(psMapData->psSrcMemInfo, 0, IMG_FALSE);
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
+        
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA       *psPerProc,
+                                                                                                  PVRSRV_KERNEL_MEM_INFO        *psSrcMemInfo,
+                                                                                                  IMG_HANDLE                            hDstDevMemHeap,
+                                                                                                  PVRSRV_KERNEL_MEM_INFO        **ppsDstMemInfo)
+{
+        PVRSRV_ERROR                            eError;
+        IMG_UINT32                                      i;
+        IMG_SIZE_T                                      ui32PageCount, ui32PageOffset;
+        IMG_SIZE_T                                      ui32HostPageSize = HOST_PAGESIZE();
+        IMG_SYS_PHYADDR                         *psSysPAddr = IMG_NULL;
+        IMG_DEV_PHYADDR                         sDevPAddr;
+        BM_BUF                                          *psBuf;
+        IMG_DEV_VIRTADDR                        sDevVAddr;
+        PVRSRV_KERNEL_MEM_INFO          *psMemInfo = IMG_NULL;
+        BM_HANDLE                                       hBuffer;
+        PVRSRV_MEMBLK                           *psMemBlock;
+        IMG_BOOL                                        bBMError;
+        PVRSRV_DEVICE_NODE                      *psDeviceNode;
+        IMG_VOID                                        *pvPageAlignedCPUVAddr;
+        RESMAN_MAP_DEVICE_MEM_DATA      *psMapData = IMG_NULL;
+
+        
+        if(!psSrcMemInfo || !hDstDevMemHeap || !ppsDstMemInfo)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        *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);
+
+        
+
+
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        ui32PageCount*sizeof(IMG_SYS_PHYADDR),
+                                        (IMG_VOID **)&psSysPAddr, IMG_NULL,
+                                        "Array of Page Addresses") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc memory for block"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        psBuf = psSrcMemInfo->sMemBlk.hBuffer;
+
+        
+        psDeviceNode = psBuf->pMapping->pBMHeap->pBMContext->psDeviceNode;
+
+        
+        sDevVAddr.uiAddr = psSrcMemInfo->sDevVAddr.uiAddr - IMG_CAST_TO_DEVVADDR_UINT(ui32PageOffset);
+        for(i=0; i<ui32PageCount; i++)
+        {
+                BM_GetPhysPageAddr(psSrcMemInfo, sDevVAddr, &sDevPAddr);
+
+                
+                psSysPAddr[i] = SysDevPAddrToSysPAddr (psDeviceNode->sDevId.eDeviceType, sDevPAddr);
+
+                
+                sDevVAddr.uiAddr += IMG_CAST_TO_DEVVADDR_UINT(ui32HostPageSize);
+        }
+
+        
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        sizeof(RESMAN_MAP_DEVICE_MEM_DATA),
+                                        (IMG_VOID **)&psMapData, IMG_NULL,
+                                        "Resource Manager Map Data") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc resman map data"));
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorExit;
+        }
+
+
+        if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                                        sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                        (IMG_VOID **)&psMemInfo, IMG_NULL,
+                                        "Kernel Memory Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: Failed to alloc memory for block"));
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorExit;
+        }
+
+        OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+        psMemInfo->ui32Flags = psSrcMemInfo->ui32Flags;
+
+        psMemBlock = &(psMemInfo->sMemBlk);
+
+        bBMError = BM_Wrap(hDstDevMemHeap,
+                                           psSrcMemInfo->ui32AllocSize,
+                                           ui32PageOffset,
+                                           IMG_FALSE,
+                                           psSysPAddr,
+                                           pvPageAlignedCPUVAddr,
+                                           &psMemInfo->ui32Flags,
+                                           &hBuffer);
+
+        if (!bBMError)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceMemoryKM: BM_Wrap Failed"));
+                eError = PVRSRV_ERROR_BAD_MAPPING;
+                goto ErrorExit;
+        }
+
+        
+        psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
+        psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
+
+        
+        psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
+
+        
+        psMemBlock->psIntSysPAddr = psSysPAddr;
+
+        
+        psMemInfo->pvLinAddrKM = psSrcMemInfo->pvLinAddrKM;
+
+        
+        psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
+        psMemInfo->ui32AllocSize = psSrcMemInfo->ui32AllocSize;
+        psMemInfo->psKernelSyncInfo = psSrcMemInfo->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;
+
+        
+        psMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                                                        RESMAN_TYPE_DEVICEMEM_MAPPING,
+                                                                                                        psMapData,
+                                                                                                        0,
+                                                                                                        &UnmapDeviceMemoryCallBack);
+
+        *ppsDstMemInfo = psMemInfo;
+
+        return PVRSRV_OK;
+
+        
+
+ErrorExit:
+
+        if(psSysPAddr)
+        {
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psSysPAddr, IMG_NULL);
+                
+        }
+
+        if(psMemInfo)
+        {
+                
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_MEM_INFO), psMemInfo, IMG_NULL);
+                
+        }
+
+        if(psMapData)
+        {
+                
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
+                
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceClassMemoryKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo)
+{
+        if (!psMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        return ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
+}
+
+
+static PVRSRV_ERROR UnmapDeviceClassMemoryCallBack(IMG_PVOID    pvParam,
+                                                                                                   IMG_UINT32   ui32Param)
+{
+        PVRSRV_DC_MAPINFO *psDCMapInfo = pvParam;
+        PVRSRV_KERNEL_MEM_INFO *psMemInfo;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        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_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA  *psPerProc,
+                                                                                                           IMG_HANDLE                           hDevMemContext,
+                                                                                                           IMG_HANDLE                           hDeviceClassBuffer,
+                                                                                                           PVRSRV_KERNEL_MEM_INFO       **ppsMemInfo,
+                                                                                                           IMG_HANDLE                           *phOSMapInfo)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_DEVICE_NODE* psDeviceNode;
+        PVRSRV_KERNEL_MEM_INFO *psMemInfo = IMG_NULL;
+        PVRSRV_DEVICECLASS_BUFFER *psDeviceClassBuffer;
+        IMG_SYS_PHYADDR *psSysPAddr;
+        IMG_VOID *pvCPUVAddr, *pvPageAlignedCPUVAddr;
+        IMG_BOOL bPhysContig;
+        BM_CONTEXT *psBMContext;
+        DEVICE_MEMORY_INFO *psDevMemoryInfo;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap;
+        IMG_HANDLE hDevMemHeap = IMG_NULL;
+        IMG_SIZE_T ui32ByteSize;
+        IMG_SIZE_T ui32Offset;
+        IMG_SIZE_T ui32PageSize = HOST_PAGESIZE();
+        BM_HANDLE               hBuffer;
+        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;
+        }
+
+        
+        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;
+
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        eError = psDeviceClassBuffer->pfnGetBufferAddr(psDeviceClassBuffer->hExtDevice,
+                                                                                                   psDeviceClassBuffer->hExtBuffer,
+                                                                                                   &psSysPAddr,
+                                                                                                   &ui32ByteSize,
+                                                                                                   &pvCPUVAddr,
+                                                                                                   phOSMapInfo,
+                                                                                                   &bPhysContig,
+                                                                                                   &psDCMapInfo->ui32TilingStride);
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: unable to get buffer address"));
+                goto ErrorExitPhase1;
+        }
+
+        
+        psBMContext = (BM_CONTEXT*)psDeviceClassBuffer->hDevMemContext;
+        psDeviceNode = psBMContext->psDeviceNode;
+        psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
+        psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
+        for(i=0; i<PVRSRV_MAX_CLIENT_HEAPS; i++)
+        {
+                if(HEAP_IDX(psDeviceMemoryHeap[i].ui32HeapID) == psDevMemoryInfo->ui32MappingHeapID)
+                {
+                        if(psDeviceMemoryHeap[i].DevMemHeapType == DEVICE_MEMORY_HEAP_PERCONTEXT)
+                        {
+                                
+                                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"));
+                eError = PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE;
+                goto ErrorExitPhase1;
+        }
+
+        
+        ui32Offset = ((IMG_UINTPTR_T)pvCPUVAddr) & (ui32PageSize - 1);
+        pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINTPTR_T)pvCPUVAddr - ui32Offset);
+
+        eError = OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                                        sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                        (IMG_VOID **)&psMemInfo, IMG_NULL,
+                                        "Kernel Memory Info");
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: Failed to alloc memory for block"));
+                goto ErrorExitPhase1;
+        }
+
+        OSMemSet(psMemInfo, 0, sizeof(*psMemInfo));
+
+        psMemBlock = &(psMemInfo->sMemBlk);
+
+        bBMError = BM_Wrap(hDevMemHeap,
+                                           ui32ByteSize,
+                                           ui32Offset,
+                                           bPhysContig,
+                                           psSysPAddr,
+                                           pvPageAlignedCPUVAddr,
+                                           &psMemInfo->ui32Flags,
+                                           &hBuffer);
+
+        if (!bBMError)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVMapDeviceClassMemoryKM: BM_Wrap Failed"));
+                
+                eError = PVRSRV_ERROR_BAD_MAPPING;
+                goto ErrorExitPhase2;
+        }
+
+        
+        psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer);
+        psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer);
+
+        
+        psMemBlock->hBuffer = (IMG_HANDLE)hBuffer;
+
+        
+
+        psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer);
+
+        
+        psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr;
+        psMemInfo->ui32AllocSize = ui32ByteSize;
+        psMemInfo->psKernelSyncInfo = psDeviceClassBuffer->psKernelSyncInfo;
+
+        
+
+        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,
+                                                                                                        psDCMapInfo,
+                                                                                                        0,
+                                                                                                        &UnmapDeviceClassMemoryCallBack);
+
+        psMemInfo->ui32RefCount++;
+
+        psMemInfo->memType = PVRSRV_MEMTYPE_DEVICECLASS;
+
+        
+        *ppsMemInfo = psMemInfo;
+
+        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;
+}
+
diff --git a/drivers/gpu/pvr/display/omap_display.c b/drivers/gpu/pvr/display/omap_display.c
new file mode 100644
index 00000000000..1fb5f353870
--- /dev/null
+++ b/drivers/gpu/pvr/display/omap_display.c
@@ -0,0 +1,1078 @@
+/*
+ * drivers/gpu/pvr/display/omap_display.c
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fb.h>
+
+#include <plat/vrfb.h>
+#include <plat/display.h>
+
+/* Workaround for DEBUG macro clash in framebuffer */
+#ifdef RELEASE
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#undef DEBUG
+#else
+#undef DEBUG
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#endif
+
+#define OMAP_DISP_DRV_NAME "omap_display"
+#define OMAP_DISP_FRAMEBUFFER_COUNT num_registered_fb
+
+#define OMAP_DISP_PAGE_MASK (PAGE_SIZE - 1)
+#define OMAP_DISP_PAGE_TRUNCATE (~OMAP_DISP_PAGE_MASK)
+#define OMAP_DISP_PAGE_ROUND_UP(x) \
+        (((x)+OMAP_DISP_PAGE_MASK) & OMAP_DISP_PAGE_TRUNCATE)
+
+#define OMAP_DISP_IRQ_TIMEOUT 500
+
+#ifdef DEBUG
+#define DBG_PRINT(format, ...) printk(KERN_DEBUG OMAP_DISP_DRV_NAME \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#define WRN_PRINT(format, ...) printk(KERN_WARNING OMAP_DISP_DRV_NAME \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#define ERR_PRINT(format, ...) printk(KERN_ERR OMAP_DISP_DRV_NAME \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#else
+#define DBG_PRINT(format, ...)
+#define WRN_PRINT(format, ...)
+#define ERR_PRINT(format, ...)
+#endif
+
+#include "omap_display.h"
+
+/* List for the available displays */
+static struct omap_display_device *omap_display_list;
+static unsigned int omap_display_number;
+
+/* Forward declarations */
+static struct omap_display_buffer *create_main_buffer(
+        struct omap_display_device *display);
+static int display_destroy_buffer(struct omap_display_buffer *buffer);
+
+static int open_display(struct omap_display_device *display,
+        enum omap_display_feature features)
+{
+        int i;
+
+        DBG_PRINT("Opening display '%s'", display->name);
+
+        /* TODO: Support horizontal orientation */
+        if (features & ORIENTATION_HORIZONTAL) {
+                DBG_PRINT("Horizontal orientation is not supported yet , "
+                        "falling back to vertical orientation");
+                features = ORIENTATION_VERTICAL;
+        }
+
+        display->features = features;
+        display->reference_count++;
+        for (i = 0; i < display->overlay_managers_count; i++)
+                omap_dss_get_device(display->overlay_managers[i]->device);
+
+        /* If the main buffer doesn't exist create it */
+        if (!display->main_buffer) {
+                DBG_PRINT("Main buffer doesn't exist for display '%s', create"
+                        " one", display->name);
+                display->main_buffer = create_main_buffer(display);
+                if (!display->main_buffer) {
+                        ERR_PRINT("Failed to create main buffer for '%s'",
+                                display->name);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+static int close_display(struct omap_display_device *display)
+{
+        int err;
+        int i;
+
+        /* TODO: Is it the same thing to close a virtual and single display? */
+        DBG_PRINT("Closing display '%s'", display->name);
+
+        display->reference_count--;
+        for (i = 0; i < display->overlay_managers_count; i++)
+                omap_dss_put_device(display->overlay_managers[i]->device);
+
+        if (display->flip_chain) {
+                err = display->destroy_flip_chain(display);
+                display->flip_chain = 0;
+                if (err)
+                        WRN_PRINT("An error happened when destroying flip "
+                                "chain for '%s'", display->name);
+        }
+
+        return 0;
+}
+
+static int get_max_buffers(struct omap_display_device *display)
+{
+        /* TODO: If TILER is wanted to be used how do you calculate this? */
+        int fb_idx;
+        switch (display->id) {
+        case OMAP_DISPID_PRIMARY:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_SECONDARY:
+                fb_idx = 1;
+                break;
+        case OMAP_DISPID_TERTIARY:
+                fb_idx = 2;
+                break;
+        case OMAP_DISPID_VIRTUAL:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_BADSTATE:
+        default:
+                ERR_PRINT("Unknown display id %i", display->id);
+                BUG();
+        }
+
+        /* Use the framebuffer memory */
+        if (fb_idx >= 0 && fb_idx < num_registered_fb) {
+                struct fb_info *framebuffer = registered_fb[fb_idx];
+                unsigned long buffer_size;
+
+                /* Single buffer size */
+                buffer_size = display->width * display->height *
+                        display->bytes_per_pixel;
+                /* Page align the buffer size, round up to the page size */
+                buffer_size = OMAP_DISP_PAGE_ROUND_UP(buffer_size);
+
+                return (int) (framebuffer->fix.smem_len / buffer_size);
+        } else {
+                ERR_PRINT("Framebuffer %i doesn't exist for display '%s'",
+                        fb_idx, display->name);
+                return 0;
+        }
+}
+
+static int create_flip_chain(struct omap_display_device *display,
+        unsigned int buffer_count)
+{
+        int fb_idx;
+
+        /* TODO: What about TILER buffers */
+        if (buffer_count <= 1) {
+                ERR_PRINT("Flip chains with %i buffers not supported",
+                        buffer_count);
+                return 1;
+        } else if (buffer_count > display->buffers_available) {
+                ERR_PRINT("Requesting %i buffers when there is %i available"
+                        " for '%s'", buffer_count, display->buffers_available,
+                        display->name);
+                return 1;
+        } else if (display->flip_chain) {
+                ERR_PRINT("Flip chain already exists for '%s'", display->name);
+                return 1;
+        }
+
+        /* Create the flip chain with the framebuffer memory */
+        switch (display->id) {
+        case OMAP_DISPID_PRIMARY:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_SECONDARY:
+                fb_idx = 1;
+                break;
+        case OMAP_DISPID_TERTIARY:
+                fb_idx = 2;
+                break;
+        case OMAP_DISPID_VIRTUAL:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_BADSTATE:
+        default:
+                ERR_PRINT("Unknown display id %i", display->id);
+                BUG();
+        }
+
+        /* Use the framebuffer memory */
+        if (fb_idx >= 0 && fb_idx < num_registered_fb) {
+                struct fb_info *framebuffer = registered_fb[fb_idx];
+                unsigned long buffer_size;
+                struct omap_display_flip_chain *flip_chain;
+                int i;
+
+                if (!framebuffer || !framebuffer->fix.smem_start ||
+                        !framebuffer->screen_base) {
+                        ERR_PRINT("Framebuffer %i doesn't seem to be "
+                                "initialized", fb_idx);
+                        return 1;
+                }
+
+                /*
+                 * Check if there is enough memory in the fb for the requested
+                 * buffers
+                 */
+                buffer_size = display->width * display->height *
+                        display->bytes_per_pixel;
+                /* Page align the buffer size, round up to the page size */
+                buffer_size = OMAP_DISP_PAGE_ROUND_UP(buffer_size);
+
+                if (buffer_size * buffer_count > framebuffer->fix.smem_len) {
+                        ERR_PRINT("Not enough memory to allocate %i buffers "
+                                "(%lu bytes each), memory available %lu for "
+                                "display '%s'", buffer_count, buffer_size,
+                                (unsigned long)framebuffer->fix.smem_len,
+                                display->name);
+                        return 1;
+                }
+
+                flip_chain = kzalloc(sizeof(*flip_chain), GFP_KERNEL);
+
+                if (!flip_chain) {
+                        ERR_PRINT("Out of memory");
+                        return 1;
+                }
+
+                for (i = 0; i < buffer_count; i++) {
+                        struct omap_display_buffer *buffer;
+
+                        /*
+                         * Reuse the main buffer as the first buffer in the
+                         * flip chain
+                         */
+                        if (i == 0) {
+                                buffer = display->main_buffer;
+                                flip_chain->buffers[i] = buffer;
+                                DBG_PRINT("Flip chain buffer %i has address "
+                                        "%lx for display '%s'", i,
+                                        buffer->physical_addr, display->name);
+                                continue;
+                        }
+
+                        buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
+
+                        if (!buffer) {
+                                /*
+                                 * FIXME: If one buffer allocation fails,
+                                 * deallocate flip chain and buffers
+                                 */
+                                ERR_PRINT("Out of memory");
+                                return 1;
+                        }
+
+                        buffer->physical_addr = framebuffer->fix.smem_start +
+                                (buffer_size * i);
+                        buffer->virtual_addr =
+                                (unsigned long) framebuffer->screen_base +
+                                (buffer_size * i);
+                        buffer->size = buffer_size;
+                        buffer->display = display;
+                        flip_chain->buffers[i] = buffer;
+
+                        DBG_PRINT("Flip chain buffer %i has address %lx for"
+                                " display '%s'", i, buffer->physical_addr,
+                                display->name);
+                }
+
+                display->flip_chain = flip_chain;
+                return 0;
+        } else {
+                ERR_PRINT("Framebuffer %i doesn't exist for display '%s'",
+                        fb_idx, display->name);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int destroy_flip_chain(struct omap_display_device *display)
+{
+        int i;
+        int err;
+
+        if (!display->flip_chain) {
+                DBG_PRINT("No flip chain to destroy for '%s'", display->name);
+                return 0;
+        }
+
+        for (i = 0; i < display->flip_chain->buffer_count; i++) {
+                struct omap_display_buffer *buffer =
+                        display->flip_chain->buffers[i];
+                /* If buffer is main buffer don't touch it */
+                if (display->main_buffer == buffer)
+                        continue;
+
+                err = display_destroy_buffer(buffer);
+                if (err) {
+                        ERR_PRINT("Error destroying buffer in flip chain for"
+                        " '%s'", display->name);
+                        return 1;
+                }
+        }
+
+        DBG_PRINT("Destroying flip chain for '%s'", display->name);
+        kfree(display->flip_chain);
+        display->flip_chain = 0;
+
+        return 0;
+}
+
+static int rotate_display(struct omap_display_device *display,
+        unsigned int rotation)
+{
+        ERR_PRINT("Not supported yet");
+        return 1;
+}
+
+static int display_destroy_buffer(struct omap_display_buffer *buffer)
+{
+        kfree(buffer);
+        return 0;
+}
+
+static int present_buffer_virtual(struct omap_display_buffer *buffer)
+{
+        /*
+         * TODO: Support for ORIENTATION_VERTICAL is in place,
+         * ORIENTATION_HORIZONTAL is missing
+         */
+        struct omap_display_device *display_virtual = buffer->display;
+        struct omap_display_device *display_primary;
+        struct omap_display_device *display_secondary;
+        struct omap_display_buffer temp_buffer;
+        unsigned int buffer_offset;
+
+        if (display_virtual->id != OMAP_DISPID_VIRTUAL) {
+                ERR_PRINT("Not a virtual display");
+                BUG();
+        }
+
+        display_primary = omap_display_get(OMAP_DISPID_PRIMARY);
+        display_secondary = omap_display_get(OMAP_DISPID_SECONDARY);
+        /*
+         * Calculate offset without page alignment round up otherwise second
+         * display may see incorrect data
+         */
+        buffer_offset = display_primary->height * display_virtual->byte_stride;
+
+        /* The first buffer will be the base */
+        temp_buffer.physical_addr = buffer->physical_addr;
+        temp_buffer.virtual_addr = buffer->virtual_addr;
+        temp_buffer.size = buffer->size >> 1;
+
+        if (display_virtual->features & ORIENTATION_INVERT) {
+                /* Secondary display has the base */
+                temp_buffer.display = display_secondary;
+                display_secondary->present_buffer(&temp_buffer);
+        } else {
+                /* Primary display has the base */
+                temp_buffer.display = display_primary;
+                display_primary->present_buffer(&temp_buffer);
+        }
+
+        /* Remaining display will show the rest */
+        temp_buffer.physical_addr = buffer->physical_addr + buffer_offset;
+        temp_buffer.virtual_addr = buffer->virtual_addr + buffer_offset;
+
+        if (display_virtual->features & ORIENTATION_INVERT) {
+                temp_buffer.display = display_primary;
+                display_primary->present_buffer(&temp_buffer);
+        } else {
+                temp_buffer.display = display_secondary;
+                display_secondary->present_buffer(&temp_buffer);
+        }
+
+        return 0;
+}
+
+static int present_buffer(struct omap_display_buffer *buffer)
+{
+        struct omap_display_device *display = buffer->display;
+        int fb_idx;
+
+        switch (display->id) {
+        case OMAP_DISPID_PRIMARY:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_SECONDARY:
+                fb_idx = 1;
+                break;
+        case OMAP_DISPID_TERTIARY:
+                fb_idx = 2;
+                break;
+        case OMAP_DISPID_VIRTUAL:
+        case OMAP_DISPID_BADSTATE:
+        default:
+                ERR_PRINT("Unable to handle display %i", display->id);
+                BUG();
+        }
+
+        if (fb_idx >= 0 && fb_idx < num_registered_fb) {
+                struct fb_info *framebuffer = registered_fb[fb_idx];
+                struct omapfb_info *ofbi = FB2OFB(framebuffer);
+                struct omapfb2_device *fbdev = ofbi->fbdev;
+                struct omap_overlay *overlay;
+                struct omap_overlay_info overlay_info;
+                int i;
+
+                omapfb_lock(fbdev);
+
+                /* Get the overlays attached to the framebuffer */
+                for (i = 0; i < ofbi->num_overlays ; i++) {
+                        overlay = ofbi->overlays[i];
+                        overlay->get_overlay_info(overlay, &overlay_info);
+
+                        /* If the overlay is not enabled don't update it */
+                        if (!overlay_info.enabled)
+                                continue;
+
+                        overlay_info.paddr = buffer->physical_addr;
+                        overlay_info.vaddr = (void *) buffer->virtual_addr;
+                        overlay->set_overlay_info(overlay, &overlay_info);
+
+                        if (overlay->manager) {
+                                overlay->manager->apply(overlay->manager);
+                                if (overlay->manager->device &&
+                                        overlay->manager->device->update) {
+                                        overlay->manager->device->update(
+                                                overlay->manager->device,
+                                                0, 0,
+                                                overlay_info.width,
+                                                overlay_info.height);
+                                }
+                        }
+                }
+
+                omapfb_unlock(fbdev);
+        } else {
+                ERR_PRINT("Framebuffer %i doesn't exist for display '%s'",
+                        fb_idx, display->name);
+                return 1;
+        }
+
+        return 0;
+}
+
+static u32 get_dss_irq(struct omap_dss_device *dss_device)
+{
+        u32 irq;
+
+        if (dss_device->type == OMAP_DISPLAY_TYPE_VENC)
+                irq = DISPC_IRQ_EVSYNC_ODD;
+        else if (dss_device->type == OMAP_DISPLAY_TYPE_HDMI)
+                irq = DISPC_IRQ_EVSYNC_EVEN;
+        else if (dss_device->type == OMAP_DISPLAY_TYPE_DSI)
+                if (!strcmp(dss_device->name, "lcd"))
+                        irq = DISPC_IRQ_FRAMEDONE;
+                else
+                        irq = DISPC_IRQ_FRAMEDONE2;
+        else
+                if (!strcmp(dss_device->name, "lcd"))
+                        irq = DISPC_IRQ_VSYNC;
+                else
+                        irq = DISPC_IRQ_VSYNC2;
+
+        return irq;
+}
+
+static int present_buffer_sync(struct omap_display_buffer *buffer)
+{
+        /* TODO: Cloning may tear with this implementation */
+        int err = 0;
+        struct omap_display_device *display = buffer->display;
+
+        err = display->sync(display);
+        err |= display->present_buffer(buffer);
+
+        return err;
+}
+
+static int present_buffer_sync_virtual(struct omap_display_buffer *buffer)
+{
+        void display_irq_wait_1(void *data, u32 mask)
+        {
+                struct omap_display_sync_item *sync_item =
+                        (struct omap_display_sync_item *) data;
+
+                if (sync_item->invalidate)
+                        return;
+
+                /* IRQ happened, present immediately */
+                sync_item->invalidate = 1;
+                sync_item->buffer->display->present_buffer(sync_item->buffer);
+                complete(sync_item->task);
+        }
+
+        void display_irq_wait_2(void *data, u32 mask)
+        {
+                struct omap_display_sync_item *sync_item =
+                        (struct omap_display_sync_item *) data;
+
+                if (sync_item->invalidate)
+                        return;
+
+                /* IRQ happened, present immediately */
+                sync_item->invalidate = 1;
+                sync_item->buffer->display->present_buffer(sync_item->buffer);
+                complete(sync_item->task);
+        }
+
+        /*
+         * TODO: Support for ORIENTATION_VERTICAL is in place,
+         * ORIENTATION_HORIZONTAL is missing. Some code can be reduced here,
+         * it will be simplified in the future.
+         */
+        struct omap_display_device *display_virtual = buffer->display;
+        struct omap_display_device *display_primary;
+        struct omap_display_device *display_secondary;
+        struct omap_display_buffer temp_buffer_top;
+        struct omap_display_buffer temp_buffer_bottom;
+        struct omap_display_sync_item sync_item_primary;
+        struct omap_display_sync_item sync_item_secondary;
+        DECLARE_COMPLETION_ONSTACK(completion_primary);
+        DECLARE_COMPLETION_ONSTACK(completion_secondary);
+        unsigned int buffer_offset;
+
+        if (display_virtual->id != OMAP_DISPID_VIRTUAL) {
+                ERR_PRINT("Not a virtual display");
+                BUG();
+        }
+
+        display_primary = omap_display_get(OMAP_DISPID_PRIMARY);
+        display_secondary = omap_display_get(OMAP_DISPID_SECONDARY);
+        /*
+         * Calculate offset without page alignment round up otherwise second
+         * display may see incorrect data
+         */
+        buffer_offset = display_primary->height * display_virtual->byte_stride;
+
+        /* The first buffer will be the top */
+        temp_buffer_top.physical_addr = buffer->physical_addr;
+        temp_buffer_top.virtual_addr = buffer->virtual_addr;
+        temp_buffer_top.size = buffer->size >> 1;
+        /* Then the bottom */
+        temp_buffer_bottom.physical_addr = buffer->physical_addr +
+                buffer_offset;
+        temp_buffer_bottom.virtual_addr = buffer->virtual_addr + buffer_offset;
+        temp_buffer_bottom.size = buffer->size >> 1;
+
+        if (display_virtual->features & ORIENTATION_INVERT) {
+                /* Secondary display has the base */
+                temp_buffer_top.display = display_secondary;
+                temp_buffer_bottom.display = display_primary;
+                sync_item_primary.buffer = &temp_buffer_bottom;
+                sync_item_secondary.buffer = &temp_buffer_top;
+
+        } else {
+                /* Primary display has the base */
+                temp_buffer_top.display = display_primary;
+                temp_buffer_bottom.display = display_secondary;
+                sync_item_primary.buffer = &temp_buffer_top;
+                sync_item_secondary.buffer = &temp_buffer_bottom;
+        }
+
+        sync_item_primary.task = &completion_primary;
+        sync_item_secondary.task = &completion_secondary;
+        sync_item_primary.invalidate = 0;
+        sync_item_secondary.invalidate = 0;
+
+        /* Register an ISR per display with its corresponding IRQ */
+        omap_dispc_register_isr(display_irq_wait_1, &sync_item_primary,
+                get_dss_irq(display_primary->overlay_managers[0]->device));
+
+        omap_dispc_register_isr(display_irq_wait_2, &sync_item_secondary,
+                get_dss_irq(display_secondary->overlay_managers[0]->device));
+
+        /* Wait until each display sync and present */
+        wait_for_completion_interruptible_timeout(&completion_primary,
+                        OMAP_DISP_IRQ_TIMEOUT);
+        wait_for_completion_interruptible_timeout(&completion_secondary,
+                        OMAP_DISP_IRQ_TIMEOUT);
+
+        /* Unregister ISRs */
+        omap_dispc_unregister_isr(display_irq_wait_1, &sync_item_primary,
+                get_dss_irq(display_primary->overlay_managers[0]->device));
+
+        omap_dispc_unregister_isr(display_irq_wait_2, &sync_item_secondary,
+                get_dss_irq(display_secondary->overlay_managers[0]->device));
+
+        return 0;
+}
+
+static int display_sync(struct omap_display_device *display)
+{
+        /* TODO: Synchronize properly with multiple managers */
+        struct omap_dss_device *dss_device =
+                display->overlay_managers[0]->device;
+        if (!dss_device || !dss_device->wait_vsync) {
+                ERR_PRINT("Unable to synchronize with '%s'", display->name);
+                return 1;
+        }
+        dss_device->wait_vsync(dss_device);
+        return 0;
+}
+
+static int display_sync_virtual(struct omap_display_device *display_virtual)
+{
+        void display_irq_wait(void *data, u32 mask)
+        {
+                complete((struct completion *)data);
+        }
+
+        /*
+         * Return as soon as one display generates an IRQ
+         */
+        struct omap_display_device *display_primary;
+        struct omap_display_device *display_secondary;
+        u32 irq_primary;
+        u32 irq_secondary;
+        u32 irq_mask;
+        DECLARE_COMPLETION_ONSTACK(completion);
+
+        if (display_virtual->id != OMAP_DISPID_VIRTUAL) {
+                ERR_PRINT("Not a virtual display");
+                BUG();
+        }
+
+        display_primary = omap_display_get(OMAP_DISPID_PRIMARY);
+        display_secondary = omap_display_get(OMAP_DISPID_SECONDARY);
+
+        irq_primary = get_dss_irq(
+                display_primary->overlay_managers[0]->device);
+
+        irq_secondary = get_dss_irq(
+                display_secondary->overlay_managers[0]->device);
+
+        irq_mask = irq_primary | irq_secondary;
+
+        /* Register an ISR with both IRQs and wait, then unregister */
+        omap_dispc_register_isr(display_irq_wait, &completion, irq_mask);
+
+        wait_for_completion_interruptible_timeout(&completion,
+                OMAP_DISP_IRQ_TIMEOUT);
+
+        omap_dispc_unregister_isr(display_irq_wait, &completion, irq_mask);
+
+        return 0;
+}
+
+static struct omap_display_buffer *create_main_buffer(
+        struct omap_display_device *display)
+{
+        int fb_idx;
+        switch (display->id) {
+        case OMAP_DISPID_PRIMARY:
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_SECONDARY:
+                fb_idx = 1;
+                break;
+        case OMAP_DISPID_TERTIARY:
+                fb_idx = 2;
+                break;
+        case OMAP_DISPID_VIRTUAL:
+                /* Use fb0 for virtual display */
+                fb_idx = 0;
+                break;
+        case OMAP_DISPID_BADSTATE:
+        default:
+                ERR_PRINT("Unknown display id %i", display->id);
+                BUG();
+        }
+
+        /* Use the framebuffer memory */
+        if (fb_idx >= 0 && fb_idx < num_registered_fb) {
+                struct fb_info *framebuffer = registered_fb[fb_idx];
+                unsigned long buffer_size;
+                struct omap_display_buffer *buffer;
+
+                if (!framebuffer || !framebuffer->fix.smem_start ||
+                        !framebuffer->screen_base) {
+                        ERR_PRINT("Framebuffer %i doesn't seem to be "
+                                "initialized", fb_idx);
+                        return NULL;
+                }
+
+                /*
+                 * Check if there is enough memory in the fb for the
+                 * main buffer
+                 */
+                buffer_size = display->width * display->height *
+                        display->bytes_per_pixel;
+                /* Page align the buffer size */
+                buffer_size = OMAP_DISP_PAGE_ROUND_UP(buffer_size);
+
+                if (buffer_size > framebuffer->fix.smem_len) {
+                        ERR_PRINT("Main buffer needs %lu bytes while the "
+                                "framebuffer %i has only %lu bytes for display"
+                                " '%s'", buffer_size, fb_idx,
+                                (unsigned long)framebuffer->fix.smem_len,
+                                display->name);
+                        return NULL;
+                }
+
+                buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
+
+                if (!buffer) {
+                        ERR_PRINT("Out of memory");
+                        return NULL;
+                }
+
+                /* Use base addresses reported by the framebuffer */
+                buffer->physical_addr = framebuffer->fix.smem_start;
+                buffer->virtual_addr =
+                        (unsigned long) framebuffer->screen_base;
+                buffer->size = buffer_size;
+                buffer->display = display;
+
+                DBG_PRINT("Created main buffer %lx for display '%s'",
+                        buffer->physical_addr, display->name);
+
+                return buffer;
+        } else {
+                ERR_PRINT("Framebuffer %i doesn't exist for display '%s'",
+                        fb_idx, display->name);
+                return NULL;
+        }
+}
+
+static int populate_display_info(struct omap_display_device *display,
+        struct omap_overlay_manager *overlay_manager)
+{
+        struct omap_dss_device *dss_device = overlay_manager->device;
+        u16 xres;
+        u16 yres;
+        int i;
+
+        if (!strcmp(dss_device->name, "lcd")) {
+                display->id = OMAP_DISPID_PRIMARY;
+                display->name = "primary";
+        } else if (!strcmp(dss_device->name, "2lcd")) {
+                display->id = OMAP_DISPID_SECONDARY;
+                display->name = "secondary";
+        } else if (!strcmp(dss_device->name, "hdmi")) {
+                display->id = OMAP_DISPID_TERTIARY;
+                display->name = "tertiary";
+        } else {
+                ERR_PRINT("Display id '%s' not supported", dss_device->name);
+                return 1;
+        }
+
+        dss_device->get_resolution(dss_device, &xres, &yres);
+        if (xres == 0 || yres == 0) {
+                ERR_PRINT("Unable to handle display '%s' with width %i "
+                "and height %i", dss_device->name, xres, yres);
+                return 1;
+        }
+
+        display->width = xres;
+        display->height = yres;
+
+        display->bits_per_pixel = dss_device->get_recommended_bpp(dss_device);
+        switch (display->bits_per_pixel) {
+        case 16:
+                /*
+                 * TODO: Asume RGB_565, maybe need to double check in
+                 * the DSS if this is true
+                 */
+                display->pixel_format = RGB_565;
+                display->bytes_per_pixel = 2;
+                break;
+        case 24: /* 24 bits are encapsulated with 32 bits */
+        case 32:
+                /*
+                 * TODO: Asume ARGB_8888, maybe need to double check in
+                 * the DSS if this is true
+                 */
+                display->pixel_format = ARGB_8888;
+                display->bytes_per_pixel = 4;
+                break;
+        default:
+                ERR_PRINT("Unable to handle %i bpp", display->bits_per_pixel);
+                return 1;
+        }
+
+        display->byte_stride = display->bytes_per_pixel * display->width;
+        display->rotation = OMAP_DSS_ROT_0; /* Asume rotation 0 degrees */
+        display->main_buffer = 0;
+        display->flip_chain = 0;
+
+        /* Add the manager to the list */
+        for (i = 0; i < OMAP_DISP_MAX_MANAGERS; i++)
+                display->overlay_managers[i] = 0;
+
+        display->overlay_managers[0] = overlay_manager;
+        display->overlay_managers_count = 1;
+
+        /* Assign function pointers for display operations */
+        display->open = open_display;
+        display->close = close_display;
+        display->create_flip_chain = create_flip_chain;
+        display->destroy_flip_chain = destroy_flip_chain;
+        display->rotate = rotate_display;
+        display->present_buffer = present_buffer;
+        display->sync = display_sync;
+        display->present_buffer_sync = present_buffer_sync;
+
+        display->main_buffer = create_main_buffer(display);
+        if (!display->main_buffer)
+                WRN_PRINT("Failed to create main buffer for '%s'",
+                        display->name);
+
+        display->buffers_available = get_max_buffers(display);
+
+        /* Just print some display info */
+        DBG_PRINT("Found display '%s-%s' (%i,%i) %i bpp (%i bytes per pixel)"
+                " rotation %i", display->name, dss_device->name,
+                display->width, display->height, display->bits_per_pixel,
+                display->bytes_per_pixel, display->rotation);
+
+        return 0;
+}
+
+static int populate_virtual_display_info(struct omap_display_device *display)
+{
+        struct omap_display_device *display_primary ;
+        struct omap_display_device *display_secondary;
+        int i;
+
+        display->id = OMAP_DISPID_VIRTUAL;
+        display->name = "virtual";
+
+        display_primary = omap_display_get(OMAP_DISPID_PRIMARY);
+        display_secondary = omap_display_get(OMAP_DISPID_SECONDARY);
+
+        if (!display_primary) {
+                ERR_PRINT("Primary display doesn't exist");
+                return 1;
+        } else if (!display_secondary) {
+                ERR_PRINT("Secondary display doesn't exist");
+                return 1;
+        }
+
+        /* Combine primary and secondary display resolutions */
+        if (display_primary->width != display_secondary->width ||
+                display_primary->height != display_secondary->height) {
+                ERR_PRINT("Primary and seconday displays resolution are not"
+                        " the same");
+                return 1;
+        }
+
+        /*
+         * TODO: Here it is hardcoded the resolution asumming a vertical
+         * virtual config, what about horizontal?
+         */
+        display->width = display_primary->width;
+        display->height = display_primary->height * 2;
+
+        if (display_primary->bits_per_pixel !=
+                display_secondary->bits_per_pixel) {
+                ERR_PRINT("Primary and seconday displays format are"
+                        " not the same");
+                return 1;
+        }
+
+        display->bits_per_pixel = display_primary->bits_per_pixel;
+        switch (display->bits_per_pixel) {
+        case 16:
+                /*
+                 * TODO: Asume RGB_565, maybe need to double check in
+                 * the DSS if this is true
+                 */
+                display->pixel_format = RGB_565;
+                display->bytes_per_pixel = 2;
+                break;
+        case 24: /* 24 bits are encapsulated with 32 bits */
+        case 32:
+                /*
+                 * TODO: Asume ARGB_8888, maybe need to double check in
+                 * the DSS if this is true
+                 */
+                display->pixel_format = ARGB_8888;
+                display->bytes_per_pixel = 4;
+                break;
+        default:
+                ERR_PRINT("Unable to handle %i bpp",
+                        display->bits_per_pixel);
+                return 1;
+        }
+
+        /* TODO: Asumming a vertical virtual config too for stride */
+        display->byte_stride = display->bytes_per_pixel * display->width;
+        display->rotation = OMAP_DSS_ROT_0; /* Asume rotation 0 degrees */
+        display->main_buffer = 0;
+        display->flip_chain = 0;
+
+        /* Add the primary and secondary overlay managers */
+        for (i = 0; i < OMAP_DISP_MAX_MANAGERS; i++)
+                display->overlay_managers[i] = 0;
+
+        display->overlay_managers[0] = display_primary->overlay_managers[0];
+        display->overlay_managers[1] = display_secondary->overlay_managers[0];
+        display->overlay_managers_count = 2;
+
+        /* Assign function pointers for display operations */
+        display->open = open_display;
+        display->close = close_display;
+        display->create_flip_chain = create_flip_chain;
+        display->destroy_flip_chain = destroy_flip_chain;
+        display->rotate = rotate_display;
+        display->present_buffer = present_buffer_virtual;
+        display->sync = display_sync_virtual;
+        display->present_buffer_sync = present_buffer_sync_virtual;
+
+        display->main_buffer = create_main_buffer(display);
+        if (!display->main_buffer)
+                WRN_PRINT("Failed to create main buffer for '%s'",
+                        display->name);
+
+        display->buffers_available = get_max_buffers(display);
+
+        /* Just print some display info */
+        DBG_PRINT("Found display '%s' (%i,%i) %i bpp (%i bytes per pixel)"
+                " rotation %i", display->name, display->width, display->height,
+                display->bits_per_pixel, display->bytes_per_pixel,
+                display->rotation);
+
+        return 0;
+}
+
+static int create_display_list(void)
+{
+        int i;
+        unsigned int bytes_to_alloc;
+        struct omap_display_device *display;
+
+        /* Query number of possible displays available first */
+        omap_display_number = omap_dss_get_num_overlay_managers();
+        /* For virtual display */
+        omap_display_number++;
+
+        /* Allocate custom display list */
+        omap_display_list = kzalloc(
+                sizeof(*display) * omap_display_number, GFP_KERNEL);
+
+        if (!omap_display_list) {
+                ERR_PRINT("Out of memory");
+                return 1;
+        }
+
+        /* Populate each display info */
+        for (i = 0; i < omap_display_number - 1; i++) {
+                struct omap_overlay_manager *overlay_manager =
+                        omap_dss_get_overlay_manager(i);
+                display = &omap_display_list[i];
+                if (!overlay_manager->device) {
+                        WRN_PRINT("Display '%s' doesn't have a dss device "
+                                "attached to it, ignoring",
+                                overlay_manager->name);
+                        display->id = OMAP_DISPID_BADSTATE;
+                        continue;
+                }
+                if (populate_display_info(display, overlay_manager)) {
+                        ERR_PRINT("Error populating display %i info with "
+                                "manager '%s'", i,
+                                overlay_manager->device->name);
+                        display->id = OMAP_DISPID_BADSTATE;
+                        continue;
+                }
+        }
+
+        /* Populate virtual display */
+        display = &omap_display_list[omap_display_number - 1];
+        if (populate_virtual_display_info(display)) {
+                ERR_PRINT("Error populating virtual display info");
+                display->id = OMAP_DISPID_BADSTATE;
+        }
+
+        return 0;
+}
+
+struct omap_display_device *omap_display_get(enum omap_display_id id)
+{
+        int i;
+        struct omap_display_device *display;
+
+        if (id == OMAP_DISPID_BADSTATE) {
+                ERR_PRINT("Oops.. user must never request a bad display");
+                BUG();
+        }
+
+        for (i = 0; i < omap_display_number; i++) {
+                display = &omap_display_list[i];
+                if (display->id == id)
+                        return display;
+        }
+
+        ERR_PRINT("Unknown display %i requested", id);
+        return 0;
+}
+EXPORT_SYMBOL(omap_display_get);
+
+int omap_display_count(void)
+{
+        return omap_display_number;
+}
+EXPORT_SYMBOL(omap_display_count);
+
+int omap_display_init(void)
+{
+        /*
+         * TODO: Is there a better way to check if list is already created?
+         */
+        if (!omap_display_list) {
+                DBG_PRINT("Initializing driver");
+                if (create_display_list()) {
+                        ERR_PRINT("Error loading driver");
+                        return 1;
+                }
+        }
+        return 0;
+}
+EXPORT_SYMBOL(omap_display_init);
+
+int omap_display_deinit(void)
+{
+        int i;
+        int err = 0;
+        DBG_PRINT("Driver exiting");
+
+        for (i = 0; i < omap_display_number; i++) {
+                struct omap_display_device *display = &omap_display_list[i];
+
+                if (!display)
+                        continue;
+
+                if (display->main_buffer) {
+                        err = display_destroy_buffer(display->main_buffer);
+                        display->main_buffer = 0;
+                        if (err)
+                                WRN_PRINT("An error happened when destroying "
+                                        "main buffer for '%s'", display->name);
+                }
+
+                err = display->close(display);
+
+                if (err)
+                        ERR_PRINT("Unable to close display '%s'",
+                                display->name);
+        }
+
+        kfree(omap_display_list);
+        omap_display_list = 0;
+
+        return err;
+}
+EXPORT_SYMBOL(omap_display_deinit);
+
diff --git a/drivers/gpu/pvr/display/omap_display.h b/drivers/gpu/pvr/display/omap_display.h
new file mode 100644
index 00000000000..13916a9461f
--- /dev/null
+++ b/drivers/gpu/pvr/display/omap_display.h
@@ -0,0 +1,109 @@
+/*
+ * drivers/gpu/pvr/display/omap_display.h
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <plat/vrfb.h>
+#include <plat/display.h>
+#include <linux/completion.h>
+
+#ifndef __OMAP_DISPLAY_H_
+#define __OMAP_DISPLAY_H_
+
+/* Max overlay managers for virtual display */
+#define OMAP_DISP_MAX_MANAGERS 2
+/* 3 for triple buffering, 4 for virtual display */
+#define OMAP_DISP_MAX_FLIPCHAIN_BUFFERS 4
+#define OMAP_DISP_NUM_DISPLAYS 4 /* lcd, 2lcd, tv, virtual */
+
+struct omap_display_device;
+
+/* On OMAP 4 we can only manage 3 displays at the same time + virtual */
+enum omap_display_id {
+        OMAP_DISPID_PRIMARY = 1 << 0,
+        OMAP_DISPID_SECONDARY = 1 << 1,
+        OMAP_DISPID_TERTIARY = 1 << 2,
+        OMAP_DISPID_VIRTUAL = 1 << 15, /* Multiple displays */
+        OMAP_DISPID_BADSTATE = 1 << 30, /* Used to say a display is unusable*/
+};
+
+enum omap_display_pixel_format {
+        RGB_565 = 0,
+        ARGB_8888  = 1,
+};
+
+/* Primary display location for virtual display */
+enum omap_display_feature {
+        ORIENTATION_VERTICAL = 1 << 0,
+        ORIENTATION_HORIZONTAL = 1 << 1,
+        ORIENTATION_INVERT = 1 << 2,
+};
+
+struct omap_display_buffer {
+        unsigned long physical_addr;
+        unsigned long virtual_addr;
+        unsigned long size;
+        struct omap_display_device *display;
+};
+
+struct omap_display_flip_chain {
+        int buffer_count;
+        struct omap_display_buffer *buffers[OMAP_DISP_MAX_FLIPCHAIN_BUFFERS];
+        struct omap_display_device *display;
+};
+
+struct omap_display_sync_item {
+        struct omap_display_buffer *buffer;
+        struct completion *task;
+        int invalidate;
+};
+
+struct omap_display_device {
+        char *name;
+        enum omap_display_id id;
+        enum omap_display_pixel_format pixel_format;
+        enum omap_display_feature features;
+        unsigned int width;
+        unsigned int height;
+        unsigned int bits_per_pixel;
+        unsigned int bytes_per_pixel;
+        unsigned int byte_stride;
+        enum omap_dss_rotation_angle rotation;
+        unsigned int reference_count;
+        unsigned int buffers_available;
+        struct omap_display_buffer *main_buffer;
+        struct omap_display_flip_chain *flip_chain;
+        struct omap_overlay_manager *overlay_managers[OMAP_DISP_MAX_MANAGERS];
+        unsigned int overlay_managers_count;
+        int (*open)(struct omap_display_device *display,
+                enum omap_display_feature features);
+        int (*close) (struct omap_display_device *display);
+        int (*create_flip_chain) (struct omap_display_device *display,
+                unsigned int buffer_count);
+        int (*destroy_flip_chain) (struct omap_display_device *display);
+        int (*rotate) (struct omap_display_device *display,
+                enum omap_dss_rotation_angle rotation);
+        int (*present_buffer) (struct omap_display_buffer *buffer);
+        int (*sync) (struct omap_display_device *display);
+        int (*present_buffer_sync) (struct omap_display_buffer *buffer);
+};
+
+int omap_display_init(void);
+int omap_display_deinit(void);
+int omap_display_count(void);
+struct omap_display_device *omap_display_get(enum omap_display_id id);
+
+#endif
diff --git a/drivers/gpu/pvr/display/omap_sgx_displayclass.c b/drivers/gpu/pvr/display/omap_sgx_displayclass.c
new file mode 100644
index 00000000000..7b493f1d94e
--- /dev/null
+++ b/drivers/gpu/pvr/display/omap_sgx_displayclass.c
@@ -0,0 +1,1638 @@
+/*************************************************************************
+ *
+ * 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/module.h>
+#include <linux/string.h>
+#include <linux/notifier.h>
+
+#if defined(LDM_PLATFORM)
+#include <linux/platform_device.h>
+#if defined(SGX_EARLYSUSPEND)
+#include <linux/earlysuspend.h>
+#endif
+#endif
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omap_sgx_displayclass.h"
+#include "omap_display.h"
+
+/* XXX: Expect 2 framebuffers for virtual display */
+#if (CONFIG_FB_OMAP2_NUM_FBS < 2)
+#error "Virtual display is supported only with 2 or more framebuffers, \
+CONFIG_FB_OMAP2_NUM_FBS must be equal or greater than 2 \
+see CONFIG_FB_OMAP2_NUM_FBS for details in the kernel config"
+#endif
+
+#define OMAP_DC_CMD_COUNT               1
+#define MAX_BUFFERS_FLIPPING            4
+
+/* Pointer Display->Services */
+static PFN_DC_GET_PVRJTABLE pfnGetPVRJTable = NULL;
+
+/* Pointer to the display devices */
+static struct OMAP_DISP_DEVINFO *pDisplayDevices = NULL;
+static int display_devices_count = 0;
+
+static void display_sync_handler(struct work_struct *work);
+static enum OMAP_ERROR get_pvr_dc_jtable (char *szFunctionName,
+        PFN_DC_GET_PVRJTABLE *ppfnFuncTable);
+
+
+/*
+ * Swap to display buffer. This buffer refers to one inside the
+ * framebuffer memory.
+ * in: hDevice, hBuffer, ui32SwapInterval, hPrivateTag, ui32ClipRectCount,
+ * psClipRect
+ */
+static PVRSRV_ERROR SwapToDCBuffer(IMG_HANDLE hDevice,
+                                   IMG_HANDLE hBuffer,
+                                   IMG_UINT32 ui32SwapInterval,
+                                   IMG_HANDLE hPrivateTag,
+                                   IMG_UINT32 ui32ClipRectCount,
+                                   IMG_RECT *psClipRect)
+{
+        /* Nothing to do */
+        return PVRSRV_OK;
+}
+
+/*
+ * Set display destination rectangle.
+ * in: hDevice, hSwapChain, psRect
+ */
+static PVRSRV_ERROR SetDCDstRect(IMG_HANDLE hDevice,
+        IMG_HANDLE hSwapChain,
+        IMG_RECT *psRect)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display source rectangle.
+ * in: hDevice, hSwapChain, psRect
+ */
+static PVRSRV_ERROR SetDCSrcRect(IMG_HANDLE hDevice,
+                                 IMG_HANDLE hSwapChain,
+                                 IMG_RECT *psRect)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display destination colour key.
+ * in: hDevice, hSwapChain, ui32CKColour
+ */
+static PVRSRV_ERROR SetDCDstColourKey(IMG_HANDLE hDevice,
+                                      IMG_HANDLE hSwapChain,
+                                      IMG_UINT32 ui32CKColour)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display source colour key.
+ * in: hDevice, hSwapChain, ui32CKColour
+ */
+static PVRSRV_ERROR SetDCSrcColourKey(IMG_HANDLE hDevice,
+                                      IMG_HANDLE hSwapChain,
+                                      IMG_UINT32 ui32CKColour)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Closes the display.
+ * in: hDevice
+ */
+static PVRSRV_ERROR CloseDCDevice(IMG_HANDLE hDevice)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo =
+                (struct OMAP_DISP_DEVINFO*) hDevice;
+        struct omap_display_device *display = psDevInfo->display;
+
+        if(display->close(display))
+                WARNING_PRINTK("Unable to close properly display '%s'",
+                        display->name);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Flushes the sync queue present in the specified swap chain.
+ * in: psSwapChain
+ */
+static void FlushInternalSyncQueue(struct OMAP_DISP_SWAPCHAIN *psSwapChain)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo =
+                (struct OMAP_DISP_DEVINFO*) psSwapChain->pvDevInfo;
+        struct OMAP_DISP_FLIP_ITEM *psFlipItem;
+        struct omap_display_device *display = psDevInfo->display;
+        unsigned long            ulMaxIndex;
+        unsigned long            i;
+
+        psFlipItem = &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+        DEBUG_PRINTK("Flushing sync queue on display %lu",
+                psDevInfo->ulDeviceID);
+        for(i = 0; i < psSwapChain->ulBufferCount; i++)
+        {
+                if (psFlipItem->bValid == OMAP_FALSE)
+                        continue;
+
+                DEBUG_PRINTK("Flushing swap buffer index %lu",
+                        psSwapChain->ulRemoveIndex);
+
+                /* Flip the buffer if it hasn't been flipped */
+                if(psFlipItem->bFlipped == OMAP_FALSE)
+                {
+                        display->present_buffer(psFlipItem->display_buffer);
+                }
+
+                /* If the command didn't complete, assume it did */
+                if(psFlipItem->bCmdCompleted == OMAP_FALSE)
+                {
+                        DEBUG_PRINTK("Calling command complete for swap "
+                                "buffer index %lu",
+                                psSwapChain->ulRemoveIndex);
+                        psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(
+                                (IMG_HANDLE)psFlipItem->hCmdComplete,
+                                IMG_TRUE);
+                }
+
+                psSwapChain->ulRemoveIndex++;
+                if(psSwapChain->ulRemoveIndex > ulMaxIndex)
+                        psSwapChain->ulRemoveIndex = 0;
+
+                /* Put the state of the buffer to be used again later */
+                psFlipItem->bFlipped = OMAP_FALSE;
+                psFlipItem->bCmdCompleted = OMAP_FALSE;
+                psFlipItem->bValid = OMAP_FALSE;
+                psFlipItem =
+                        &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        }
+
+        psSwapChain->ulInsertIndex = 0;
+        psSwapChain->ulRemoveIndex = 0;
+}
+
+/*
+ * Sets the flush state of the specified display device
+ * at the swap chain level without blocking the call.
+ * in: psDevInfo, bFlushState
+ */
+static void SetFlushStateInternalNoLock(struct OMAP_DISP_DEVINFO* psDevInfo,
+                                        enum OMAP_BOOL bFlushState)
+{
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain = psDevInfo->psSwapChain;
+
+        /* Nothing to do if there is no swap chain */
+        if (psSwapChain == NULL){
+                DEBUG_PRINTK("Swap chain is null, nothing to do for"
+                        " display %lu", psDevInfo->ulDeviceID);
+                return;
+        }
+
+        if (bFlushState)
+        {
+                DEBUG_PRINTK("Desired flushState is true for display %lu",
+                        psDevInfo->ulDeviceID);
+                if (psSwapChain->ulSetFlushStateRefCount == 0)
+                {
+                        psSwapChain->bFlushCommands = OMAP_TRUE;
+                        FlushInternalSyncQueue(psSwapChain);
+                }
+                psSwapChain->ulSetFlushStateRefCount++;
+        }
+        else
+        {
+                DEBUG_PRINTK("Desired flushState is false for display %lu",
+                        psDevInfo->ulDeviceID);
+                if (psSwapChain->ulSetFlushStateRefCount != 0)
+                {
+                        psSwapChain->ulSetFlushStateRefCount--;
+                        if (psSwapChain->ulSetFlushStateRefCount == 0)
+                        {
+                                psSwapChain->bFlushCommands = OMAP_FALSE;
+                        }
+                }
+        }
+}
+
+/*
+ * Sets the flush state of the specified display device
+ * at device level blocking the call if needed.
+ * in: psDevInfo, bFlushState
+ */
+static void SetFlushStateExternal(struct OMAP_DISP_DEVINFO* psDevInfo,
+                                  enum OMAP_BOOL bFlushState)
+{
+        DEBUG_PRINTK("Executing for display %lu",
+                psDevInfo->ulDeviceID);
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+        if (psDevInfo->bFlushCommands != bFlushState)
+        {
+                psDevInfo->bFlushCommands = bFlushState;
+                SetFlushStateInternalNoLock(psDevInfo, bFlushState);
+        }
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+}
+
+/*
+ * Opens the display.
+ * in: ui32DeviceID, phDevice
+ * out: psSystemBufferSyncData
+ */
+static PVRSRV_ERROR OpenDCDevice(IMG_UINT32 ui32DeviceID,
+                                 IMG_HANDLE *phDevice,
+                                 PVRSRV_SYNC_DATA* psSystemBufferSyncData)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct omap_display_device *display;
+        int i;
+
+        psDevInfo = 0;
+        for(i = 0; i < display_devices_count; i++)
+        {
+                if(ui32DeviceID == (&pDisplayDevices[i])->ulDeviceID)
+                {
+                        psDevInfo = &pDisplayDevices[i];
+                        break;
+                }
+        }
+
+        if(!psDevInfo)
+        {
+                WARNING_PRINTK("Unable to identify display device with id %i",
+                        (int)ui32DeviceID);
+                return OMAP_ERROR_INVALID_DEVICE;
+        }
+
+        psDevInfo->sSystemBuffer.psSyncData = psSystemBufferSyncData;
+        display = psDevInfo->display;
+
+        DEBUG_PRINTK("Opening display %lu '%s'",psDevInfo->ulDeviceID,
+                display->name);
+
+        /* TODO: Explain here why ORIENTATION_VERTICAL is used*/
+        if(display->open(display, ORIENTATION_VERTICAL | ORIENTATION_INVERT))
+                ERROR_PRINTK("Unable to open properly display '%s'",
+                        psDevInfo->display->name);
+
+        display->present_buffer(display->main_buffer);
+
+        /* TODO: Turn on display here? */
+
+        *phDevice = (IMG_HANDLE)psDevInfo;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the available formats for the display.
+ * in: hDevice
+ * out: pui32NumFormats, psFormat
+ */
+static PVRSRV_ERROR EnumDCFormats(IMG_HANDLE hDevice,
+                                  IMG_UINT32 *pui32NumFormats,
+                                  DISPLAY_FORMAT *psFormat)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        if(!hDevice || !pui32NumFormats)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        *pui32NumFormats = 1;
+
+        if(psFormat)
+                psFormat[0] = psDevInfo->sDisplayFormat;
+        else
+                WARNING_PRINTK("Display format is null for"
+                        " display %lu", psDevInfo->ulDeviceID);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the available dimensions for the display.
+ * in: hDevice, psFormat
+ * out: pui32NumDims, psDim
+ */
+static PVRSRV_ERROR EnumDCDims(IMG_HANDLE hDevice,
+                               DISPLAY_FORMAT *psFormat,
+                               IMG_UINT32 *pui32NumDims,
+                               DISPLAY_DIMS *psDim)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        if(!hDevice || !psFormat || !pui32NumDims)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        *pui32NumDims = 1;
+
+        if(psDim)
+                psDim[0] = psDevInfo->sDisplayDim;
+        else
+                WARNING_PRINTK("Display dimensions are null for"
+                        " display %lu", psDevInfo->ulDeviceID);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display framebuffer physical address.
+ * in: hDevice
+ * out: phBuffer
+ */
+static PVRSRV_ERROR GetDCSystemBuffer(IMG_HANDLE hDevice, IMG_HANDLE *phBuffer)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+
+        if(!hDevice || !phBuffer)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        *phBuffer = (IMG_HANDLE)&psDevInfo->sSystemBuffer;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display general information.
+ * in: hDevice
+ * out: psDCInfo
+ */
+static PVRSRV_ERROR GetDCInfo(IMG_HANDLE hDevice, DISPLAY_INFO *psDCInfo)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+
+        if(!hDevice || !psDCInfo)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        *psDCInfo = psDevInfo->sDisplayInfo;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display framebuffer virtual address.
+ * in: hDevice
+ * out: ppsSysAddr, pui32ByteSize, ppvCpuVAddr, phOSMapInfo, pbIsContiguous
+ */
+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)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_BUFFER *psSystemBuffer;
+
+        if(!hDevice || !hBuffer || !ppsSysAddr || !pui32ByteSize )
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        psSystemBuffer = (struct OMAP_DISP_BUFFER *)hBuffer;
+        *ppsSysAddr = &psSystemBuffer->sSysAddr;
+        *pui32ByteSize = (IMG_UINT32)psDevInfo->sSystemBuffer.ulBufferSize;
+
+        if (ppvCpuVAddr)
+                *ppvCpuVAddr = psSystemBuffer->sCPUVAddr;
+
+        if (phOSMapInfo)
+                *phOSMapInfo = (IMG_HANDLE)0;
+
+        if (pbIsContiguous)
+                *pbIsContiguous = IMG_TRUE;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Creates a swap chain. Called when a 3D application begins.
+ * in: hDevice, ui32Flags, ui32BufferCount, psDstSurfAttrib, psSrcSurfAttrib
+ * ui32OEMFlags
+ * out: phSwapChain, ppsSyncData, pui32SwapChainID
+ */
+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)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        struct OMAP_DISP_BUFFER *psBuffer;
+        struct OMAP_DISP_FLIP_ITEM *psFlipItems;
+        IMG_UINT32 i;
+        PVRSRV_ERROR eError;
+        IMG_UINT32 ui32BuffersToSkip;
+        struct omap_display_device *display;
+        int err;
+
+        if(!hDevice || !psDstSurfAttrib || !psSrcSurfAttrib ||
+                !ppsSyncData || !phSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+
+        if (psDevInfo->sDisplayInfo.ui32MaxSwapChains == 0)
+        {
+                ERROR_PRINTK("Unable to operate with 0 MaxSwapChains for"
+                        " display %lu", psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_NOT_SUPPORTED;
+        }
+
+        if(psDevInfo->psSwapChain != NULL)
+        {
+                ERROR_PRINTK("Swap chain already exists for"
+                        " display %lu", psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_FLIP_CHAIN_EXISTS;
+        }
+
+        if(ui32BufferCount > psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers)
+        {
+                ERROR_PRINTK("Too many buffers. Trying to use %u buffers while"
+                        " there is only %u available for display %lu",
+                        (unsigned int)ui32BufferCount,
+                        (unsigned int)psDevInfo->
+                        sDisplayInfo.ui32MaxSwapChainBuffers,
+                        psDevInfo->ulDeviceID);
+                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))
+        {
+                ERROR_PRINTK("Destination surface attributes differ from the"
+                        " current framebuffer for display %lu",
+                        psDevInfo->ulDeviceID);
+                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))
+        {
+                ERROR_PRINTK("Destination surface attributes differ from the"
+                        " target destination surface for display %lu",
+                        psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        /* Create the flip chain in display side */
+        display = psDevInfo->display;
+        /* TODO: What about TILER buffers? */
+        /*
+         * Creating the flip chain with the maximum number of buffers
+         * we will decide which ones will be used later
+         */
+        err = display->create_flip_chain(
+                display, psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers);
+        if(err)
+        {
+                ERROR_PRINTK("Unable to create the flip chain for '%s' display"
+                        " id %lu", display->name, psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        /* Allocate memory needed for the swap chain */
+        psSwapChain = (struct OMAP_DISP_SWAPCHAIN*) kmalloc(
+                sizeof(struct OMAP_DISP_SWAPCHAIN), GFP_KERNEL);
+        if(!psSwapChain)
+        {
+                ERROR_PRINTK("Out of memory to allocate swap chain for"
+                        " display %lu", psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        DEBUG_PRINTK("Creating swap chain for display %lu",
+                psDevInfo->ulDeviceID );
+
+        /* Allocate memory for the buffer abstraction structures */
+        psBuffer = (struct OMAP_DISP_BUFFER*) kmalloc(
+                sizeof(struct OMAP_DISP_BUFFER) * ui32BufferCount, GFP_KERNEL);
+        if(!psBuffer)
+        {
+                ERROR_PRINTK("Out of memory to allocate the buffer"
+                        " abstraction structures for display %lu",
+                        psDevInfo->ulDeviceID);
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorFreeSwapChain;
+        }
+
+        /* Allocate memory for the flip item abstraction structures */
+        psFlipItems = (struct OMAP_DISP_FLIP_ITEM *) kmalloc (
+                sizeof(struct OMAP_DISP_FLIP_ITEM) * ui32BufferCount,
+                GFP_KERNEL);
+        if (!psFlipItems)
+        {
+                ERROR_PRINTK("Out of memory to allocate the flip item"
+                        " abstraction structures for display %lu",
+                        psDevInfo->ulDeviceID);
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorFreeBuffers;
+        }
+
+        /* Assign to the swap chain structure the initial data */
+        psSwapChain->ulBufferCount = (unsigned long)ui32BufferCount;
+        psSwapChain->psBuffer = psBuffer;
+        psSwapChain->psFlipItems = psFlipItems;
+        psSwapChain->ulInsertIndex = 0;
+        psSwapChain->ulRemoveIndex = 0;
+        psSwapChain->psPVRJTable = &psDevInfo->sPVRJTable;
+        psSwapChain->pvDevInfo = (void*)psDevInfo;
+
+        /*
+         * Init the workqueue (single thread, freezable and real time)
+         * and its own work for this display
+         */
+        INIT_WORK(&psDevInfo->sync_display_work, display_sync_handler);
+        psDevInfo->sync_display_wq =
+                __create_workqueue("pvr_display_sync_wq", 1, 1, 1);
+
+        DEBUG_PRINTK("Swap chain will have %u buffers for display %lu",
+                (unsigned int)ui32BufferCount, psDevInfo->ulDeviceID);
+        /* Link the buffers available like a circular list */
+        for(i=0; i<ui32BufferCount-1; i++)
+        {
+                psBuffer[i].psNext = &psBuffer[i+1];
+        }
+        psBuffer[i].psNext = &psBuffer[0];
+
+        /* Initialize each buffer abstraction structure */
+        for(i=0; i<ui32BufferCount; i++)
+        {
+                /* Get the needed buffers from the display flip chain */
+                IMG_UINT32 ui32SwapBuffer = i + ui32BuffersToSkip;
+                struct omap_display_buffer * flip_buffer =
+                        display->flip_chain->buffers[ui32SwapBuffer];
+                psBuffer[i].display_buffer = flip_buffer;
+                psBuffer[i].psSyncData = ppsSyncData[i];
+                psBuffer[i].sSysAddr.uiAddr = flip_buffer->physical_addr;
+                psBuffer[i].sCPUVAddr =
+                        (IMG_CPU_VIRTADDR) flip_buffer->virtual_addr;
+                DEBUG_PRINTK("Display %lu buffer index %u has physical "
+                        "address 0x%x",
+                        psDevInfo->ulDeviceID,
+                        (unsigned int)i,
+                        (unsigned int)psBuffer[i].sSysAddr.uiAddr);
+        }
+
+        /* Initialize each flip item abstraction structure */
+        for(i=0; i<ui32BufferCount; i++)
+        {
+                psFlipItems[i].bValid = OMAP_FALSE;
+                psFlipItems[i].bFlipped = OMAP_FALSE;
+                psFlipItems[i].bCmdCompleted = OMAP_FALSE;
+                psFlipItems[i].display_buffer = 0;
+        }
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        psDevInfo->psSwapChain = psSwapChain;
+        psSwapChain->bFlushCommands = psDevInfo->bFlushCommands;
+        if (psSwapChain->bFlushCommands)
+                psSwapChain->ulSetFlushStateRefCount = 1;
+        else
+                psSwapChain->ulSetFlushStateRefCount = 0;
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        *phSwapChain = (IMG_HANDLE)psSwapChain;
+
+        return PVRSRV_OK;
+
+ErrorFreeBuffers:
+        kfree(psBuffer);
+ErrorFreeSwapChain:
+        kfree(psSwapChain);
+
+        return eError;
+}
+
+/*
+ * Destroy a swap chain. Called when a 3D application ends.
+ * in: hDevice, hSwapChain
+ */
+static PVRSRV_ERROR DestroyDCSwapChain(IMG_HANDLE hDevice,
+        IMG_HANDLE hSwapChain)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        struct omap_display_device *display;
+        int err;
+
+        if(!hDevice || !hSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        psSwapChain = (struct OMAP_DISP_SWAPCHAIN*)hSwapChain;
+        display = psDevInfo->display;
+
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device pointer");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        DEBUG_PRINTK("Destroying swap chain for display %lu",
+                psDevInfo->ulDeviceID);
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        FlushInternalSyncQueue(psSwapChain);
+        psDevInfo->psSwapChain = NULL;
+
+        /*
+         * Present the buffer which is at the base of address of
+         * the framebuffer
+         */
+        display->present_buffer(display->main_buffer);
+
+        /* Destroy the flip chain in display side */
+        err = display->destroy_flip_chain(display);
+        if(err)
+        {
+                ERROR_PRINTK("Unable to destroy the flip chain for '%s' "
+                        "display id %lu", display->name,
+                        psDevInfo->ulDeviceID);
+        }
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        /* Destroy the workqueue */
+        flush_workqueue(psDevInfo->sync_display_wq);
+        destroy_workqueue(psDevInfo->sync_display_wq);
+
+        kfree(psSwapChain->psFlipItems);
+        kfree(psSwapChain->psBuffer);
+        kfree(psSwapChain);
+
+        return PVRSRV_OK;
+}
+
+
+/*
+ * Get display buffers. These are the buffers that can be allocated
+ * inside the framebuffer memory.
+ * in: hDevice, hSwapChain
+ * out: pui32BufferCount, phBuffer
+ */
+static PVRSRV_ERROR GetDCBuffers(IMG_HANDLE hDevice,
+                                 IMG_HANDLE hSwapChain,
+                                 IMG_UINT32 *pui32BufferCount,
+                                 IMG_HANDLE *phBuffer)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        unsigned long      i;
+
+        if(!hDevice || !hSwapChain || !pui32BufferCount || !phBuffer)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        psSwapChain = (struct OMAP_DISP_SWAPCHAIN*)hSwapChain;
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device %lu pointer",
+                        psDevInfo->ulDeviceID);
+                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;
+}
+
+/*
+ * Sets the display state.
+ * in: ui32State, hDevice
+ */
+static IMG_VOID SetDCState(IMG_HANDLE hDevice, IMG_UINT32 ui32State)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo =
+                (struct OMAP_DISP_DEVINFO*) hDevice;
+
+        switch (ui32State)
+        {
+                case DC_STATE_FLUSH_COMMANDS:
+                        DEBUG_PRINTK("Setting state to flush commands for"
+                                " display %lu", psDevInfo->ulDeviceID);
+                        SetFlushStateExternal(psDevInfo, OMAP_TRUE);
+                        break;
+                case DC_STATE_NO_FLUSH_COMMANDS:
+                        DEBUG_PRINTK("Setting state to not flush commands for"
+                                " display %lu", psDevInfo->ulDeviceID);
+                        SetFlushStateExternal(psDevInfo, OMAP_FALSE);
+                        break;
+                default:
+                        WARNING_PRINTK("Unknown command state %u for display"
+                                " %lu", (unsigned int)ui32State,
+                                psDevInfo->ulDeviceID);
+                        break;
+        }
+}
+
+/*
+ * Swap to display system buffer. This buffer refers to the one which
+ * is that fits in the framebuffer memory.
+ * in: hDevice, hSwapChain
+ */
+static PVRSRV_ERROR SwapToDCSystem(IMG_HANDLE hDevice,
+                                   IMG_HANDLE hSwapChain)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        struct omap_display_device *display;
+
+        if(!hDevice || !hSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)hDevice;
+        psSwapChain = (struct OMAP_DISP_SWAPCHAIN*)hSwapChain;
+        display = psDevInfo->display;
+
+        DEBUG_PRINTK("Executing for display %lu",
+                psDevInfo->ulDeviceID);
+
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device %lu pointer",
+                        psDevInfo->ulDeviceID);
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        FlushInternalSyncQueue(psSwapChain);
+        display->present_buffer(display->main_buffer);
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Handles the synchronization with the display
+ * in: work
+ */
+
+static void display_sync_handler(struct work_struct *work)
+{
+        /*
+         * TODO: Since present_buffer_sync waits and then present, this
+         * algorithm can be simplified further
+         */
+        struct OMAP_DISP_DEVINFO *psDevInfo = container_of(work,
+                struct OMAP_DISP_DEVINFO, sync_display_work);
+        struct omap_display_device *display = psDevInfo->display;
+        struct OMAP_DISP_FLIP_ITEM *psFlipItem;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        unsigned long ulMaxIndex;
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        psSwapChain = psDevInfo->psSwapChain;
+        if (!psSwapChain || psSwapChain->bFlushCommands)
+                goto ExitUnlock;
+
+        psFlipItem = &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+        /* Iterate through the flip items and flip them if necessary */
+        while(psFlipItem->bValid)
+        {
+                if(psFlipItem->bFlipped)
+                {
+                        if(!psFlipItem->bCmdCompleted)
+                        {
+                                psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(
+                                        (IMG_HANDLE)psFlipItem->hCmdComplete,
+                                        IMG_TRUE);
+                                psFlipItem->bCmdCompleted = OMAP_TRUE;
+                        }
+
+                        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
+                        {
+                                /*
+                                 * Here the swap interval is not zero yet
+                                 * we need to schedule another work until
+                                 * it reaches zero
+                                 */
+                                display->sync(display);
+                                psFlipItem->ulSwapInterval--;
+                                queue_work(psDevInfo->sync_display_wq,
+                                        &psDevInfo->sync_display_work);
+                                goto ExitUnlock;
+                        }
+                }
+                else
+                {
+                        display->present_buffer_sync(
+                                psFlipItem->display_buffer);
+                        /*
+                         * present_buffer_sync waits and then present, then
+                         * swap interval decreases here too.
+                         */
+                        psFlipItem->ulSwapInterval--;
+                        psFlipItem->bFlipped = OMAP_TRUE;
+                        /*
+                         * If the flip has been presented here then we need
+                         * in the next sync execute the command complete,
+                         * schedule another work
+                         */
+                        queue_work(psDevInfo->sync_display_wq,
+                                &psDevInfo->sync_display_work);
+                        goto ExitUnlock;
+                }
+                psFlipItem =
+                        &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        }
+
+ExitUnlock:
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+}
+
+/*
+ * Performs a flip. This function takes the necessary steps to present
+ * the buffer to be flipped in the display.
+ * in: hCmdCookie, ui32DataSize, pvData
+ */
+static IMG_BOOL ProcessFlip(IMG_HANDLE  hCmdCookie,
+                            IMG_UINT32  ui32DataSize,
+                            IMG_VOID   *pvData)
+{
+        DISPLAYCLASS_FLIP_COMMAND *psFlipCmd;
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        struct OMAP_DISP_BUFFER *psBuffer;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        struct omap_display_device *display;
+#if defined(SYS_USING_INTERRUPTS)
+        struct OMAP_DISP_FLIP_ITEM* psFlipItem;
+#endif
+
+        if(!hCmdCookie || !pvData)
+        {
+                WARNING_PRINTK("Ignoring call with NULL parameters");
+                return IMG_FALSE;
+        }
+
+        psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)pvData;
+
+        if (psFlipCmd == IMG_NULL ||
+                sizeof(DISPLAYCLASS_FLIP_COMMAND) != ui32DataSize)
+        {
+                WARNING_PRINTK("NULL command or command data size is wrong");
+                return IMG_FALSE;
+        }
+
+        psDevInfo = (struct OMAP_DISP_DEVINFO*)psFlipCmd->hExtDevice;
+        psBuffer = (struct OMAP_DISP_BUFFER*)psFlipCmd->hExtBuffer;
+        psSwapChain = (struct OMAP_DISP_SWAPCHAIN*) psFlipCmd->hExtSwapChain;
+        display = psDevInfo->display;
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        if (psDevInfo->bDeviceSuspended)
+        {
+                /* If is suspended then assume the commands are completed */
+                psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(
+                        hCmdCookie, IMG_TRUE);
+                goto ExitTrueUnlock;
+        }
+
+#if defined(SYS_USING_INTERRUPTS)
+
+        if( psFlipCmd->ui32SwapInterval == 0 ||
+                psSwapChain->bFlushCommands == OMAP_TRUE)
+        {
+#endif
+                display->present_buffer(psBuffer->display_buffer);
+                psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(
+                        hCmdCookie, IMG_TRUE);
+
+#if defined(SYS_USING_INTERRUPTS)
+                goto ExitTrueUnlock;
+        }
+
+        psFlipItem = &psSwapChain->psFlipItems[psSwapChain->ulInsertIndex];
+
+        if(psFlipItem->bValid == OMAP_FALSE)
+        {
+                unsigned long ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+                psFlipItem->bFlipped = OMAP_FALSE;
+
+                /*
+                 * The buffer is queued here, must be consumed by the workqueue
+                 */
+                psFlipItem->hCmdComplete = (OMAP_HANDLE)hCmdCookie;
+                psFlipItem->ulSwapInterval =
+                        (unsigned long)psFlipCmd->ui32SwapInterval;
+                psFlipItem->sSysAddr = &psBuffer->sSysAddr;
+                psFlipItem->bValid = OMAP_TRUE;
+                psFlipItem->display_buffer = psBuffer->display_buffer;
+
+                psSwapChain->ulInsertIndex++;
+                if(psSwapChain->ulInsertIndex > ulMaxIndex)
+                        psSwapChain->ulInsertIndex = 0;
+
+                /* Give work to the workqueue to sync with the display */
+                queue_work(psDevInfo->sync_display_wq,
+                        &psDevInfo->sync_display_work);
+
+                goto ExitTrueUnlock;
+        }
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        return IMG_FALSE;
+#endif
+
+ExitTrueUnlock:
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        return IMG_TRUE;
+}
+
+#if defined(LDM_PLATFORM)
+
+/*
+ *  Function called when the driver must suspend
+ */
+static void DriverSuspend(void)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        int i;
+
+        if(!pDisplayDevices)
+                return;
+
+        for(i = 0; i < display_devices_count; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+
+                mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+                if (psDevInfo->bDeviceSuspended)
+                {
+                        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+                        continue;
+                }
+
+                psDevInfo->bDeviceSuspended = OMAP_TRUE;
+                SetFlushStateInternalNoLock(psDevInfo, OMAP_TRUE);
+
+                mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        }
+}
+
+/*
+ *  Function called when the driver must resume
+ */
+static void DriverResume(void)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        int i;
+
+        if(!pDisplayDevices)
+                return;
+
+        for(i = 0; i < display_devices_count; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+
+                mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+                if (!psDevInfo->bDeviceSuspended)
+                {
+                        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+                        continue;
+                }
+
+                SetFlushStateInternalNoLock(psDevInfo, OMAP_FALSE);
+                psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+                mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        }
+}
+#endif /* defined(LDM_PLATFORM) */
+
+/*
+ * Frees the kernel framebuffer
+ * in: psDevInfo
+ */
+static void deinit_display_device(struct OMAP_DISP_DEVINFO *psDevInfo)
+{
+        /* TODO: Are we sure there is nothing to do here? */
+}
+
+/*
+ *  Deinitialization routine for the 3rd party display driver
+ */
+static enum OMAP_ERROR destroy_display_devices(void)
+{
+        struct OMAP_DISP_DEVINFO *psDevInfo;
+        PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable;
+        int i;
+
+        DEBUG_PRINTK("Deinitializing 3rd party display driver");
+
+        if(!pDisplayDevices)
+                return OMAP_OK;
+
+        for(i = 0; i < display_devices_count; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+                if(!psDevInfo->display)
+                        continue;
+
+                /* Remove the ProcessFlip command callback */
+                psJTable = &psDevInfo->sPVRJTable;
+
+                if(!psJTable)
+                        continue;
+
+                if (psDevInfo->sPVRJTable.pfnPVRSRVRemoveCmdProcList(
+                        psDevInfo->ulDeviceID,
+                        OMAP_DC_CMD_COUNT) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to remove callback for "
+                                "ProcessFlip command for display %lu",
+                                psDevInfo->ulDeviceID);
+                        return OMAP_ERROR_GENERIC;
+                }
+
+                /* Remove the display device from services */
+                if (psJTable->pfnPVRSRVRemoveDCDevice(
+                        psDevInfo->ulDeviceID) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to remove the display %lu "
+                                "from services", psDevInfo->ulDeviceID);
+                        return OMAP_ERROR_GENERIC;
+                }
+
+                deinit_display_device(psDevInfo);
+        }
+
+        kfree(pDisplayDevices);
+
+        return OMAP_OK;
+}
+
+/*
+ * Extracts the framebuffer data from the kernel driver
+ * in: psDevInfo
+ */
+static enum OMAP_ERROR init_display_device(struct OMAP_DISP_DEVINFO *psDevInfo,
+        struct omap_display_device *display)
+{
+        int buffers_available = display->buffers_available;
+
+        /* Extract the needed data from the display struct */
+        DEBUG_PRINTK("Display '%s' id %i information:", display->name,
+                display->id);
+        DEBUG_PRINTK("*Width, height: %u,%u", display->width,
+                display->height);
+        DEBUG_PRINTK("*Rotation: %u", display->rotation);
+        DEBUG_PRINTK("*Stride: %u bytes", display->byte_stride);
+        DEBUG_PRINTK("*Buffers available: %u", buffers_available);
+        DEBUG_PRINTK("*Bytes per pixel: %u (%u bpp)",
+                display->bytes_per_pixel, display->bits_per_pixel);
+
+        if(display->bits_per_pixel == 16)
+        {
+                if(display->pixel_format == RGB_565)
+                {
+                        DEBUG_PRINTK("*Format: RGB565");
+                        psDevInfo->sDisplayFormat.pixelformat =
+                                PVRSRV_PIXEL_FORMAT_RGB565;
+                }
+                else
+                        WARNING_PRINTK("*Format: Unknown framebuffer"
+                                "format");
+        }
+        else if(display->bits_per_pixel == 24 ||
+                display->bits_per_pixel == 32)
+        {
+                if(display->pixel_format == ARGB_8888)
+                {
+                        DEBUG_PRINTK("*Format: ARGB8888");
+                        psDevInfo->sDisplayFormat.pixelformat =
+                                PVRSRV_PIXEL_FORMAT_ARGB8888;
+
+                }
+                else
+                        WARNING_PRINTK("*Format: Unknown framebuffer"
+                                "format");
+        }
+        else
+                WARNING_PRINTK("*Format: Unknown framebuffer format");
+
+        if(display->main_buffer)
+        {
+                DEBUG_PRINTK("*Bytes per buffer: %lu",
+                        display->main_buffer->size);
+                DEBUG_PRINTK("*Main buffer physical address: 0x%lx",
+                        display->main_buffer->physical_addr);
+                DEBUG_PRINTK("*Main buffer virtual address: 0x%lx",
+                        display->main_buffer->virtual_addr);
+                DEBUG_PRINTK("*Main buffer size: %lu bytes",
+                        display->main_buffer->size);
+        }
+        else
+        {
+                psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = 0;
+                ERROR_PRINTK("*No main buffer found for display '%s'",
+                        display->name);
+                return OMAP_ERROR_INIT_FAILURE;
+        }
+
+        psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = buffers_available;
+        mutex_init(&psDevInfo->sSwapChainLockMutex);
+        psDevInfo->psSwapChain = 0;
+        psDevInfo->bFlushCommands = OMAP_FALSE;
+        psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+        if(psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers > 1)
+        {
+                if(MAX_BUFFERS_FLIPPING == 1)
+                {
+                        DEBUG_PRINTK("Flipping support is possible"
+                                " but you decided not to use it");
+                }
+
+                DEBUG_PRINTK("*Flipping support");
+                if(psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers >
+                        MAX_BUFFERS_FLIPPING)
+                psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers =
+                        MAX_BUFFERS_FLIPPING;
+        }
+        else
+        {
+                DEBUG_PRINTK("*Flipping not supported");
+        }
+
+        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;
+
+        /* Get the display and framebuffer needed info */
+        strncpy(psDevInfo->sDisplayInfo.szDisplayName,
+                DISPLAY_DEVICE_NAME, MAX_DISPLAY_NAME_SIZE);
+
+        psDevInfo->sDisplayDim.ui32Width = display->width;
+        psDevInfo->sDisplayDim.ui32Height = display->height;
+        psDevInfo->sDisplayDim.ui32ByteStride = display->byte_stride;
+        psDevInfo->sSystemBuffer.sSysAddr.uiAddr =
+                display->main_buffer->physical_addr;
+        psDevInfo->sSystemBuffer.sCPUVAddr =
+                (IMG_CPU_VIRTADDR) display->main_buffer->virtual_addr;
+        psDevInfo->sSystemBuffer.ulBufferSize = display->main_buffer->size;
+        psDevInfo->display = display;
+
+        return OMAP_OK;
+}
+
+/*
+ *  Initialization routine for the 3rd party display driver
+ */
+static enum OMAP_ERROR create_display_devices(void)
+{
+        PFN_CMD_PROC pfnCmdProcList[OMAP_DC_CMD_COUNT];
+        IMG_UINT32 aui32SyncCountList[OMAP_DC_CMD_COUNT][2];
+        int i;
+        unsigned int bytes_to_alloc;
+
+        DEBUG_PRINTK("Initializing 3rd party display driver");
+
+        /* Ask for the number of displays available */
+        omap_display_init();
+        /* TODO: allow more displays */
+        display_devices_count = 1; // omap_display_count();
+
+        DEBUG_PRINTK("Found %i displays", display_devices_count);
+
+        /*
+         * Obtain the function pointer for the jump table from kernel
+         * services to fill it with the function pointers that we want
+         */
+        if(get_pvr_dc_jtable ("PVRGetDisplayClassJTable",
+                &pfnGetPVRJTable) != OMAP_OK)
+        {
+                ERROR_PRINTK("Unable to get the function to get the"
+                        " jump table display->services");
+                return OMAP_ERROR_INIT_FAILURE;
+        }
+
+        /*
+         * Allocate the display device structures, one per display available
+         */
+        bytes_to_alloc =
+                sizeof(struct OMAP_DISP_DEVINFO) * display_devices_count;
+        pDisplayDevices = (struct OMAP_DISP_DEVINFO *) kmalloc(
+                bytes_to_alloc, GFP_KERNEL);
+        if(!pDisplayDevices)
+        {
+                pDisplayDevices = NULL;
+                ERROR_PRINTK("Out of memory");
+                return OMAP_ERROR_OUT_OF_MEMORY;
+        }
+        memset(pDisplayDevices, 0, bytes_to_alloc);
+
+        /*
+         * Initialize each display device
+         */
+        for(i = 0; i < display_devices_count; i++)
+        {
+                struct omap_display_device *display;
+                struct OMAP_DISP_DEVINFO * psDevInfo;
+                enum omap_display_id id;
+
+                psDevInfo = &pDisplayDevices[i];
+                psDevInfo->display = 0;
+
+                id = OMAP_DISPID_VIRTUAL;
+
+                /*
+                 * TODO: Modify this to allow primary, secondary,
+                 * not only virtual
+                 */
+#if 0
+                switch(i)
+                {
+                        case 0:
+                                id = OMAP_DISPID_PRIMARY;
+                                break;
+                        case 1:
+                                id = OMAP_DISPID_SECONDARY;
+                                break;
+                        case 2:
+                                id = OMAP_DISPID_TERTIARY;
+                                break;
+                        case 3:
+                                id = OMAP_DISPID_VIRTUAL;
+                                break;
+                        default:
+                                ERROR_PRINTK("Invalid display type %i", i);
+                                BUG();
+                }
+
+#endif
+
+                display = omap_display_get(id);
+                if(!display)
+                        continue;
+
+                if(init_display_device(psDevInfo, display) != OMAP_OK)
+                {
+                        ERROR_PRINTK("Unable to initialize display '%s' type"
+                                " %u", display->name, display->id);
+                        continue;
+#if 0
+                        kfree(pDisplayDevices);
+                        pDisplayDevices = NULL;
+                        return OMAP_ERROR_INIT_FAILURE;
+#endif
+                }
+
+                /*
+                 * Populate each display device structure
+                */
+                if(!(*pfnGetPVRJTable)(&psDevInfo->sPVRJTable))
+                {
+                        ERROR_PRINTK("Unable to get the jump table"
+                                " display->services for display '%s'",
+                                display->name);
+                        return OMAP_ERROR_INIT_FAILURE;
+                }
+
+                /* Populate the function table that services will use */
+                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;
+
+                /* Register the display device */
+                if(psDevInfo->sPVRJTable.pfnPVRSRVRegisterDCDevice(
+                        &psDevInfo->sDCJTable,
+                        (IMG_UINT32*) &psDevInfo->ulDeviceID) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to register the jump table"
+                                " services->display");
+                        return OMAP_ERROR_DEVICE_REGISTER_FAILED;
+                }
+
+                DEBUG_PRINTK("Display '%s' registered with the GPU with"
+                        " id %lu", display->name, psDevInfo->ulDeviceID);
+
+                /*
+                 * Register the ProcessFlip function to notify when a frame is
+                 * ready to be flipped
+                 */
+                pfnCmdProcList[DC_FLIP_COMMAND] = ProcessFlip;
+                aui32SyncCountList[DC_FLIP_COMMAND][0] = 0;
+                aui32SyncCountList[DC_FLIP_COMMAND][1] = 2;
+                if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterCmdProcList(
+                        psDevInfo->ulDeviceID, &pfnCmdProcList[0],
+                        aui32SyncCountList, OMAP_DC_CMD_COUNT) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to register callback for "
+                                "ProcessFlip command");
+                        return OMAP_ERROR_CANT_REGISTER_CALLBACK;
+                }
+
+        }
+        return OMAP_OK;
+}
+
+/*
+ * Here we get the function pointer to get jump table from
+ * services using an external function.
+ * in: szFunctionName
+ * out: ppfnFuncTable
+ */
+static enum OMAP_ERROR get_pvr_dc_jtable (char *szFunctionName,
+        PFN_DC_GET_PVRJTABLE *ppfnFuncTable)
+{
+        if(strcmp("PVRGetDisplayClassJTable", szFunctionName) != 0)
+        {
+                ERROR_PRINTK("Unable to get function pointer for %s"
+                        " from services", szFunctionName);
+                return OMAP_ERROR_INVALID_PARAMS;
+        }
+        *ppfnFuncTable = PVRGetDisplayClassJTable;
+
+        return OMAP_OK;
+}
+
+#if defined(LDM_PLATFORM)
+
+static volatile enum OMAP_BOOL bDeviceSuspended;
+
+/*
+ * Common suspend driver function
+ * in: psSwapChain, aPhyAddr
+ */
+static void CommonSuspend(void)
+{
+        if (bDeviceSuspended)
+        {
+                DEBUG_PRINTK("Driver is already suspended");
+                return;
+        }
+
+        DriverSuspend();
+        bDeviceSuspended = OMAP_TRUE;
+}
+
+#if defined(SGX_EARLYSUSPEND)
+
+static struct early_suspend driver_early_suspend;
+
+/*
+ * Android specific, driver is requested to be suspended
+ * in: ea_event
+ */
+static void DriverSuspend_Entry(struct early_suspend *ea_event)
+{
+        DEBUG_PRINTK("Requested driver suspend");
+        CommonSuspend();
+}
+
+/*
+ * Android specific, driver is requested to be suspended
+ * in: ea_event
+ */
+static void DriverResume_Entry(struct early_suspend *ea_event)
+{
+        DEBUG_PRINTK("Requested driver resume");
+        DriverResume();
+        bDeviceSuspended = OMAP_FALSE;
+}
+
+static struct platform_driver omap_sgx_dc_driver = {
+        .driver = {
+                .name = DRVNAME,
+        }
+};
+
+#else /* defined(SGX_EARLYSUSPEND) */
+
+/*
+ * Function called when the driver is requested to be suspended
+ * in: pDevice, state
+ */
+static int DriverSuspend_Entry(struct platform_device unref__ *pDevice,
+        pm_message_t unref__ state)
+{
+        DEBUG_PRINTK("Requested driver suspend");
+        CommonSuspend();
+        return 0;
+}
+
+/*
+ * Function called when the driver is requested to resume
+ * in: pDevice
+ */
+static int DriverResume_Entry(struct platform_device unref__ *pDevice)
+{
+        DEBUG_PRINTK("Requested driver resume");
+        DriverResume();
+        bDeviceSuspended = OMAP_FALSE;
+        return 0;
+}
+
+/*
+ * Function called when the driver is requested to shutdown
+ * in: pDevice
+ */
+static IMG_VOID DriverShutdown_Entry(
+        struct platform_device unref__ *pDevice)
+{
+        DEBUG_PRINTK("Requested driver shutdown");
+        CommonSuspend();
+}
+
+static struct platform_driver omap_sgx_dc_driver = {
+        .driver = {
+                .name = DRVNAME,
+        },
+        .suspend = DriverSuspend_Entry,
+        .resume = DriverResume_Entry,
+        .shutdown = DriverShutdown_Entry,
+};
+
+#endif /* defined(SGX_EARLYSUSPEND) */
+
+#endif /* defined(LDM_PLATFORM) */
+
+/*
+ * Driver init function
+ */
+static int __init omap_sgx_dc_init(void)
+{
+        if(create_display_devices() != OMAP_OK)
+        {
+                WARNING_PRINTK("Driver init failed");
+                return -ENODEV;
+        }
+
+#if defined(LDM_PLATFORM)
+        DEBUG_PRINTK("Registering platform driver");
+        if (platform_driver_register(&omap_sgx_dc_driver))
+        {
+                WARNING_PRINTK("Unable to register platform driver");
+                if(destroy_display_devices() != OMAP_OK)
+                        WARNING_PRINTK("Driver cleanup failed\n");
+                return -ENODEV;
+        }
+
+#if defined(SGX_EARLYSUSPEND)
+        driver_early_suspend.suspend = DriverSuspend_Entry;
+        driver_early_suspend.resume = DriverResume_Entry;
+        driver_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
+        register_early_suspend(&driver_early_suspend);
+        DEBUG_PRINTK("Registered early suspend support");
+#endif
+
+#endif
+        return 0;
+}
+
+/*
+ * Driver exit function
+ */
+static IMG_VOID __exit omap_sgx_dc_deinit(IMG_VOID)
+{
+#if defined(LDM_PLATFORM)
+        DEBUG_PRINTK("Removing platform driver");
+        platform_driver_unregister(&omap_sgx_dc_driver);
+#if defined(SGX_EARLYSUSPEND)
+        unregister_early_suspend(&driver_early_suspend);
+#endif
+#endif
+        if(destroy_display_devices() != OMAP_OK)
+                WARNING_PRINTK("Driver cleanup failed");
+}
+
+MODULE_SUPPORTED_DEVICE(DEVNAME);
+late_initcall(omap_sgx_dc_init);
+module_exit(omap_sgx_dc_deinit);
diff --git a/drivers/gpu/pvr/display/omap_sgx_displayclass.h b/drivers/gpu/pvr/display/omap_sgx_displayclass.h
new file mode 100644
index 00000000000..e97c4addc5a
--- /dev/null
+++ b/drivers/gpu/pvr/display/omap_sgx_displayclass.h
@@ -0,0 +1,123 @@
+/*************************************************************************
+ *
+ * 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 __OMAP_SGX_DISPLAYCLASS_H__
+#define __OMAP_SGX_DISPLAYCLASS_H__
+
+extern IMG_BOOL PVRGetDisplayClassJTable(
+        PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
+
+typedef void * OMAP_HANDLE;
+
+enum OMAP_BOOL
+{
+        OMAP_FALSE = 0,
+        OMAP_TRUE = 1,
+};
+
+struct OMAP_DISP_BUFFER
+{
+        unsigned long ulBufferSize;
+        IMG_SYS_PHYADDR sSysAddr;
+        IMG_CPU_VIRTADDR sCPUVAddr;
+        PVRSRV_SYNC_DATA *psSyncData;
+        struct OMAP_DISP_BUFFER *psNext;
+        struct omap_display_buffer *display_buffer;
+};
+
+struct OMAP_DISP_FLIP_ITEM
+{
+        OMAP_HANDLE hCmdComplete;
+        unsigned long ulSwapInterval;
+        enum OMAP_BOOL bValid;
+        enum OMAP_BOOL bFlipped;
+        enum OMAP_BOOL bCmdCompleted;
+        IMG_SYS_PHYADDR *sSysAddr;
+        struct omap_display_buffer *display_buffer;
+};
+
+struct OMAP_DISP_SWAPCHAIN
+{
+        unsigned long ulBufferCount;
+        struct OMAP_DISP_BUFFER *psBuffer;
+        struct OMAP_DISP_FLIP_ITEM *psFlipItems;
+        unsigned long ulInsertIndex;
+        unsigned long ulRemoveIndex;
+        PVRSRV_DC_DISP2SRV_KMJTABLE *psPVRJTable;
+        enum OMAP_BOOL bFlushCommands;
+        unsigned long ulSetFlushStateRefCount;
+        enum OMAP_BOOL bBlanked;
+        spinlock_t *psSwapChainLock;
+        void *pvDevInfo;
+};
+
+struct OMAP_DISP_DEVINFO
+{
+        unsigned long ulDeviceID;
+        struct OMAP_DISP_BUFFER sSystemBuffer;
+        PVRSRV_DC_DISP2SRV_KMJTABLE sPVRJTable;
+        PVRSRV_DC_SRV2DISP_KMJTABLE sDCJTable;
+        struct OMAP_DISP_SWAPCHAIN *psSwapChain;
+        enum OMAP_BOOL bFlushCommands;
+        enum OMAP_BOOL bDeviceSuspended;
+        struct mutex sSwapChainLockMutex;
+        IMG_DEV_VIRTADDR sDisplayDevVAddr;
+        DISPLAY_INFO sDisplayInfo;
+        DISPLAY_FORMAT sDisplayFormat;
+        DISPLAY_DIMS sDisplayDim;
+        struct workqueue_struct *sync_display_wq;
+        struct work_struct sync_display_work;
+        PVRSRV_PIXEL_FORMAT ePixelFormat;
+        struct omap_display_device *display;
+};
+
+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
+
+};
+
+#define DISPLAY_DEVICE_NAME "PowerVR OMAP Display Driver"
+#define DRVNAME "omap_sgx_displayclass"
+#define DEVNAME DRVNAME
+#define DRIVER_PREFIX DRVNAME
+
+#define DEBUG_PRINTK(format, ...) printk("DEBUG " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#define WARNING_PRINTK(format, ...) printk("WARNING " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#define ERROR_PRINTK(format, ...) printk("ERROR " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+
+#endif
diff --git a/drivers/gpu/pvr/env_data.h b/drivers/gpu/pvr/env_data.h
new file mode 100644
index 00000000000..3d41219b797
--- /dev/null
+++ b/drivers/gpu/pvr/env_data.h
@@ -0,0 +1,66 @@
+/**********************************************************************
+ *
+ * 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 _ENV_DATA_
+#define _ENV_DATA_
+
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+#include <linux/workqueue.h>
+#endif
+
+#define PVRSRV_MAX_BRIDGE_IN_SIZE       0x1000
+#define PVRSRV_MAX_BRIDGE_OUT_SIZE      0x1000
+
+typedef struct _PVR_PCI_DEV_TAG
+{
+        struct pci_dev          *psPCIDev;
+        HOST_PCI_INIT_FLAGS     ePCIFlags;
+        IMG_BOOL abPCIResourceInUse[DEVICE_COUNT_RESOURCE];
+} PVR_PCI_DEV;
+
+typedef struct _ENV_DATA_TAG
+{
+        IMG_VOID                *pvBridgeData;
+        struct pm_dev           *psPowerDevice;
+        IMG_BOOL                bLISRInstalled;
+        IMG_BOOL                bMISRInstalled;
+        IMG_UINT32              ui32IRQ;
+        IMG_VOID                *pvISRCookie;
+#if defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+        struct workqueue_struct *psWorkQueue;
+#endif
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE) || defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+        struct work_struct      sMISRWork;
+        IMG_VOID                *pvMISRData;
+#else
+        struct tasklet_struct   sMISRTasklet;
+#endif
+} ENV_DATA;
+
+#endif 
diff --git a/drivers/gpu/pvr/env_perproc.h b/drivers/gpu/pvr/env_perproc.h
new file mode 100644
index 00000000000..67c8a539f00
--- /dev/null
+++ b/drivers/gpu/pvr/env_perproc.h
@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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 __ENV_PERPROC_H__
+#define __ENV_PERPROC_H__
+
+#include <linux/list.h>
+#include <linux/proc_fs.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);
+
+PVRSRV_ERROR LinuxMMapPerProcessConnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc);
+
+IMG_VOID LinuxMMapPerProcessDisconnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc);
+
+PVRSRV_ERROR LinuxMMapPerProcessHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase);
+
+IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID);
+
+#endif
+
diff --git a/drivers/gpu/pvr/event.c b/drivers/gpu/pvr/event.c
new file mode 100644
index 00000000000..e2ef0d177ca
--- /dev/null
+++ b/drivers/gpu/pvr/event.c
@@ -0,0 +1,274 @@
+/**********************************************************************
+ *
+ * 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 <asm/io.h>
+#include <asm/page.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#include <asm/system.h>
+#endif
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <asm/hardirq.h>
+#include <linux/timer.h>
+#include <linux/capability.h>
+#include <linux/sched.h>
+#include <asm/uaccess.h>
+
+#include "img_types.h"
+#include "services_headers.h"
+#include "mm.h"
+#include "pvrmmap.h"
+#include "mmap.h"
+#include "env_data.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;
+   
+} PVRSRV_LINUX_EVENT_OBJECT_LIST;
+
+
+typedef struct PVRSRV_LINUX_EVENT_OBJECT_TAG
+{
+        atomic_t        sTimeStamp;
+        IMG_UINT32  ui32TimeStampPrevious;
+#if defined(DEBUG)
+        IMG_UINT        ui32Stats;
+#endif
+    wait_queue_head_t sWait;    
+        struct list_head        sList;
+        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;
+
+        if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), 
+                (IMG_VOID **)&psEvenObjectList, 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);
+
+        rwlock_init(&psEvenObjectList->sLock);
+        
+        *phEventObjectList = (IMG_HANDLE *) psEvenObjectList;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR LinuxEventObjectListDestroy(IMG_HANDLE hEventObjectList)
+{
+
+        PVRSRV_LINUX_EVENT_OBJECT_LIST *psEvenObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST *) hEventObjectList ;
+
+        if(psEvenObjectList)    
+        {
+                if (!list_empty(&psEvenObjectList->sList)) 
+                {
+                         PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectListDestroy: Event List is not empty"));
+                         return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
+                }
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT_LIST), psEvenObjectList, IMG_NULL);
+                
+        }
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR LinuxEventObjectDelete(IMG_HANDLE hOSEventObjectList, IMG_HANDLE hOSEventObject)
+{
+        if(hOSEventObjectList)
+        {
+                if(hOSEventObject)
+                {
+                        PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)hOSEventObject; 
+#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_UNABLE_TO_DESTROY_EVENT;
+                        }
+                        
+                        return PVRSRV_OK;
+                }
+        }
+        return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
+
+}
+
+static PVRSRV_ERROR LinuxEventObjectDeleteCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+{
+        PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = pvParam;
+        PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = psLinuxEventObject->psLinuxEventObjectList;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        write_lock_bh(&psLinuxEventObjectList->sLock);
+        list_del(&psLinuxEventObject->sList);
+        write_unlock_bh(&psLinuxEventObjectList->sLock);
+
+#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);
+        
+
+        return PVRSRV_OK;
+}
+PVRSRV_ERROR LinuxEventObjectAdd(IMG_HANDLE hOSEventObjectList, IMG_HANDLE *phOSEventObject)
+ {
+        PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject; 
+        PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST*)hOSEventObjectList; 
+        IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
+        PVRSRV_PER_PROCESS_DATA *psPerProc;
+
+        psPerProc = PVRSRVPerProcessData(ui32PID);
+        if (psPerProc == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: Couldn't find per-process data"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        
+        if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_LINUX_EVENT_OBJECT), 
+                (IMG_VOID **)&psLinuxEventObject, IMG_NULL,
+                "Linux Event Object") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: failed to allocate memory "));            
+                return PVRSRV_ERROR_OUT_OF_MEMORY;      
+        }
+        
+        INIT_LIST_HEAD(&psLinuxEventObject->sList);
+
+        atomic_set(&psLinuxEventObject->sTimeStamp, 0);
+        psLinuxEventObject->ui32TimeStampPrevious = 0;
+
+#if defined(DEBUG)
+        psLinuxEventObject->ui32Stats = 0;
+#endif
+    init_waitqueue_head(&psLinuxEventObject->sWait);
+
+        psLinuxEventObject->psLinuxEventObjectList = psLinuxEventObjectList;
+
+        psLinuxEventObject->hResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                                                         RESMAN_TYPE_EVENT_OBJECT,
+                                                                                                         psLinuxEventObject,
+                                                                                                         0,
+                                                                                                         &LinuxEventObjectDeleteCallback);      
+
+        write_lock_bh(&psLinuxEventObjectList->sLock);
+        list_add(&psLinuxEventObject->sList, &psLinuxEventObjectList->sList);
+    write_unlock_bh(&psLinuxEventObjectList->sLock);
+        
+        *phOSEventObject = psLinuxEventObject;
+
+        return PVRSRV_OK;        
+}
+
+PVRSRV_ERROR LinuxEventObjectSignal(IMG_HANDLE hOSEventObjectList)
+{
+        PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject;
+        PVRSRV_LINUX_EVENT_OBJECT_LIST *psLinuxEventObjectList = (PVRSRV_LINUX_EVENT_OBJECT_LIST*)hOSEventObjectList; 
+        struct list_head *psListEntry, *psListEntryTemp, *psList;
+        psList = &psLinuxEventObjectList->sList;
+
+        list_for_each_safe(psListEntry, psListEntryTemp, psList) 
+        {               
+
+                psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)list_entry(psListEntry, PVRSRV_LINUX_EVENT_OBJECT, sList);    
+                
+                atomic_inc(&psLinuxEventObject->sTimeStamp);    
+                wake_up_interruptible(&psLinuxEventObject->sWait);
+        }
+
+        return  PVRSRV_OK;
+        
+}
+
+PVRSRV_ERROR LinuxEventObjectWait(IMG_HANDLE hOSEventObject, IMG_UINT32 ui32MSTimeout)
+{
+        IMG_UINT32 ui32TimeStamp;
+        DEFINE_WAIT(sWait);
+
+        PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *) hOSEventObject;
+
+        IMG_UINT32 ui32TimeOutJiffies = msecs_to_jiffies(ui32MSTimeout);
+        
+        do      
+        {
+                prepare_to_wait(&psLinuxEventObject->sWait, &sWait, TASK_INTERRUPTIBLE);
+                ui32TimeStamp = (IMG_UINT32)atomic_read(&psLinuxEventObject->sTimeStamp);
+        
+                if(psLinuxEventObject->ui32TimeStampPrevious != ui32TimeStamp)
+                {
+                        break;
+                }
+
+                LinuxUnLockMutex(&gPVRSRVLock);         
+
+                ui32TimeOutJiffies = (IMG_UINT32)schedule_timeout((IMG_INT32)ui32TimeOutJiffies);
+                
+                LinuxLockMutex(&gPVRSRVLock);
+#if defined(DEBUG)
+                psLinuxEventObject->ui32Stats++;
+#endif                  
+
+                
+        } while (ui32TimeOutJiffies);
+
+        finish_wait(&psLinuxEventObject->sWait, &sWait);        
+
+        psLinuxEventObject->ui32TimeStampPrevious = ui32TimeStamp;
+
+        return ui32TimeOutJiffies ? PVRSRV_OK : PVRSRV_ERROR_TIMEOUT;
+
+}
+
diff --git a/drivers/gpu/pvr/event.h b/drivers/gpu/pvr/event.h
new file mode 100644
index 00000000000..d07bc9711d9
--- /dev/null
+++ b/drivers/gpu/pvr/event.h
@@ -0,0 +1,32 @@
+/**********************************************************************
+ *
+ * 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 
+ *
+ ******************************************************************************/
+
+PVRSRV_ERROR LinuxEventObjectListCreate(IMG_HANDLE *phEventObjectList);
+PVRSRV_ERROR LinuxEventObjectListDestroy(IMG_HANDLE hEventObjectList);
+PVRSRV_ERROR LinuxEventObjectAdd(IMG_HANDLE hOSEventObjectList, IMG_HANDLE *phOSEventObject);
+PVRSRV_ERROR LinuxEventObjectDelete(IMG_HANDLE hOSEventObjectList, IMG_HANDLE hOSEventObject);
+PVRSRV_ERROR LinuxEventObjectSignal(IMG_HANDLE hOSEventObjectList);
+PVRSRV_ERROR LinuxEventObjectWait(IMG_HANDLE hOSEventObject, IMG_UINT32 ui32MSTimeout);
diff --git a/drivers/gpu/pvr/handle.c b/drivers/gpu/pvr/handle.c
new file mode 100644
index 00000000000..5e34af5b280
--- /dev/null
+++ b/drivers/gpu/pvr/handle.c
@@ -0,0 +1,1723 @@
+/**********************************************************************
+ *
+ * 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 
+ *
+ ******************************************************************************/
+
+#ifdef  PVR_SECURE_HANDLES
+#include <stddef.h>
+
+#include "services_headers.h"
+#include "handle.h"
+
+#ifdef  DEBUG
+#define HANDLE_BLOCK_SHIFT      2
+#else
+#define HANDLE_BLOCK_SHIFT      8
+#endif
+
+#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 HANDLE_HASH_TAB_INIT_SIZE       32
+
+#define INDEX_IS_VALID(psBase, i) ((i) < (psBase)->ui32TotalHandCount)
+
+#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 HANDLE_PTR_TO_INDEX(psHandle) ((psHandle)->ui32Index)
+#define HANDLE_PTR_TO_HANDLE(psHandle) INDEX_TO_HANDLE(HANDLE_PTR_TO_INDEX(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 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))
+
+#define TEST_ALLOC_FLAG(psHandle, f) TEST_FLAG((psHandle)->eFlag, f)
+
+#define SET_INTERNAL_FLAG(psHandle, f) SET_FLAG((psHandle)->eInternalFlag, f)
+#define CLEAR_INTERNAL_FLAG(psHandle, f) CLEAR_FLAG((psHandle)->eInternalFlag, f)
+#define TEST_INTERNAL_FLAG(psHandle, f) TEST_FLAG((psHandle)->eInternalFlag, f)
+
+#define BATCHED_HANDLE(psHandle) TEST_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
+
+#define SET_BATCHED_HANDLE(psHandle) SET_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
+
+#define SET_UNBATCHED_HANDLE(psHandle) CLEAR_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED)
+
+#define BATCHED_HANDLE_PARTIALLY_FREE(psHandle) TEST_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE)
+
+#define SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle) SET_INTERNAL_FLAG(psHandle, INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE)
+
+#define HANDLE_STRUCT_IS_FREE(psHandle) ((psHandle)->eType == PVRSRV_HANDLE_TYPE_NONE && (psHandle)->eInternalFlag == INTERNAL_HANDLE_FLAG_NONE)
+
+#ifdef  MIN
+#undef MIN
+#endif
+
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+
+struct sHandleList
+{
+        IMG_UINT32 ui32Prev;
+        IMG_UINT32 ui32Next;
+        IMG_HANDLE hParent;
+};
+
+enum ePVRSRVInternalHandleFlag
+{
+        INTERNAL_HANDLE_FLAG_NONE = 0x00,
+        INTERNAL_HANDLE_FLAG_BATCHED = 0x01,
+        INTERNAL_HANDLE_FLAG_BATCHED_PARTIALLY_FREE = 0x02,
+};
+
+struct sHandle
+{
+        
+        PVRSRV_HANDLE_TYPE eType;
+
+        
+        IMG_VOID *pvData;
+
+        
+        IMG_UINT32 ui32NextIndexPlusOne;
+
+        
+        enum ePVRSRVInternalHandleFlag eInternalFlag;
+
+        
+        PVRSRV_HANDLE_ALLOC_FLAG eFlag;
+
+        
+        IMG_UINT32 ui32Index;
+
+        
+        struct sHandleList sChildren;
+
+        
+        struct sHandleList sSiblings;
+};
+
+struct sHandleIndex
+{
+        
+        struct sHandle *psHandle;
+
+        
+        IMG_HANDLE hBlockAlloc;
+
+        
+        IMG_UINT32 ui32FreeHandBlockCount;
+};
+
+struct _PVRSRV_HANDLE_BASE_
+{
+        
+        IMG_HANDLE hBaseBlockAlloc;
+
+        
+        IMG_HANDLE hArrayBlockAlloc;
+
+        
+        struct sHandleIndex *psHandleArray;
+
+        
+        HASH_TABLE *psHashTab;
+
+        
+        IMG_UINT32 ui32FreeHandCount;
+
+        
+        IMG_UINT32 ui32FirstFreeIndex;
+
+        
+        IMG_UINT32 ui32MaxIndexPlusOne;
+
+        
+        IMG_UINT32 ui32TotalHandCount;
+
+        
+        IMG_UINT32 ui32LastFreeIndexPlusOne;
+
+        
+        IMG_UINT32 ui32HandBatchSize;
+
+        
+        IMG_UINT32 ui32TotalHandCountPreBatch;
+
+        
+        IMG_UINT32 ui32FirstBatchIndexPlusOne;
+
+        
+        IMG_UINT32 ui32BatchHandAllocFailures;
+
+        
+        IMG_BOOL bPurgingEnabled;
+};
+
+enum eHandKey {
+        HAND_KEY_DATA = 0,
+        HAND_KEY_TYPE,
+        HAND_KEY_PARENT,
+        HAND_KEY_LEN                    
+};
+
+PVRSRV_HANDLE_BASE *gpsKernelHandleBase = IMG_NULL;
+
+typedef IMG_UINTPTR_T HAND_KEY[HAND_KEY_LEN];
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(HandleListInit)
+#endif
+static INLINE
+IMG_VOID HandleListInit(IMG_UINT32 ui32Index, struct sHandleList *psList, IMG_HANDLE hParent)
+{
+        psList->ui32Next = ui32Index;
+        psList->ui32Prev = ui32Index;
+        psList->hParent = hParent;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(InitParentList)
+#endif
+static INLINE
+IMG_VOID InitParentList(struct sHandle *psHandle)
+{
+        IMG_UINT32 ui32Parent = HANDLE_PTR_TO_INDEX(psHandle);
+
+        HandleListInit(ui32Parent, &psHandle->sChildren, INDEX_TO_HANDLE(ui32Parent));
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(InitChildEntry)
+#endif
+static INLINE
+IMG_VOID InitChildEntry(struct sHandle *psHandle)
+{
+        HandleListInit(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, IMG_NULL);
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(HandleListIsEmpty)
+#endif
+static INLINE
+IMG_BOOL HandleListIsEmpty(IMG_UINT32 ui32Index, struct sHandleList *psList)
+{
+        IMG_BOOL bIsEmpty;
+
+        bIsEmpty = (IMG_BOOL)(psList->ui32Next == ui32Index);
+
+#ifdef  DEBUG
+        {
+                IMG_BOOL bIsEmpty2;
+
+                bIsEmpty2 = (IMG_BOOL)(psList->ui32Prev == ui32Index);
+                PVR_ASSERT(bIsEmpty == bIsEmpty2);
+        }
+#endif
+
+        return bIsEmpty;
+}
+
+#ifdef DEBUG
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(NoChildren)
+#endif
+static INLINE
+IMG_BOOL NoChildren(struct sHandle *psHandle)
+{
+        PVR_ASSERT(psHandle->sChildren.hParent == HANDLE_PTR_TO_HANDLE(psHandle));
+
+        return HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sChildren);
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(NoParent)
+#endif
+static INLINE
+IMG_BOOL NoParent(struct sHandle *psHandle)
+{
+        if (HandleListIsEmpty(HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings))
+        {
+                PVR_ASSERT(psHandle->sSiblings.hParent == IMG_NULL);
+
+                return IMG_TRUE;
+        }
+        else
+        {
+                PVR_ASSERT(psHandle->sSiblings.hParent != IMG_NULL);
+        }
+        return IMG_FALSE;
+}
+#endif 
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(ParentHandle)
+#endif
+static INLINE
+IMG_HANDLE ParentHandle(struct sHandle *psHandle)
+{
+        return psHandle->sSiblings.hParent;
+}
+
+#define LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, 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)
+#endif
+static INLINE
+IMG_VOID HandleListInsertBefore(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32InsIndex, struct sHandleList *psIns, IMG_SIZE_T uiParentOffset, IMG_UINT32 ui32EntryIndex, struct sHandleList *psEntry, IMG_SIZE_T uiEntryOffset, IMG_UINT32 ui32ParentIndex)
+{
+         
+        struct sHandleList *psPrevIns = LIST_PTR_FROM_INDEX_AND_OFFSET(psBase, psIns->ui32Prev, ui32ParentIndex, uiParentOffset, uiEntryOffset);
+
+        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(ui32ParentIndex));
+
+        psEntry->ui32Prev = psIns->ui32Prev;
+        psIns->ui32Prev = ui32EntryIndex;
+        psEntry->ui32Next = ui32InsIndex;
+        psPrevIns->ui32Next = ui32EntryIndex;
+
+        psEntry->hParent = INDEX_TO_HANDLE(ui32ParentIndex);
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(AdoptChild)
+#endif
+static INLINE
+IMG_VOID AdoptChild(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, struct sHandle *psChild)
+{
+        IMG_UINT32 ui32Parent = HANDLE_TO_INDEX(psParent->sChildren.hParent);
+
+        PVR_ASSERT(ui32Parent == HANDLE_PTR_TO_INDEX(psParent));
+
+        HandleListInsertBefore(psBase, ui32Parent, &psParent->sChildren, offsetof(struct sHandle, sChildren), HANDLE_PTR_TO_INDEX(psChild), &psChild->sSiblings, offsetof(struct sHandle, sSiblings), ui32Parent);
+
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(HandleListRemove)
+#endif
+static INLINE
+IMG_VOID HandleListRemove(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32EntryIndex, struct sHandleList *psEntry, IMG_SIZE_T uiEntryOffset, IMG_SIZE_T uiParentOffset)
+{
+        if (!HandleListIsEmpty(ui32EntryIndex, psEntry))
+        {
+                 
+                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);
+
+                psPrev->ui32Next = psEntry->ui32Next;
+                psNext->ui32Prev = psEntry->ui32Prev;
+
+                HandleListInit(ui32EntryIndex, psEntry, IMG_NULL);
+        }
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(UnlinkFromParent)
+#endif
+static INLINE
+IMG_VOID UnlinkFromParent(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psHandle)
+{
+        HandleListRemove(psBase, HANDLE_PTR_TO_INDEX(psHandle), &psHandle->sSiblings, offsetof(struct sHandle, sSiblings), offsetof(struct sHandle, sChildren));
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(HandleListIterate)
+#endif
+static INLINE
+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(psHead->hParent);
+
+        PVR_ASSERT(psHead->hParent != IMG_NULL);
+
+        
+        for(ui32Index = psHead->ui32Next; ui32Index != ui32Parent; )
+        {
+                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;
+
+                PVR_ASSERT(psEntry->hParent == psHead->hParent);
+                
+                ui32Index = psEntry->ui32Next;
+
+                eError = (*pfnIterFunc)(psBase, psHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        return eError;
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(IterateOverChildren)
+#endif
+static INLINE
+PVRSRV_ERROR IterateOverChildren(PVRSRV_HANDLE_BASE *psBase, struct sHandle *psParent, PVRSRV_ERROR (*pfnIterFunc)(PVRSRV_HANDLE_BASE *, struct sHandle *))
+{
+         return HandleListIterate(psBase, &psParent->sChildren, offsetof(struct sHandle, sChildren), offsetof(struct sHandle, sSiblings), pfnIterFunc);
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(GetHandleStructure)
+#endif
+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(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_HANDLE_INDEX_OUT_OF_RANGE;
+        }
+
+        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_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_HANDLE_TYPE_MISMATCH;
+        }
+
+        
+        *ppsHandle = psHandle;
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(ParentIfPrivate)
+#endif
+static INLINE
+IMG_HANDLE ParentIfPrivate(struct sHandle *psHandle)
+{
+        return TEST_ALLOC_FLAG(psHandle, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ?
+                        ParentHandle(psHandle) : IMG_NULL;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(InitKey)
+#endif
+static INLINE
+IMG_VOID InitKey(HAND_KEY aKey, PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hParent)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        aKey[HAND_KEY_DATA] = (IMG_UINTPTR_T)pvData;
+        aKey[HAND_KEY_TYPE] = (IMG_UINTPTR_T)eType;
+        aKey[HAND_KEY_PARENT] = (IMG_UINTPTR_T)hParent;
+}
+
+static
+PVRSRV_ERROR ReallocHandleArray(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32NewCount)
+{
+        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 (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,
+                                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, "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
+                {
+                        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;
+                }
+        }
+
+        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(psHandle);
+        PVRSRV_ERROR eError;
+
+        
+        InitKey(aKey, psBase, psHandle->pvData, psHandle->eType, ParentIfPrivate(psHandle));
+
+        if (!TEST_ALLOC_FLAG(psHandle, PVRSRV_HANDLE_ALLOC_FLAG_MULTI) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
+        {
+                IMG_HANDLE hHandle;
+                hHandle = (IMG_HANDLE) HASH_Remove_Extended(psBase->psHashTab, aKey);
+
+                PVR_ASSERT(hHandle != IMG_NULL);
+                PVR_ASSERT(hHandle == INDEX_TO_HANDLE(ui32Index));
+                PVR_UNREFERENCED_PARAMETER(hHandle);
+        }
+
+        
+        UnlinkFromParent(psBase, psHandle);
+
+        
+        eError = IterateOverChildren(psBase, psHandle, FreeHandle);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreeHandle: Error whilst freeing subhandles (%d)", eError));
+                return eError;
+        }
+
+        
+        psHandle->eType = PVRSRV_HANDLE_TYPE_NONE;
+
+        if (BATCHED_HANDLE(psHandle) && !BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
+        {
+                 
+        SET_BATCHED_HANDLE_PARTIALLY_FREE(psHandle);
+                
+                return PVRSRV_OK;
+        }
+
+        
+        if (!psBase->bPurgingEnabled)
+        {
+                if (psBase->ui32FreeHandCount == 0)
+                {
+                        PVR_ASSERT(psBase->ui32FirstFreeIndex == 0);
+                        PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == 0);
+
+                        psBase->ui32FirstFreeIndex =  ui32Index;
+                }
+                else
+                {
+                        
+                        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 =  ui32Index + 1;
+                }
+
+                PVR_ASSERT(psHandle->ui32NextIndexPlusOne == 0);
+
+                
+                psBase->ui32LastFreeIndexPlusOne = ui32Index + 1;
+        }
+
+        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;
+}
+
+static PVRSRV_ERROR FreeAllHandles(PVRSRV_HANDLE_BASE *psBase)
+{
+        IMG_UINT32 i;
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        if (psBase->ui32FreeHandCount == psBase->ui32TotalHandCount)
+        {
+                return eError;
+        }
+
+        for (i = 0; i < psBase->ui32TotalHandCount; i++)
+        {
+                struct sHandle *psHandle;
+
+                psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, i);
+
+                if (psHandle->eType != PVRSRV_HANDLE_TYPE_NONE)
+                {
+                        eError = FreeHandle(psBase, psHandle);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "FreeAllHandles: FreeHandle failed (%d)", eError));
+                                break;
+                        }
+
+                        
+                        if (psBase->ui32FreeHandCount == psBase->ui32TotalHandCount)
+                        {
+                                break;
+                        }
+                }
+        }
+
+        return eError;
+}
+
+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"));
+                PVRSRVReleaseHandleBatch(psBase);
+        }
+
+        
+        eError = FreeAllHandles(psBase);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handles (%d)", eError));
+                return eError;
+        }
+
+        
+        eError = FreeHandleArray(psBase);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handle array (%d)", eError));
+                return eError;
+        }
+
+        if (psBase->psHashTab != IMG_NULL)
+        {
+                
+                HASH_Delete(psBase->psHashTab);
+        }
+
+        eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                sizeof(*psBase),
+                psBase,
+                psBase->hBaseBlockAlloc);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreeHandleBase: Couldn't free handle base (%d)", eError));
+                return eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(FindHandle)
+#endif
+static INLINE
+IMG_HANDLE FindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hParent)
+{
+        HAND_KEY aKey;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        InitKey(aKey, psBase, pvData, eType, hParent);
+
+        return (IMG_HANDLE) HASH_Retrieve_Extended(psBase->psHashTab, aKey);
+}
+
+static PVRSRV_ERROR IncreaseHandleArraySize(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32Delta)
+{
+        PVRSRV_ERROR eError;
+        IMG_UINT32 ui32DeltaAdjusted = ROUND_UP_TO_MULTIPLE_OF_BLOCK_SIZE(ui32Delta);
+        IMG_UINT32 ui32NewTotalHandCount = psBase->ui32TotalHandCount + ui32DeltaAdjusted;
+;
+
+        PVR_ASSERT(ui32Delta != 0);
+
+        
+        if (ui32NewTotalHandCount > psBase->ui32MaxIndexPlusOne || ui32NewTotalHandCount <= psBase->ui32TotalHandCount)
+        {
+                ui32NewTotalHandCount = psBase->ui32MaxIndexPlusOne;
+
+                ui32DeltaAdjusted = ui32NewTotalHandCount - psBase->ui32TotalHandCount;
+
+                if (ui32DeltaAdjusted < ui32Delta)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "IncreaseHandleArraySize: Maximum handle limit reached (%d)", psBase->ui32MaxIndexPlusOne));
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+        }
+
+        PVR_ASSERT(ui32DeltaAdjusted >= ui32Delta);
+
+        
+        eError = ReallocHandleArray(psBase, ui32NewTotalHandCount);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "IncreaseHandleArraySize: ReallocHandleArray failed (%d)", eError));
+                return eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+static PVRSRV_ERROR EnsureFreeHandles(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32Free)
+{
+        PVRSRV_ERROR eError;
+
+        if (ui32Free > psBase->ui32FreeHandCount)
+        {
+                IMG_UINT32 ui32FreeHandDelta = ui32Free - psBase->ui32FreeHandCount;
+                eError = IncreaseHandleArraySize(psBase, ui32FreeHandDelta);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "EnsureFreeHandles: Couldn't allocate %u handles to ensure %u free handles (IncreaseHandleArraySize failed with error %d)", ui32FreeHandDelta, ui32Free, eError));
+
+                        return eError;
+                }
+        }
+
+        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 = DEFAULT_MAX_INDEX_PLUS_ONE;
+        struct sHandle *psNewHandle = IMG_NULL;
+        IMG_HANDLE hHandle;
+        HAND_KEY aKey;
+        PVRSRV_ERROR eError;
+
+        
+        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))
+        {
+                
+                PVR_ASSERT(FindHandle(psBase, pvData, eType, hParent) == IMG_NULL);
+        }
+
+        if (psBase->ui32FreeHandCount == 0 && HANDLES_BATCHED(psBase))
+        {
+                 PVR_DPF((PVR_DBG_WARNING, "AllocHandle: Handle batch size (%u) was too small, allocating additional space", psBase->ui32HandBatchSize));
+        }
+
+        
+        eError = EnsureFreeHandles(psBase, 1);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "AllocHandle: EnsureFreeHandles failed (%d)", eError));
+                return eError;
+        }
+        PVR_ASSERT(psBase->ui32FreeHandCount != 0)
+
+        if (!psBase->bPurgingEnabled)
+        {
+                
+                ui32NewIndex = psBase->ui32FirstFreeIndex;
+
+                
+                psNewHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32NewIndex);
+        }
+        else
+        {
+                IMG_UINT32 ui32BlockedIndex;
+
+                
+                
+                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)
+                {
+                        struct sHandleIndex *psIndex = BASE_AND_INDEX_TO_INDEX_STRUCT_PTR(psBase, ui32BlockedIndex);
+
+                        if (psIndex->ui32FreeHandBlockCount == 0)
+                        {
+                                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(ui32NewIndex);
+
+        
+        if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
+        {
+                
+                InitKey(aKey, psBase, pvData, eType, hParent);
+
+                
+                if (!HASH_Insert_Extended(psBase->psHashTab, aKey, (IMG_UINTPTR_T)hHandle))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "AllocHandle: Couldn't add handle to hash table"));
+
+                        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)
+        {
+                
+                if (psBase->ui32FreeHandCount == 0)
+                {
+                        PVR_ASSERT(psBase->ui32FirstFreeIndex == ui32NewIndex);
+                        PVR_ASSERT(psBase->ui32LastFreeIndexPlusOne == (ui32NewIndex + 1));
+
+                        psBase->ui32LastFreeIndexPlusOne = 0;
+                        psBase->ui32FirstFreeIndex = 0;
+                }
+                else
+                {
+                        
+                        psBase->ui32FirstFreeIndex = (psNewHandle->ui32NextIndexPlusOne == 0) ?
+                                ui32NewIndex + 1 :
+                                psNewHandle->ui32NextIndexPlusOne - 1;
+                }
+        }
+
+        
+        PVR_ASSERT(psNewHandle->ui32Index == ui32NewIndex);
+
+         
+        psNewHandle->eType = eType;
+        psNewHandle->pvData = pvData;
+        psNewHandle->eInternalFlag = INTERNAL_HANDLE_FLAG_NONE;
+        psNewHandle->eFlag = eFlag;
+
+        InitParentList(psNewHandle);
+#if defined(DEBUG)
+        PVR_ASSERT(NoChildren(psNewHandle));
+#endif
+
+        InitChildEntry(psNewHandle);
+#if defined(DEBUG)
+        PVR_ASSERT(NoParent(psNewHandle));
+#endif
+
+        if (HANDLES_BATCHED(psBase))
+        {
+                
+                psNewHandle->ui32NextIndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
+
+                psBase->ui32FirstBatchIndexPlusOne = ui32NewIndex + 1;
+
+                 
+                SET_BATCHED_HANDLE(psNewHandle);
+        }
+        else
+        {
+                psNewHandle->ui32NextIndexPlusOne = 0;
+        }
+
+        
+        *phHandle = hHandle;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVAllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag)
+{
+        IMG_HANDLE hHandle;
+        PVRSRV_ERROR eError;
+
+        *phHandle = IMG_NULL;
+
+        if (HANDLES_BATCHED(psBase))
+        {
+                
+                psBase->ui32BatchHandAllocFailures++;
+        }
+
+        
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
+        {
+                
+                hHandle = FindHandle(psBase, pvData, eType, IMG_NULL);
+                if (hHandle != IMG_NULL)
+                {
+                        struct sHandle *psHandle;
+
+                        eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandle: Lookup of existing handle failed"));
+                                return eError;
+                        }
+
+                        
+                        if (TEST_FLAG(psHandle->eFlag & eFlag, PVRSRV_HANDLE_ALLOC_FLAG_SHARED))
+                        {
+                                *phHandle = hHandle;
+                                eError = PVRSRV_OK;
+                                goto exit_ok;
+                        }
+                        return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
+                }
+        }
+
+        eError = AllocHandle(psBase, phHandle, pvData, eType, eFlag, IMG_NULL);
+
+exit_ok:
+        if (HANDLES_BATCHED(psBase) && (eError == PVRSRV_OK))
+        {
+                psBase->ui32BatchHandAllocFailures--;
+        }
+
+        return eError;
+}
+
+PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent)
+{
+        struct sHandle *psPHand;
+        struct sHandle *psCHand;
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hParentKey;
+        IMG_HANDLE hHandle;
+
+        *phHandle = IMG_NULL;
+
+        if (HANDLES_BATCHED(psBase))
+        {
+                
+                psBase->ui32BatchHandAllocFailures++;
+        }
+
+        
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        hParentKey = TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE) ?
+                        hParent : IMG_NULL;
+
+        
+        eError = GetHandleStructure(psBase, &psPHand, hParent, PVRSRV_HANDLE_TYPE_NONE);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        if (!TEST_FLAG(eFlag, PVRSRV_HANDLE_ALLOC_FLAG_MULTI))
+        {
+                
+                hHandle = FindHandle(psBase, pvData, eType, hParentKey);
+                if (hHandle != IMG_NULL)
+                {
+                        struct sHandle *psCHandle;
+                        PVRSRV_ERROR eErr;
+
+                        eErr = GetHandleStructure(psBase, &psCHandle, hHandle, eType);
+                        if (eErr != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSubHandle: Lookup of existing handle failed"));
+                                return eErr;
+                        }
+
+                        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_STRUCT_PTR(psBase, hHandle)) == hParent)
+                        {
+                                *phHandle = hHandle;
+                                goto exit_ok;
+                        }
+                        return PVRSRV_ERROR_HANDLE_NOT_SHAREABLE;
+                }
+        }
+
+        eError = AllocHandle(psBase, &hHandle, pvData, eType, eFlag, hParentKey);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        
+        psPHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hParent);
+
+        psCHand = HANDLE_TO_HANDLE_STRUCT_PTR(psBase, hHandle);
+
+        AdoptChild(psBase, psPHand, psCHand);
+
+        *phHandle = hHandle;
+
+exit_ok:
+        if (HANDLES_BATCHED(psBase))
+        {
+                psBase->ui32BatchHandAllocFailures--;
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVFindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType)
+{
+        IMG_HANDLE hHandle;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        
+        hHandle = (IMG_HANDLE) FindHandle(psBase, pvData, eType, IMG_NULL);
+        if (hHandle == IMG_NULL)
+        {
+                return PVRSRV_ERROR_HANDLE_NOT_FOUND;
+        }
+
+        *phHandle = hHandle;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVLookupHandleAnyType(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, PVRSRV_HANDLE_TYPE *peType, IMG_HANDLE hHandle)
+{
+        struct sHandle *psHandle;
+        PVRSRV_ERROR eError;
+
+        eError = GetHandleStructure(psBase, &psHandle, hHandle, PVRSRV_HANDLE_TYPE_NONE);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupHandleAnyType: Error looking up handle (%d)", eError));
+                return eError;
+        }
+
+        *ppvData = psHandle->pvData;
+        *peType = psHandle->eType;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVLookupHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        struct sHandle *psHandle;
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupHandle: Error looking up handle (%d)", eError));
+                return eError;
+        }
+
+        *ppvData = psHandle->pvData;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVLookupSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hAncestor)
+{
+        struct sHandle *psPHand;
+        struct sHandle *psCHand;
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        eError = GetHandleStructure(psBase, &psCHand, hHandle, eType);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupSubHandle: Error looking up subhandle (%d)", eError));
+                return eError;
+        }
+
+        
+        for (psPHand = psCHand; ParentHandle(psPHand) != hAncestor; )
+        {
+                eError = GetHandleStructure(psBase, &psPHand, ParentHandle(psPHand), PVRSRV_HANDLE_TYPE_NONE);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupSubHandle: Subhandle doesn't belong to given ancestor"));
+                        return PVRSRV_ERROR_INVALID_SUBHANDLE;
+                }
+        }
+
+        *ppvData = psCHand->pvData;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVGetParentHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *phParent, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        struct sHandle *psHandle;
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetParentHandle: Error looking up subhandle (%d)", eError));
+                return eError;
+        }
+
+        *phParent = ParentHandle(psHandle);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVLookupAndReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        struct sHandle *psHandle;
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVLookupAndReleaseHandle: Error looking up handle (%d)", eError));
+                return eError;
+        }
+
+        *ppvData = psHandle->pvData;
+
+        eError = FreeHandle(psBase, psHandle);
+
+        return eError;
+}
+
+PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        struct sHandle *psHandle;
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(eType != PVRSRV_HANDLE_TYPE_NONE);
+
+        eError = GetHandleStructure(psBase, &psHandle, hHandle, eType);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVReleaseHandle: Error looking up handle (%d)", eError));
+                return eError;
+        }
+
+        eError = FreeHandle(psBase, psHandle);
+
+        return eError;
+}
+
+PVRSRV_ERROR PVRSRVNewHandleBatch(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32BatchSize)
+{
+        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_HANDLE_BATCH_IN_USE;
+        }
+
+        if (ui32BatchSize == 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: Invalid batch size (%u)", ui32BatchSize));
+                return  PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        eError = EnsureFreeHandles(psBase, ui32BatchSize);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVNewHandleBatch: EnsureFreeHandles failed (error %d)", eError));
+                return eError;
+        }
+
+        psBase->ui32HandBatchSize = ui32BatchSize;
+
+        
+        psBase->ui32TotalHandCountPreBatch = psBase->ui32TotalHandCount;
+
+        PVR_ASSERT(psBase->ui32BatchHandAllocFailures == 0);
+
+        PVR_ASSERT(psBase->ui32FirstBatchIndexPlusOne == 0);
+
+        PVR_ASSERT(HANDLES_BATCHED(psBase));
+
+        return PVRSRV_OK;
+}
+
+static PVRSRV_ERROR PVRSRVHandleBatchCommitOrRelease(PVRSRV_HANDLE_BASE *psBase, IMG_BOOL bCommit)
+{
+
+        IMG_UINT32 ui32IndexPlusOne;
+        IMG_BOOL bCommitBatch = bCommit;
+
+        if (!HANDLES_BATCHED(psBase))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: There is no handle batch"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+
+        }
+
+        if (psBase->ui32BatchHandAllocFailures != 0)
+        {
+                if (bCommit)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: Attempting to commit batch with handle allocation failures."));
+                }
+                bCommitBatch = IMG_FALSE;
+        }
+        
+        PVR_ASSERT(psBase->ui32BatchHandAllocFailures == 0 || !bCommit);
+
+        ui32IndexPlusOne = psBase->ui32FirstBatchIndexPlusOne;
+        while(ui32IndexPlusOne != 0)
+        {
+                struct sHandle *psHandle = INDEX_TO_HANDLE_STRUCT_PTR(psBase, ui32IndexPlusOne - 1);
+                IMG_UINT32 ui32NextIndexPlusOne = psHandle->ui32NextIndexPlusOne;
+                PVR_ASSERT(BATCHED_HANDLE(psHandle));
+
+                psHandle->ui32NextIndexPlusOne = 0;
+
+                if (!bCommitBatch || BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
+                {
+                        PVRSRV_ERROR eError;
+
+                        
+                        if (!BATCHED_HANDLE_PARTIALLY_FREE(psHandle))
+                        {
+                                 
+                                SET_UNBATCHED_HANDLE(psHandle);  
+                        }
+
+                        eError = FreeHandle(psBase, psHandle);
+                        if (eError != PVRSRV_OK)
+                        {
+                                 PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleBatchCommitOrRelease: Error freeing handle (%d)", eError));
+                        }
+                        PVR_ASSERT(eError == PVRSRV_OK);
+                }
+                else
+                {
+                         
+                        SET_UNBATCHED_HANDLE(psHandle);
+                }
+
+                ui32IndexPlusOne = ui32NextIndexPlusOne;
+        }
+
+#ifdef DEBUG
+        if (psBase->ui32TotalHandCountPreBatch != psBase->ui32TotalHandCount)
+        {
+                IMG_UINT32 ui32Delta = psBase->ui32TotalHandCount - psBase->ui32TotalHandCountPreBatch;
+
+                PVR_ASSERT(psBase->ui32TotalHandCount > psBase->ui32TotalHandCountPreBatch);
+
+                PVR_DPF((PVR_DBG_WARNING, "PVRSRVHandleBatchCommitOrRelease: The batch size was too small.  Batch size was %u, but needs to be %u", psBase->ui32HandBatchSize,  psBase->ui32HandBatchSize + ui32Delta));
+
+        }
+#endif
+
+        psBase->ui32HandBatchSize = 0;
+        psBase->ui32FirstBatchIndexPlusOne = 0;
+        psBase->ui32TotalHandCountPreBatch = 0;
+        psBase->ui32BatchHandAllocFailures = 0;
+
+        if (psBase->ui32BatchHandAllocFailures != 0 && bCommit)
+        {
+                PVR_ASSERT(!bCommitBatch);
+
+                return PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE;
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVCommitHandleBatch(PVRSRV_HANDLE_BASE *psBase)
+{
+        return PVRSRVHandleBatchCommitOrRelease(psBase, IMG_TRUE);
+}
+
+IMG_VOID PVRSRVReleaseHandleBatch(PVRSRV_HANDLE_BASE *psBase)
+{
+        (IMG_VOID) PVRSRVHandleBatchCommitOrRelease(psBase, IMG_FALSE);
+}
+
+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"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        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));
+
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        if (psBase->ui32TotalHandCount != 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVSetMaxHandle: Limit cannot be set because handles have already been allocated"));
+
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        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;
+}
+
+IMG_UINT32 PVRSRVGetMaxHandle(PVRSRV_HANDLE_BASE *psBase)
+{
+        return psBase->ui32MaxIndexPlusOne;
+}
+
+PVRSRV_ERROR PVRSRVEnableHandlePurging(PVRSRV_HANDLE_BASE *psBase)
+{
+        if (psBase->bPurgingEnabled)
+        {
+                PVR_DPF((PVR_DBG_WARNING, "PVRSRVEnableHandlePurging: Purging already enabled"));
+                return PVRSRV_OK;
+        }
+
+        
+        if (psBase->ui32TotalHandCount != 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVEnableHandlePurging: Handles have already been allocated"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psBase->bPurgingEnabled = IMG_TRUE;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVPurgeHandles(PVRSRV_HANDLE_BASE *psBase)
+{
+        IMG_UINT32 ui32BlockIndex;
+        IMG_UINT32 ui32NewHandCount;
+
+        if (!psBase->bPurgingEnabled)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPurgeHandles: Purging not enabled for this handle base"));
+                return PVRSRV_ERROR_NOT_SUPPORTED;
+        }
+
+        if (HANDLES_BATCHED(psBase))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPurgeHandles: Purging not allowed whilst in batch mode"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        PVR_ASSERT((psBase->ui32TotalHandCount % HANDLE_BLOCK_SIZE) == 0);
+
+        for (ui32BlockIndex = INDEX_TO_BLOCK_INDEX(psBase->ui32TotalHandCount); ui32BlockIndex != 0; ui32BlockIndex--)
+        {
+                if (psBase->psHandleArray[ui32BlockIndex - 1].ui32FreeHandBlockCount != HANDLE_BLOCK_SIZE)
+                {
+                        break;
+                }
+        }
+        ui32NewHandCount = BLOCK_INDEX_TO_INDEX(ui32BlockIndex);
+
+        
+        if (ui32NewHandCount <= (psBase->ui32TotalHandCount/2))
+        {
+                PVRSRV_ERROR eError;
+
+                
+
+                eError = ReallocHandleArray(psBase, ui32NewHandCount);
+                if (eError != PVRSRV_OK)
+                {
+                        return eError;
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase)
+{
+        PVRSRV_HANDLE_BASE *psBase;
+        IMG_HANDLE hBlockAlloc;
+        PVRSRV_ERROR eError;
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                sizeof(*psBase),
+                (IMG_PVOID *)&psBase,
+                &hBlockAlloc,
+                "Handle Base");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't allocate handle base (%d)", eError));
+                return eError;
+        }
+        OSMemSet(psBase, 0, sizeof(*psBase));
+
+        
+        psBase->psHashTab = HASH_Create_Extended(HANDLE_HASH_TAB_INIT_SIZE, sizeof(HAND_KEY), HASH_Func_Default, HASH_Key_Comp_Default);
+        if (psBase->psHashTab == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't create data pointer hash table\n"));
+                (IMG_VOID)PVRSRVFreeHandleBase(psBase);
+                return PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE;
+        }
+
+        psBase->hBaseBlockAlloc = hBlockAlloc;
+
+        psBase->ui32MaxIndexPlusOne = DEFAULT_MAX_INDEX_PLUS_ONE;
+
+        *ppsBase = psBase;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVFreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(psBase != gpsKernelHandleBase);
+
+        eError = FreeHandleBase(psBase);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeHandleBase: FreeHandleBase failed (%d)", eError));
+        }
+
+        return eError;
+}
+
+PVRSRV_ERROR PVRSRVHandleInit(IMG_VOID)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(gpsKernelHandleBase == IMG_NULL);
+
+        eError = PVRSRVAllocHandleBase(&gpsKernelHandleBase);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleInit: PVRSRVAllocHandleBase failed (%d)", eError));
+                goto error;
+        }
+
+        eError = PVRSRVEnableHandlePurging(gpsKernelHandleBase);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleInit: PVRSRVEnableHandlePurging failed (%d)", eError));
+                goto error;
+        }
+
+        return PVRSRV_OK;
+error:
+        (IMG_VOID) PVRSRVHandleDeInit();
+        return eError;
+}
+
+PVRSRV_ERROR PVRSRVHandleDeInit(IMG_VOID)
+{
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        if (gpsKernelHandleBase != IMG_NULL)
+        {
+                eError = FreeHandleBase(gpsKernelHandleBase);
+                if (eError == PVRSRV_OK)
+                {
+                        gpsKernelHandleBase = IMG_NULL;
+                }
+                else
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVHandleDeInit: FreeHandleBase failed (%d)", eError));
+                }
+        }
+
+        return eError;
+}
+#else
+#endif  
diff --git a/drivers/gpu/pvr/handle.h b/drivers/gpu/pvr/handle.h
new file mode 100644
index 00000000000..56de04aede0
--- /dev/null
+++ b/drivers/gpu/pvr/handle.h
@@ -0,0 +1,383 @@
+/**********************************************************************
+ *
+ * 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 __HANDLE_H__
+#define __HANDLE_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "img_types.h"
+#include "hash.h"
+#include "resman.h"
+
+typedef enum
+{
+        PVRSRV_HANDLE_TYPE_NONE = 0,
+        PVRSRV_HANDLE_TYPE_PERPROC_DATA,
+        PVRSRV_HANDLE_TYPE_DEV_NODE,
+        PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT,
+        PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
+        PVRSRV_HANDLE_TYPE_MEM_INFO,
+        PVRSRV_HANDLE_TYPE_SYNC_INFO,
+        PVRSRV_HANDLE_TYPE_DISP_INFO,
+        PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
+        PVRSRV_HANDLE_TYPE_BUF_INFO,
+        PVRSRV_HANDLE_TYPE_DISP_BUFFER,
+        PVRSRV_HANDLE_TYPE_BUF_BUFFER,
+        PVRSRV_HANDLE_TYPE_SGX_HW_RENDER_CONTEXT,
+        PVRSRV_HANDLE_TYPE_SGX_HW_TRANSFER_CONTEXT,
+        PVRSRV_HANDLE_TYPE_SGX_HW_2D_CONTEXT,
+        PVRSRV_HANDLE_TYPE_SHARED_PB_DESC,
+        PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+        PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
+        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_SYNC_INFO_MOD_OBJ
+} PVRSRV_HANDLE_TYPE;
+
+typedef enum
+{
+        
+        PVRSRV_HANDLE_ALLOC_FLAG_NONE =                 0,
+        
+        PVRSRV_HANDLE_ALLOC_FLAG_SHARED =               0x01,
+        
+        PVRSRV_HANDLE_ALLOC_FLAG_MULTI =                0x02,
+        
+        PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE =              0x04
+} PVRSRV_HANDLE_ALLOC_FLAG;
+
+struct _PVRSRV_HANDLE_BASE_;
+typedef struct _PVRSRV_HANDLE_BASE_ PVRSRV_HANDLE_BASE;
+
+#ifdef  PVR_SECURE_HANDLES
+extern PVRSRV_HANDLE_BASE *gpsKernelHandleBase;
+
+#define KERNEL_HANDLE_BASE (gpsKernelHandleBase)
+
+PVRSRV_ERROR PVRSRVAllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag);
+
+PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent);
+
+PVRSRV_ERROR PVRSRVFindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType);
+
+PVRSRV_ERROR PVRSRVLookupHandleAnyType(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, PVRSRV_HANDLE_TYPE *peType, IMG_HANDLE hHandle);
+
+PVRSRV_ERROR PVRSRVLookupHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType);
+
+PVRSRV_ERROR PVRSRVLookupSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hAncestor);
+
+PVRSRV_ERROR PVRSRVGetParentHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *phParent, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType);
+
+PVRSRV_ERROR PVRSRVLookupAndReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType);
+
+PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType);
+
+PVRSRV_ERROR PVRSRVNewHandleBatch(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32BatchSize);
+
+PVRSRV_ERROR PVRSRVCommitHandleBatch(PVRSRV_HANDLE_BASE *psBase);
+
+IMG_VOID PVRSRVReleaseHandleBatch(PVRSRV_HANDLE_BASE *psBase);
+
+PVRSRV_ERROR PVRSRVSetMaxHandle(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32MaxHandle);
+
+IMG_UINT32 PVRSRVGetMaxHandle(PVRSRV_HANDLE_BASE *psBase);
+
+PVRSRV_ERROR PVRSRVEnableHandlePurging(PVRSRV_HANDLE_BASE *psBase);
+
+PVRSRV_ERROR PVRSRVPurgeHandles(PVRSRV_HANDLE_BASE *psBase);
+
+PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase);
+
+PVRSRV_ERROR PVRSRVFreeHandleBase(PVRSRV_HANDLE_BASE *psBase);
+
+PVRSRV_ERROR PVRSRVHandleInit(IMG_VOID);
+
+PVRSRV_ERROR PVRSRVHandleDeInit(IMG_VOID);
+
+#else   
+
+#define KERNEL_HANDLE_BASE IMG_NULL
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVAllocHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVAllocHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag)
+{
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(eFlag);
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        *phHandle = pvData;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVAllocSubHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVAllocSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType, PVRSRV_HANDLE_ALLOC_FLAG eFlag, IMG_HANDLE hParent)
+{
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(eFlag);
+        PVR_UNREFERENCED_PARAMETER(hParent);
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        *phHandle = pvData;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVFindHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVFindHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE *phHandle, IMG_VOID *pvData, PVRSRV_HANDLE_TYPE eType)
+{
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        *phHandle = pvData;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVLookupHandleAnyType)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVLookupHandleAnyType(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, PVRSRV_HANDLE_TYPE *peType, IMG_HANDLE hHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        
+        *peType = PVRSRV_HANDLE_TYPE_NONE;
+
+        *ppvData = hHandle;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVLookupHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVLookupHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        PVR_UNREFERENCED_PARAMETER(eType);
+
+        *ppvData = hHandle;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVLookupSubHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVLookupSubHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType, IMG_HANDLE hAncestor)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(hAncestor);
+
+        *ppvData = hHandle;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVGetParentHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVGetParentHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *phParent, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(hHandle);
+
+        *phParent = IMG_NULL;
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVLookupAndReleaseHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVLookupAndReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_PVOID *ppvData, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        *ppvData = hHandle;
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVReleaseHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVReleaseHandle(PVRSRV_HANDLE_BASE *psBase, IMG_HANDLE hHandle, PVRSRV_HANDLE_TYPE eType)
+{
+        PVR_UNREFERENCED_PARAMETER(hHandle);
+        PVR_UNREFERENCED_PARAMETER(eType);
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVNewHandleBatch)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVNewHandleBatch(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32BatchSize)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        PVR_UNREFERENCED_PARAMETER(ui32BatchSize);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVCommitHandleBatch)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVCommitHandleBatch(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVReleaseHandleBatch)
+#endif
+static INLINE
+IMG_VOID PVRSRVReleaseHandleBatch(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVSetMaxHandle)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVSetMaxHandle(PVRSRV_HANDLE_BASE *psBase, IMG_UINT32 ui32MaxHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+        PVR_UNREFERENCED_PARAMETER(ui32MaxHandle);
+
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVGetMaxHandle)
+#endif
+static INLINE
+IMG_UINT32 PVRSRVGetMaxHandle(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return 0;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVEnableHandlePurging)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVEnableHandlePurging(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVPurgeHandles)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVPurgeHandles(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVAllocHandleBase)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase)
+{
+        *ppsBase = IMG_NULL;
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVFreeHandleBase)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVFreeHandleBase(PVRSRV_HANDLE_BASE *psBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psBase);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVHandleInit)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVHandleInit(IMG_VOID)
+{
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVHandleDeInit)
+#endif
+static INLINE
+PVRSRV_ERROR PVRSRVHandleDeInit(IMG_VOID)
+{
+        return PVRSRV_OK;
+}
+
+#endif  
+
+#define PVRSRVAllocHandleNR(psBase, phHandle, pvData, eType, eFlag) \
+        (IMG_VOID)PVRSRVAllocHandle(psBase, phHandle, pvData, eType, eFlag)
+
+#define PVRSRVAllocSubHandleNR(psBase, phHandle, pvData, eType, eFlag, hParent) \
+        (IMG_VOID)PVRSRVAllocSubHandle(psBase, phHandle, pvData, eType, eFlag, hParent)
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/hash.c b/drivers/gpu/pvr/hash.c
new file mode 100644
index 00000000000..32b0779d456
--- /dev/null
+++ b/drivers/gpu/pvr/hash.c
@@ -0,0 +1,477 @@
+/**********************************************************************
+ *
+ * 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 "pvr_debug.h"
+#include "img_defs.h"
+#include "services.h"
+#include "servicesint.h"
+#include "hash.h"
+#include "osfunc.h"
+
+#define PRIVATE_MAX(a,b) ((a)>(b)?(a):(b))
+
+#define KEY_TO_INDEX(pHash, key, uSize) \
+        ((pHash)->pfnHashFunc((pHash)->uKeySize, (key), (uSize)) % (uSize))
+
+#define KEY_COMPARE(pHash, pKey1, pKey2) \
+        ((pHash)->pfnKeyComp((pHash)->uKeySize, (pKey1), (pKey2)))
+
+struct _BUCKET_
+{
+        
+        struct _BUCKET_ *pNext;
+
+        
+        IMG_UINTPTR_T v;
+
+        
+        IMG_UINTPTR_T k[];               
+};
+typedef struct _BUCKET_ BUCKET;
+
+struct _HASH_TABLE_
+{
+        
+        BUCKET **ppBucketTable;
+
+        
+        IMG_UINT32 uSize;
+
+        
+        IMG_UINT32 uCount;
+
+        
+        IMG_UINT32 uMinimumSize;
+
+        
+        IMG_UINT32 uKeySize;
+
+        
+        HASH_FUNC *pfnHashFunc;
+
+        
+        HASH_KEY_COMP *pfnKeyComp;
+};
+
+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_UINT32 uHashKey = 0;
+
+        PVR_UNREFERENCED_PARAMETER(uHashTabLen);
+
+        PVR_ASSERT((uKeySize % sizeof(IMG_UINTPTR_T)) == 0);
+
+        for (ui = 0; ui < uKeyLen; ui++)
+        {
+                IMG_UINT32 uHashPart = (IMG_UINT32)*p++;
+
+                uHashPart += (uHashPart << 12);
+                uHashPart ^= (uHashPart >> 22);
+                uHashPart += (uHashPart << 4);
+                uHashPart ^= (uHashPart >> 9);
+                uHashPart += (uHashPart << 10);
+                uHashPart ^= (uHashPart >> 2);
+                uHashPart += (uHashPart << 7);
+                uHashPart ^= (uHashPart >> 12);
+
+                uHashKey += uHashPart;
+        }
+
+        return uHashKey;
+}
+
+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);
+        IMG_UINT32 ui;
+
+        PVR_ASSERT((uKeySize % sizeof(IMG_UINTPTR_T)) == 0);
+
+        for (ui = 0; ui < uKeyLen; ui++)
+        {
+                if (*p1++ != *p2++)
+                        return IMG_FALSE;
+        }
+
+        return IMG_TRUE;
+}
+
+static PVRSRV_ERROR
+_ChainInsert (HASH_TABLE *pHash, BUCKET *pBucket, BUCKET **ppBucketTable, IMG_UINT32 uSize)
+{
+        IMG_UINT32 uIndex;
+
+        PVR_ASSERT (pBucket != IMG_NULL);
+        PVR_ASSERT (ppBucketTable != IMG_NULL);
+        PVR_ASSERT (uSize != 0);
+
+        if ((pBucket == IMG_NULL) || (ppBucketTable == IMG_NULL) || (uSize == 0))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "_ChainInsert: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        uIndex = KEY_TO_INDEX(pHash, pBucket->k, uSize);         
+        pBucket->pNext = ppBucketTable[uIndex];
+        ppBucketTable[uIndex] = pBucket;
+
+        return PVRSRV_OK;
+}
+
+static PVRSRV_ERROR
+_Rehash (HASH_TABLE *pHash,
+         BUCKET **ppOldTable, IMG_UINT32 uOldSize,
+         BUCKET **ppNewTable, IMG_UINT32 uNewSize)
+{
+        IMG_UINT32 uIndex;
+        for (uIndex=0; uIndex< uOldSize; uIndex++)
+    {
+                BUCKET *pBucket;
+                pBucket = ppOldTable[uIndex];
+                while (pBucket != IMG_NULL)
+                {
+                        PVRSRV_ERROR eError;
+                        BUCKET *pNextBucket = pBucket->pNext;
+                        eError = _ChainInsert (pHash, pBucket, ppNewTable, uNewSize);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "_Rehash: call to _ChainInsert failed"));
+                                return eError;
+                        }
+                        pBucket = pNextBucket;
+                }
+    }
+        return PVRSRV_OK;
+}
+
+static IMG_BOOL
+_Resize (HASH_TABLE *pHash, IMG_UINT32 uNewSize)
+{
+        if (uNewSize != pHash->uSize)
+    {
+                BUCKET **ppNewTable;
+        IMG_UINT32 uIndex;
+
+                PVR_DPF ((PVR_DBG_MESSAGE,
+                  "HASH_Resize: oldsize=0x%x  newsize=0x%x  count=0x%x",
+                                pHash->uSize, uNewSize, pHash->uCount));
+
+                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;
+
+        if (_Rehash (pHash, pHash->ppBucketTable, pHash->uSize, ppNewTable, uNewSize) != PVRSRV_OK)
+                {
+                        return IMG_FALSE;
+                }
+
+        OSFreeMem (PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET *)*pHash->uSize, pHash->ppBucketTable, IMG_NULL);
+        
+        pHash->ppBucketTable = ppNewTable;
+        pHash->uSize = uNewSize;
+    }
+    return IMG_TRUE;
+}
+
+
+HASH_TABLE * HASH_Create_Extended (IMG_UINT32 uInitialLen, IMG_SIZE_T uKeySize, HASH_FUNC *pfnHashFunc, HASH_KEY_COMP *pfnKeyComp)
+{
+        HASH_TABLE *pHash;
+        IMG_UINT32 uIndex;
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Create_Extended: InitialSize=0x%x", uInitialLen));
+
+        if(OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                                        sizeof(HASH_TABLE),
+                                        (IMG_VOID **)&pHash, IMG_NULL,
+                                        "Hash Table") != PVRSRV_OK)
+        {
+                return IMG_NULL;
+        }
+
+        pHash->uCount = 0;
+        pHash->uSize = uInitialLen;
+        pHash->uMinimumSize = uInitialLen;
+        pHash->uKeySize = uKeySize;
+        pHash->pfnHashFunc = pfnHashFunc;
+        pHash->pfnKeyComp = pfnKeyComp;
+
+        OSAllocMem(PVRSRV_PAGEABLE_SELECT,
+                  sizeof (BUCKET *) * pHash->uSize,
+                  (IMG_PVOID*)&pHash->ppBucketTable, IMG_NULL,
+                                  "Hash Table Buckets");
+
+        if (pHash->ppBucketTable == IMG_NULL)
+    {
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(HASH_TABLE), pHash, IMG_NULL);
+                
+                return IMG_NULL;
+    }
+
+        for (uIndex=0; uIndex<pHash->uSize; uIndex++)
+                pHash->ppBucketTable[uIndex] = IMG_NULL;
+        return pHash;
+}
+
+HASH_TABLE * HASH_Create (IMG_UINT32 uInitialLen)
+{
+        return HASH_Create_Extended(uInitialLen, sizeof(IMG_UINTPTR_T),
+                &HASH_Func_Default, &HASH_Key_Comp_Default);
+}
+
+IMG_VOID
+HASH_Delete (HASH_TABLE *pHash)
+{
+        if (pHash != IMG_NULL)
+    {
+                PVR_DPF ((PVR_DBG_MESSAGE, "HASH_Delete"));
+
+                PVR_ASSERT (pHash->uCount==0);
+                if(pHash->uCount != 0)
+                {
+                        PVR_DPF ((PVR_DBG_ERROR, "HASH_Delete: leak detected in hash table!"));
+                        PVR_DPF ((PVR_DBG_ERROR, "Likely Cause: client drivers not freeing alocations before destroying devmemcontext"));
+                }
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET *)*pHash->uSize, pHash->ppBucketTable, IMG_NULL);
+                pHash->ppBucketTable = IMG_NULL;
+                OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(HASH_TABLE), pHash, IMG_NULL);
+                
+    }
+}
+
+IMG_BOOL
+HASH_Insert_Extended (HASH_TABLE *pHash, IMG_VOID *pKey, IMG_UINTPTR_T v)
+{
+        BUCKET *pBucket;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+              "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);
+
+        if (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,
+                                        (IMG_VOID **)&pBucket, IMG_NULL,
+                                        "Hash Table entry") != PVRSRV_OK)
+        {
+                return IMG_FALSE;
+        }
+
+        pBucket->v = v;
+         
+        OSMemCopy(pBucket->k, pKey, pHash->uKeySize);
+        if (_ChainInsert (pHash, pBucket, pHash->ppBucketTable, pHash->uSize) != PVRSRV_OK)
+        {
+                return IMG_FALSE;
+        }
+
+        pHash->uCount++;
+
+        
+        if (pHash->uCount << 1 > pHash->uSize)
+    {
+        
+
+        _Resize (pHash, pHash->uSize << 1);
+    }
+
+
+        return IMG_TRUE;
+}
+
+IMG_BOOL
+HASH_Insert (HASH_TABLE *pHash, IMG_UINTPTR_T k, IMG_UINTPTR_T v)
+{
+        PVR_DPF ((PVR_DBG_MESSAGE,
+              "HASH_Insert: Hash=0x%x, k=0x%x, v=0x%x",
+              (IMG_UINTPTR_T)pHash, k, v));
+
+        return HASH_Insert_Extended(pHash, &k, v);
+}
+
+IMG_UINTPTR_T
+HASH_Remove_Extended(HASH_TABLE *pHash, IMG_VOID *pKey)
+{
+        BUCKET **ppBucket;
+        IMG_UINT32 uIndex;
+
+        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"));
+                return 0;
+        }
+
+        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;
+                        (*ppBucket) = pBucket->pNext;
+
+                        OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(BUCKET) + pHash->uKeySize, pBucket, IMG_NULL);
+                        
+
+                        pHash->uCount--;
+
+                        
+                        if (pHash->uSize > (pHash->uCount << 2) &&
+                pHash->uSize > pHash->uMinimumSize)
+            {
+                
+
+                                _Resize (pHash,
+                         PRIVATE_MAX (pHash->uSize >> 1,
+                                      pHash->uMinimumSize));
+            }
+
+                        PVR_DPF ((PVR_DBG_MESSAGE,
+                      "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=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=0x%x, k=0x%x",
+                        (IMG_UINTPTR_T)pHash, k));
+
+        return HASH_Remove_Extended(pHash, &k);
+}
+
+IMG_UINTPTR_T
+HASH_Retrieve_Extended (HASH_TABLE *pHash, IMG_VOID *pKey)
+{
+        BUCKET **ppBucket;
+        IMG_UINT32 uIndex;
+
+        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"));
+                return 0;
+        }
+
+        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=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=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=0x%x, k=0x%x",
+                        (IMG_UINTPTR_T)pHash, k));
+        return HASH_Retrieve_Extended(pHash, &k);
+}
+
+#ifdef HASH_TRACE
+IMG_VOID
+HASH_Dump (HASH_TABLE *pHash)
+{
+        IMG_UINT32 uIndex;
+        IMG_UINT32 uMaxLength=0;
+        IMG_UINT32 uEmptyCount=0;
+
+        PVR_ASSERT (pHash != IMG_NULL);
+        for (uIndex=0; uIndex<pHash->uSize; uIndex++)
+        {
+                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++;
+                }
+                uMaxLength = PRIVATE_MAX (uMaxLength, uLength);
+        }
+
+        PVR_TRACE(("hash table: uMinimumSize=%d  size=%d  count=%d",
+                        pHash->uMinimumSize, pHash->uSize, pHash->uCount));
+        PVR_TRACE(("  empty=%d  max=%d", uEmptyCount, uMaxLength));
+}
+#endif
diff --git a/drivers/gpu/pvr/hash.h b/drivers/gpu/pvr/hash.h
new file mode 100644
index 00000000000..d45f4a98dda
--- /dev/null
+++ b/drivers/gpu/pvr/hash.h
@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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 _HASH_H_
+#define _HASH_H_
+
+#include "img_types.h"
+#include "osfunc.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef IMG_UINT32 HASH_FUNC(IMG_SIZE_T uKeySize, IMG_VOID *pKey, IMG_UINT32 uHashTabLen);
+typedef IMG_BOOL HASH_KEY_COMP(IMG_SIZE_T uKeySize, IMG_VOID *pKey1, IMG_VOID *pKey2);
+
+typedef struct _HASH_TABLE_ HASH_TABLE;
+
+IMG_UINT32 HASH_Func_Default (IMG_SIZE_T uKeySize, IMG_VOID *pKey, IMG_UINT32 uHashTabLen);
+
+IMG_BOOL HASH_Key_Comp_Default (IMG_SIZE_T uKeySize, IMG_VOID *pKey1, IMG_VOID *pKey2);
+
+HASH_TABLE * HASH_Create_Extended (IMG_UINT32 uInitialLen, IMG_SIZE_T uKeySize, HASH_FUNC *pfnHashFunc, HASH_KEY_COMP *pfnKeyComp);
+
+HASH_TABLE * HASH_Create (IMG_UINT32 uInitialLen);
+
+IMG_VOID HASH_Delete (HASH_TABLE *pHash);
+
+IMG_BOOL HASH_Insert_Extended (HASH_TABLE *pHash, IMG_VOID *pKey, IMG_UINTPTR_T v);
+
+IMG_BOOL HASH_Insert (HASH_TABLE *pHash, IMG_UINTPTR_T k, IMG_UINTPTR_T v);
+
+IMG_UINTPTR_T HASH_Remove_Extended(HASH_TABLE *pHash, IMG_VOID *pKey);
+
+IMG_UINTPTR_T HASH_Remove (HASH_TABLE *pHash, IMG_UINTPTR_T k);
+
+IMG_UINTPTR_T HASH_Retrieve_Extended (HASH_TABLE *pHash, IMG_VOID *pKey);
+
+IMG_UINTPTR_T HASH_Retrieve (HASH_TABLE *pHash, IMG_UINTPTR_T k);
+
+#ifdef HASH_TRACE
+IMG_VOID HASH_Dump (HASH_TABLE *pHash);
+#endif
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/img_defs.h b/drivers/gpu/pvr/img_defs.h
new file mode 100644
index 00000000000..3ba2d2fc688
--- /dev/null
+++ b/drivers/gpu/pvr/img_defs.h
@@ -0,0 +1,118 @@
+/**********************************************************************
+ *
+ * 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 (__IMG_DEFS_H__)
+#define __IMG_DEFS_H__
+
+#include "img_types.h"
+
+typedef         enum    img_tag_TriStateSwitch
+{
+        IMG_ON          =       0x00,
+        IMG_OFF,
+        IMG_IGNORE
+
+} img_TriStateSwitch, * img_pTriStateSwitch;
+
+#define         IMG_SUCCESS                             0
+
+#define         IMG_NO_REG                              1
+
+#if defined (NO_INLINE_FUNCS)
+        #define INLINE
+        #define FORCE_INLINE
+#else
+#if defined (__cplusplus)
+        #define INLINE                                  inline
+        #define FORCE_INLINE                    inline
+#else
+#if     !defined(INLINE)
+        #define INLINE                                  __inline
+#endif
+        #define FORCE_INLINE                    static __inline
+#endif
+#endif
+
+
+#ifndef PVR_UNREFERENCED_PARAMETER
+#define PVR_UNREFERENCED_PARAMETER(param) (param) = (param)
+#endif
+
+#ifdef __GNUC__
+#define unref__ __attribute__ ((unused))
+#else
+#define unref__
+#endif
+
+#ifndef _TCHAR_DEFINED
+#if defined(UNICODE)
+typedef unsigned short          TCHAR, *PTCHAR, *PTSTR;
+#else   
+typedef char                            TCHAR, *PTCHAR, *PTSTR;
+#endif  
+#define _TCHAR_DEFINED
+#endif 
+
+
+                        #if defined(__linux__) || defined(__METAG)
+
+                                #define IMG_CALLCONV
+                                #define IMG_INTERNAL    __attribute__((visibility("hidden")))
+                                #define IMG_EXPORT              __attribute__((visibility("default")))
+                                #define IMG_IMPORT
+                                #define IMG_RESTRICT    __restrict__
+
+                        #else
+                                        #error("define an OS")
+                        #endif
+
+#ifndef IMG_ABORT
+        #define IMG_ABORT()     abort()
+#endif
+
+#ifndef IMG_MALLOC
+        #define IMG_MALLOC(A)           malloc  (A)
+#endif
+
+#ifndef IMG_FREE
+        #define IMG_FREE(A)                     free    (A)
+#endif
+
+#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 
diff --git a/drivers/gpu/pvr/img_types.h b/drivers/gpu/pvr/img_types.h
new file mode 100644
index 00000000000..31962aaedbb
--- /dev/null
+++ b/drivers/gpu/pvr/img_types.h
@@ -0,0 +1,138 @@
+/**********************************************************************
+ *
+ * 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 __IMG_TYPES_H__
+#define __IMG_TYPES_H__
+
+#if !defined(IMG_ADDRSPACE_CPUVADDR_BITS)
+#define IMG_ADDRSPACE_CPUVADDR_BITS             32
+#endif
+
+#if !defined(IMG_ADDRSPACE_PHYSADDR_BITS)
+#define IMG_ADDRSPACE_PHYSADDR_BITS             32
+#endif
+
+typedef unsigned int    IMG_UINT,       *IMG_PUINT;
+typedef signed int              IMG_INT,        *IMG_PINT;
+
+typedef unsigned char   IMG_UINT8,      *IMG_PUINT8;
+typedef unsigned char   IMG_BYTE,       *IMG_PBYTE;
+typedef signed char             IMG_INT8,       *IMG_PINT8;
+typedef char                    IMG_CHAR,       *IMG_PCHAR;
+
+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
+
+        #if (defined(LINUX) || defined(__METAG))
+#if !defined(USE_CODE)
+                typedef unsigned long long              IMG_UINT64,     *IMG_PUINT64;
+                typedef long long                               IMG_INT64,      *IMG_PINT64;
+#endif
+        #else
+
+                #error("define an OS")
+
+        #endif
+
+#if !(defined(LINUX) && defined (__KERNEL__))
+typedef float                   IMG_FLOAT,      *IMG_PFLOAT;
+typedef double                  IMG_DOUBLE, *IMG_PDOUBLE;
+#endif
+
+typedef enum tag_img_bool
+{
+        IMG_FALSE               = 0,
+        IMG_TRUE                = 1,
+        IMG_FORCE_ALIGN = 0x7FFFFFFF
+} IMG_BOOL, *IMG_PBOOL;
+
+typedef void            IMG_VOID, *IMG_PVOID;
+
+typedef IMG_INT32       IMG_RESULT;
+
+#if defined(_WIN64)
+typedef unsigned __int64 IMG_UINTPTR_T;
+#else
+typedef unsigned int     IMG_UINTPTR_T;
+#endif
+
+typedef IMG_PVOID       IMG_HANDLE;
+
+typedef void**          IMG_HVOID,      * IMG_PHVOID;
+
+typedef IMG_UINT32              IMG_SIZE_T;
+
+#define IMG_NULL        0 
+
+typedef IMG_UINT32      IMG_SID;
+
+
+typedef IMG_PVOID IMG_CPU_VIRTADDR;
+
+typedef struct _IMG_DEV_VIRTADDR
+{
+        
+        IMG_UINT32  uiAddr;
+#define IMG_CAST_TO_DEVVADDR_UINT(var)          (IMG_UINT32)(var)
+        
+} IMG_DEV_VIRTADDR;
+
+typedef struct _IMG_CPU_PHYADDR
+{
+        
+        IMG_UINTPTR_T uiAddr;
+} IMG_CPU_PHYADDR;
+
+typedef struct _IMG_DEV_PHYADDR
+{
+#if IMG_ADDRSPACE_PHYSADDR_BITS == 32
+        
+        IMG_UINTPTR_T uiAddr;
+#else
+        IMG_UINT32 uiAddr;
+        IMG_UINT32 uiHighAddr;
+#endif
+} IMG_DEV_PHYADDR;
+
+typedef struct _IMG_SYS_PHYADDR
+{
+        
+        IMG_UINTPTR_T uiAddr;
+} IMG_SYS_PHYADDR;
+
+#include "img_defs.h"
+
+#endif  
diff --git a/drivers/gpu/pvr/ioctldef.h b/drivers/gpu/pvr/ioctldef.h
new file mode 100644
index 00000000000..4b23ad437a7
--- /dev/null
+++ b/drivers/gpu/pvr/ioctldef.h
@@ -0,0 +1,98 @@
+/**********************************************************************
+ *
+ * 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 __IOCTLDEF_H__
+#define __IOCTLDEF_H__
+
+#define MAKEIOCTLINDEX(i)       (((i) >> 2) & 0xFFF)
+
+#ifndef CTL_CODE
+
+#define DEVICE_TYPE ULONG
+
+#define FILE_DEVICE_BEEP                0x00000001
+#define FILE_DEVICE_CD_ROM              0x00000002
+#define FILE_DEVICE_CD_ROM_FILE_SYSTEM  0x00000003
+#define FILE_DEVICE_CONTROLLER          0x00000004
+#define FILE_DEVICE_DATALINK            0x00000005
+#define FILE_DEVICE_DFS                 0x00000006
+#define FILE_DEVICE_DISK                0x00000007
+#define FILE_DEVICE_DISK_FILE_SYSTEM    0x00000008
+#define FILE_DEVICE_FILE_SYSTEM         0x00000009
+#define FILE_DEVICE_INPORT_PORT         0x0000000a
+#define FILE_DEVICE_KEYBOARD            0x0000000b
+#define FILE_DEVICE_MAILSLOT            0x0000000c
+#define FILE_DEVICE_MIDI_IN             0x0000000d
+#define FILE_DEVICE_MIDI_OUT            0x0000000e
+#define FILE_DEVICE_MOUSE               0x0000000f
+#define FILE_DEVICE_MULTI_UNC_PROVIDER  0x00000010
+#define FILE_DEVICE_NAMED_PIPE          0x00000011
+#define FILE_DEVICE_NETWORK             0x00000012
+#define FILE_DEVICE_NETWORK_BROWSER     0x00000013
+#define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014
+#define FILE_DEVICE_NULL                0x00000015
+#define FILE_DEVICE_PARALLEL_PORT       0x00000016
+#define FILE_DEVICE_PHYSICAL_NETCARD    0x00000017
+#define FILE_DEVICE_PRINTER             0x00000018
+#define FILE_DEVICE_SCANNER             0x00000019
+#define FILE_DEVICE_SERIAL_MOUSE_PORT   0x0000001a
+#define FILE_DEVICE_SERIAL_PORT         0x0000001b
+#define FILE_DEVICE_SCREEN              0x0000001c
+#define FILE_DEVICE_SOUND               0x0000001d
+#define FILE_DEVICE_STREAMS             0x0000001e
+#define FILE_DEVICE_TAPE                0x0000001f
+#define FILE_DEVICE_TAPE_FILE_SYSTEM    0x00000020
+#define FILE_DEVICE_TRANSPORT           0x00000021
+#define FILE_DEVICE_UNKNOWN             0x00000022
+#define FILE_DEVICE_VIDEO               0x00000023
+#define FILE_DEVICE_VIRTUAL_DISK        0x00000024
+#define FILE_DEVICE_WAVE_IN             0x00000025
+#define FILE_DEVICE_WAVE_OUT            0x00000026
+#define FILE_DEVICE_8042_PORT           0x00000027
+#define FILE_DEVICE_NETWORK_REDIRECTOR  0x00000028
+#define FILE_DEVICE_BATTERY             0x00000029
+#define FILE_DEVICE_BUS_EXTENDER        0x0000002a
+#define FILE_DEVICE_MODEM               0x0000002b
+#define FILE_DEVICE_VDM                 0x0000002c
+#define FILE_DEVICE_MASS_STORAGE        0x0000002d
+
+#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
+    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
+)
+
+#define METHOD_BUFFERED                 0
+#define METHOD_IN_DIRECT                1
+#define METHOD_OUT_DIRECT               2
+#define METHOD_NEITHER                  3
+
+#define FILE_ANY_ACCESS                 0
+#define FILE_READ_ACCESS          ( 0x0001 )    
+#define FILE_WRITE_ACCESS         ( 0x0002 )    
+
+#endif 
+
+#endif 
+
diff --git a/drivers/gpu/pvr/kernelbuffer.h b/drivers/gpu/pvr/kernelbuffer.h
new file mode 100644
index 00000000000..5243aaf4a92
--- /dev/null
+++ b/drivers/gpu/pvr/kernelbuffer.h
@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * 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 (__KERNELBUFFER_H__)
+#define __KERNELBUFFER_H__
+
+#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 struct PVRSRV_BC_SRV2BUFFER_KMJTABLE_TAG
+{
+        IMG_UINT32                                                      ui32TableSize;
+        PFN_OPEN_BC_DEVICE                                      pfnOpenBCDevice;
+        PFN_CLOSE_BC_DEVICE                                     pfnCloseBCDevice;
+        PFN_GET_BC_INFO                                         pfnGetBCInfo;
+        PFN_GET_BC_BUFFER                                       pfnGetBCBuffer;
+        PFN_GET_BUFFER_ADDR                                     pfnGetBufferAddr;
+
+} PVRSRV_BC_SRV2BUFFER_KMJTABLE;
+
+
+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
diff --git a/drivers/gpu/pvr/kerneldisplay.h b/drivers/gpu/pvr/kerneldisplay.h
new file mode 100644
index 00000000000..b5c1c7a1ecd
--- /dev/null
+++ b/drivers/gpu/pvr/kerneldisplay.h
@@ -0,0 +1,165 @@
+/**********************************************************************
+ *
+ * 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 (__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*);
+typedef PVRSRV_ERROR (*PFN_ENUM_DC_DIMS)(IMG_HANDLE,
+                                                                                 DISPLAY_FORMAT*,
+                                                                                 IMG_UINT32*,
+                                                                                 DISPLAY_DIMS*);
+typedef PVRSRV_ERROR (*PFN_GET_DC_SYSTEMBUFFER)(IMG_HANDLE, IMG_HANDLE*);
+typedef PVRSRV_ERROR (*PFN_GET_DC_INFO)(IMG_HANDLE, DISPLAY_INFO*);
+typedef PVRSRV_ERROR (*PFN_CREATE_DC_SWAPCHAIN)(IMG_HANDLE,
+                                                                                                IMG_UINT32, 
+                                                                                                DISPLAY_SURF_ATTRIBUTES*, 
+                                                                                                DISPLAY_SURF_ATTRIBUTES*,
+                                                                                                IMG_UINT32, 
+                                                                                                PVRSRV_SYNC_DATA**,
+                                                                                                IMG_UINT32,
+                                                                                                IMG_HANDLE*, 
+                                                                                                IMG_UINT32*);
+typedef PVRSRV_ERROR (*PFN_DESTROY_DC_SWAPCHAIN)(IMG_HANDLE, 
+                                                                                                 IMG_HANDLE);
+typedef PVRSRV_ERROR (*PFN_SET_DC_DSTRECT)(IMG_HANDLE, IMG_HANDLE, IMG_RECT*);
+typedef PVRSRV_ERROR (*PFN_SET_DC_SRCRECT)(IMG_HANDLE, IMG_HANDLE, IMG_RECT*);
+typedef PVRSRV_ERROR (*PFN_SET_DC_DSTCK)(IMG_HANDLE, IMG_HANDLE, IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_SET_DC_SRCCK)(IMG_HANDLE, IMG_HANDLE, IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_GET_DC_BUFFERS)(IMG_HANDLE,
+                                                                                   IMG_HANDLE,
+                                                                                   IMG_UINT32*,
+                                                                                   IMG_HANDLE*);
+typedef PVRSRV_ERROR (*PFN_SWAP_TO_DC_BUFFER)(IMG_HANDLE,
+                                                                                          IMG_HANDLE,
+                                                                                          IMG_UINT32,
+                                                                                          IMG_HANDLE,
+                                                                                          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
+{
+        IMG_UINT32                                              ui32TableSize;
+        PFN_OPEN_DC_DEVICE                              pfnOpenDCDevice;
+        PFN_CLOSE_DC_DEVICE                             pfnCloseDCDevice;
+        PFN_ENUM_DC_FORMATS                             pfnEnumDCFormats;
+        PFN_ENUM_DC_DIMS                                pfnEnumDCDims;
+        PFN_GET_DC_SYSTEMBUFFER                 pfnGetDCSystemBuffer;
+        PFN_GET_DC_INFO                                 pfnGetDCInfo;
+        PFN_GET_BUFFER_ADDR                             pfnGetBufferAddr;
+        PFN_CREATE_DC_SWAPCHAIN                 pfnCreateDCSwapChain;
+        PFN_DESTROY_DC_SWAPCHAIN                pfnDestroyDCSwapChain;
+        PFN_SET_DC_DSTRECT                              pfnSetDCDstRect;
+        PFN_SET_DC_SRCRECT                              pfnSetDCSrcRect;
+        PFN_SET_DC_DSTCK                                pfnSetDCDstColourKey;
+        PFN_SET_DC_SRCCK                                pfnSetDCSrcColourKey;
+        PFN_GET_DC_BUFFERS                              pfnGetDCBuffers;
+        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;
+
+typedef IMG_BOOL (*PFN_ISR_HANDLER)(IMG_VOID*);
+
+typedef PVRSRV_ERROR (*PFN_DC_REGISTER_DISPLAY_DEV)(PVRSRV_DC_SRV2DISP_KMJTABLE*, IMG_UINT32*);
+typedef PVRSRV_ERROR (*PFN_DC_REMOVE_DISPLAY_DEV)(IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_DC_OEM_FUNCTION)(IMG_UINT32, IMG_VOID*, IMG_UINT32, IMG_VOID*, IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_DC_REGISTER_COMMANDPROCLIST)(IMG_UINT32, PPFN_CMD_PROC,IMG_UINT32[][2], IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_DC_REMOVE_COMMANDPROCLIST)(IMG_UINT32, IMG_UINT32);
+typedef IMG_VOID (*PFN_DC_CMD_COMPLETE)(IMG_HANDLE, IMG_BOOL);
+typedef PVRSRV_ERROR (*PFN_DC_REGISTER_SYS_ISR)(PFN_ISR_HANDLER, IMG_VOID*, IMG_UINT32, IMG_UINT32);
+typedef PVRSRV_ERROR (*PFN_DC_REGISTER_POWER)(IMG_UINT32, PFN_PRE_POWER, PFN_POST_POWER,
+                                                                                          PFN_PRE_CLOCKSPEED_CHANGE, PFN_POST_CLOCKSPEED_CHANGE,
+                                                                                          IMG_HANDLE, PVRSRV_DEV_POWER_STATE, PVRSRV_DEV_POWER_STATE);
+
+typedef struct PVRSRV_DC_DISP2SRV_KMJTABLE_TAG
+{
+        IMG_UINT32                                              ui32TableSize;
+        PFN_DC_REGISTER_DISPLAY_DEV             pfnPVRSRVRegisterDCDevice;
+        PFN_DC_REMOVE_DISPLAY_DEV               pfnPVRSRVRemoveDCDevice;
+        PFN_DC_OEM_FUNCTION                             pfnPVRSRVOEMFunction;
+        PFN_DC_REGISTER_COMMANDPROCLIST pfnPVRSRVRegisterCmdProcList;
+        PFN_DC_REMOVE_COMMANDPROCLIST   pfnPVRSRVRemoveCmdProcList;
+        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 struct DISPLAYCLASS_FLIP_COMMAND_TAG
+{
+        
+        IMG_HANDLE hExtDevice;
+
+        
+        IMG_HANDLE hExtSwapChain;
+
+        
+        IMG_HANDLE hExtBuffer;
+
+        
+        IMG_HANDLE hPrivateTag;
+
+        
+        IMG_UINT32 ui32ClipRectCount;
+
+        
+        IMG_RECT *psClipRect;
+
+        
+        IMG_UINT32      ui32SwapInterval;
+
+} DISPLAYCLASS_FLIP_COMMAND;
+
+#define DC_FLIP_COMMAND         0
+
+#define DC_STATE_NO_FLUSH_COMMANDS              0
+#define DC_STATE_FLUSH_COMMANDS                 1
+
+
+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
+
diff --git a/drivers/gpu/pvr/linkage.h b/drivers/gpu/pvr/linkage.h
new file mode 100644
index 00000000000..1d0d5775246
--- /dev/null
+++ b/drivers/gpu/pvr/linkage.h
@@ -0,0 +1,52 @@
+/**********************************************************************
+ *
+ * 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 __LINKAGE_H__
+#define __LINKAGE_H__
+
+#if !defined(SUPPORT_DRI_DRM)
+IMG_INT32 PVRSRV_BridgeDispatchKM(struct file *file, IMG_UINT cmd, IMG_UINT32 arg);
+#endif
+
+IMG_VOID PVRDPFInit(IMG_VOID);
+PVRSRV_ERROR PVROSFuncInit(IMG_VOID);
+IMG_VOID PVROSFuncDeInit(IMG_VOID);
+
+#ifdef DEBUG
+
+IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
+void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el);
+
+#ifdef PVR_MANUAL_POWER_CONTROL
+IMG_INT PVRProcSetPowerLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data);
+
+void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el);
+
+#endif 
+
+#endif  
+
+#endif 
diff --git a/drivers/gpu/pvr/lists.c b/drivers/gpu/pvr/lists.c
new file mode 100644
index 00000000000..58389bf4a16
--- /dev/null
+++ b/drivers/gpu/pvr/lists.c
@@ -0,0 +1,99 @@
+/**********************************************************************
+ *
+ * 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 "lists.h"
+#include "services_headers.h"
+
+IMPLEMENT_LIST_ANY_VA(BM_HEAP)
+IMPLEMENT_LIST_ANY_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_ANY_VA_2(BM_HEAP, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH_VA(BM_HEAP)
+IMPLEMENT_LIST_REMOVE(BM_HEAP)
+IMPLEMENT_LIST_INSERT(BM_HEAP)
+
+IMPLEMENT_LIST_ANY_VA(BM_CONTEXT)
+IMPLEMENT_LIST_ANY_VA_2(BM_CONTEXT, IMG_HANDLE, IMG_NULL)
+IMPLEMENT_LIST_ANY_VA_2(BM_CONTEXT, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH(BM_CONTEXT)
+IMPLEMENT_LIST_REMOVE(BM_CONTEXT)
+IMPLEMENT_LIST_INSERT(BM_CONTEXT)
+
+IMPLEMENT_LIST_ANY_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_ANY_VA(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_ANY_VA_2(PVRSRV_DEVICE_NODE, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_FOR_EACH(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_FOR_EACH_VA(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_INSERT(PVRSRV_DEVICE_NODE)
+IMPLEMENT_LIST_REMOVE(PVRSRV_DEVICE_NODE)
+
+IMPLEMENT_LIST_ANY_VA(PVRSRV_POWER_DEV)
+IMPLEMENT_LIST_ANY_VA_2(PVRSRV_POWER_DEV, PVRSRV_ERROR, PVRSRV_OK)
+IMPLEMENT_LIST_INSERT(PVRSRV_POWER_DEV)
+IMPLEMENT_LIST_REMOVE(PVRSRV_POWER_DEV)
+
+
+IMG_VOID* MatchDeviceKM_AnyVaCb(PVRSRV_DEVICE_NODE* psDeviceNode, va_list va)
+{
+        IMG_UINT32 ui32DevIndex;
+        IMG_BOOL bIgnoreClass;
+        PVRSRV_DEVICE_CLASS eDevClass;
+
+        ui32DevIndex = va_arg(va, IMG_UINT32);
+        bIgnoreClass = va_arg(va, IMG_BOOL);
+        if (!bIgnoreClass)
+        {
+                eDevClass = va_arg(va, PVRSRV_DEVICE_CLASS);
+        }
+        else
+        {
+                
+
+                eDevClass = PVRSRV_DEVICE_CLASS_FORCE_I32;
+        }
+
+        if ((bIgnoreClass || psDeviceNode->sDevId.eDeviceClass == eDevClass) &&
+                psDeviceNode->sDevId.ui32DeviceIndex == ui32DevIndex)
+        {
+                return psDeviceNode;
+        }
+        return IMG_NULL;
+}
+
+IMG_VOID* MatchPowerDeviceIndex_AnyVaCb(PVRSRV_POWER_DEV *psPowerDev, va_list va)
+{
+        IMG_UINT32 ui32DeviceIndex;
+
+        ui32DeviceIndex = va_arg(va, IMG_UINT32);
+
+        if (psPowerDev->ui32DeviceIndex == ui32DeviceIndex)
+        {
+                return psPowerDev;
+        }
+        else
+        {
+                return IMG_NULL;
+        }
+}
diff --git a/drivers/gpu/pvr/lists.h b/drivers/gpu/pvr/lists.h
new file mode 100644
index 00000000000..0d7478862e1
--- /dev/null
+++ b/drivers/gpu/pvr/lists.h
@@ -0,0 +1,244 @@
+/**********************************************************************
+ *
+ * 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 __LISTS_UTILS__
+#define __LISTS_UTILS__
+
+#include <stdarg.h>
+#include "img_types.h"
+
+#define DECLARE_LIST_FOR_EACH(TYPE) \
+IMG_VOID List_##TYPE##_ForEach(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_FOR_EACH(TYPE) \
+IMG_VOID List_##TYPE##_ForEach(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode))\
+{\
+        while(psHead)\
+        {\
+                pfnCallBack(psHead);\
+                psHead = psHead->psNext;\
+        }\
+}
+
+
+#define DECLARE_LIST_FOR_EACH_VA(TYPE) \
+IMG_VOID List_##TYPE##_ForEach_va(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_FOR_EACH_VA(TYPE) \
+IMG_VOID List_##TYPE##_ForEach_va(TYPE *psHead, IMG_VOID(*pfnCallBack)(TYPE* psNode, va_list va), ...) \
+{\
+        va_list ap;\
+        while(psHead)\
+        {\
+                va_start(ap, pfnCallBack);\
+                pfnCallBack(psHead, ap);\
+                psHead = psHead->psNext;\
+                va_end(ap);\
+        }\
+}
+
+
+#define DECLARE_LIST_ANY(TYPE) \
+IMG_VOID* List_##TYPE##_Any(TYPE *psHead, IMG_VOID* (*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_ANY(TYPE) \
+IMG_VOID* List_##TYPE##_Any(TYPE *psHead, IMG_VOID* (*pfnCallBack)(TYPE* psNode))\
+{ \
+        IMG_VOID *pResult;\
+        TYPE *psNextNode;\
+        pResult = IMG_NULL;\
+        psNextNode = psHead;\
+        while(psHead && !pResult)\
+        {\
+                psNextNode = psNextNode->psNext;\
+                pResult = pfnCallBack(psHead);\
+                psHead = psNextNode;\
+        }\
+        return pResult;\
+}
+
+
+#define DECLARE_LIST_ANY_VA(TYPE) \
+IMG_VOID* List_##TYPE##_Any_va(TYPE *psHead, IMG_VOID*(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_ANY_VA(TYPE) \
+IMG_VOID* List_##TYPE##_Any_va(TYPE *psHead, IMG_VOID*(*pfnCallBack)(TYPE* psNode, va_list va), ...)\
+{\
+        va_list ap;\
+        TYPE *psNextNode;\
+        IMG_VOID* pResult = IMG_NULL;\
+        while(psHead && !pResult)\
+        {\
+                psNextNode = psHead->psNext;\
+                va_start(ap, pfnCallBack);\
+                pResult = pfnCallBack(psHead, ap);\
+                va_end(ap);\
+                psHead = psNextNode;\
+        }\
+        return pResult;\
+}
+
+#define DECLARE_LIST_ANY_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any(TYPE *psHead, RTYPE (*pfnCallBack)(TYPE* psNode))
+
+#define IMPLEMENT_LIST_ANY_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any(TYPE *psHead, RTYPE (*pfnCallBack)(TYPE* psNode))\
+{ \
+        RTYPE result;\
+        TYPE *psNextNode;\
+        result = CONTINUE;\
+        psNextNode = psHead;\
+        while(psHead && result == CONTINUE)\
+        {\
+                psNextNode = psNextNode->psNext;\
+                result = pfnCallBack(psHead);\
+                psHead = psNextNode;\
+        }\
+        return result;\
+}
+
+
+#define DECLARE_LIST_ANY_VA_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any_va(TYPE *psHead, RTYPE(*pfnCallBack)(TYPE* psNode, va_list va), ...)
+
+#define IMPLEMENT_LIST_ANY_VA_2(TYPE, RTYPE, CONTINUE) \
+RTYPE List_##TYPE##_##RTYPE##_Any_va(TYPE *psHead, RTYPE(*pfnCallBack)(TYPE* psNode, va_list va), ...)\
+{\
+        va_list ap;\
+        TYPE *psNextNode;\
+        RTYPE result = CONTINUE;\
+        while(psHead && result == CONTINUE)\
+        {\
+                psNextNode = psHead->psNext;\
+                va_start(ap, pfnCallBack);\
+                result = pfnCallBack(psHead, ap);\
+                va_end(ap);\
+                psHead = psNextNode;\
+        }\
+        return result;\
+}
+
+
+#define DECLARE_LIST_REMOVE(TYPE) \
+IMG_VOID List_##TYPE##_Remove(TYPE *psNode)
+
+#define IMPLEMENT_LIST_REMOVE(TYPE) \
+IMG_VOID List_##TYPE##_Remove(TYPE *psNode)\
+{\
+        (*psNode->ppsThis)=psNode->psNext;\
+        if(psNode->psNext)\
+        {\
+                psNode->psNext->ppsThis = psNode->ppsThis;\
+        }\
+}
+
+#define DECLARE_LIST_INSERT(TYPE) \
+IMG_VOID List_##TYPE##_Insert(TYPE **ppsHead, TYPE *psNewNode)
+
+#define IMPLEMENT_LIST_INSERT(TYPE) \
+IMG_VOID List_##TYPE##_Insert(TYPE **ppsHead, TYPE *psNewNode)\
+{\
+        psNewNode->ppsThis = ppsHead;\
+        psNewNode->psNext = *ppsHead;\
+        *ppsHead = psNewNode;\
+        if(psNewNode->psNext)\
+        {\
+                psNewNode->psNext->ppsThis = &(psNewNode->psNext);\
+        }\
+}
+
+#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
+
diff --git a/drivers/gpu/pvr/lock.h b/drivers/gpu/pvr/lock.h
new file mode 100644
index 00000000000..e0bf5ee67d4
--- /dev/null
+++ b/drivers/gpu/pvr/lock.h
@@ -0,0 +1,32 @@
+/**********************************************************************
+ *
+ * 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 __LOCK_H__
+#define __LOCK_H__
+
+extern PVRSRV_LINUX_MUTEX gPVRSRVLock;
+
+#endif 
diff --git a/drivers/gpu/pvr/mem.c b/drivers/gpu/pvr/mem.c
new file mode 100644
index 00000000000..a2673d53c23
--- /dev/null
+++ b/drivers/gpu/pvr/mem.c
@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * 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 "pvr_bridge_km.h"
+
+
+static PVRSRV_ERROR
+FreeSharedSysMemCallBack(IMG_PVOID      pvParam,
+                                                 IMG_UINT32     ui32Param)
+{
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        OSFreePages(psKernelMemInfo->ui32Flags,
+                                psKernelMemInfo->ui32AllocSize,
+                                psKernelMemInfo->pvLinAddrKM,
+                                psKernelMemInfo->sMemBlk.hOSMemHandle);
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          sizeof(PVRSRV_KERNEL_MEM_INFO),
+                          psKernelMemInfo,
+                          IMG_NULL);
+        
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT PVRSRV_ERROR
+PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA    *psPerProc,
+                                                         IMG_UINT32                                     ui32Flags,
+                                                         IMG_SIZE_T                             ui32Size,
+                                                         PVRSRV_KERNEL_MEM_INFO         **ppsKernelMemInfo)
+{
+        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                  (IMG_VOID **)&psKernelMemInfo, IMG_NULL,
+                                  "Kernel Memory Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for meminfo"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        OSMemSet(psKernelMemInfo, 0, sizeof(*psKernelMemInfo));
+
+        ui32Flags &= ~PVRSRV_HAP_MAPTYPE_MASK;
+        ui32Flags |= PVRSRV_HAP_MULTI_PROCESS;
+        psKernelMemInfo->ui32Flags = ui32Flags;
+        psKernelMemInfo->ui32AllocSize = ui32Size;
+
+        if(OSAllocPages(psKernelMemInfo->ui32Flags,
+                                        psKernelMemInfo->ui32AllocSize,
+                                        HOST_PAGESIZE(),
+                                        &psKernelMemInfo->pvLinAddrKM,
+                                        &psKernelMemInfo->sMemBlk.hOSMemHandle)
+                != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for block"));
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_KERNEL_MEM_INFO),
+                                  psKernelMemInfo,
+                                  0);
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        
+        psKernelMemInfo->sMemBlk.hResItem =
+                                ResManRegisterRes(psPerProc->hResManContext,
+                                                                  RESMAN_TYPE_SHARED_MEM_INFO,
+                                                                  psKernelMemInfo,
+                                                                  0,
+                                                                  &FreeSharedSysMemCallBack);
+
+        *ppsKernelMemInfo = psKernelMemInfo;
+
+        return PVRSRV_OK; 
+}
+
+
+IMG_EXPORT PVRSRV_ERROR
+PVRSRVFreeSharedSysMemoryKM(PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo)
+{
+        PVRSRV_ERROR eError;
+
+        if(psKernelMemInfo->sMemBlk.hResItem)
+        {
+                eError = ResManFreeResByPtr(psKernelMemInfo->sMemBlk.hResItem);
+        }
+        else
+        {
+                eError = FreeSharedSysMemCallBack(psKernelMemInfo, 0);
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT PVRSRV_ERROR
+PVRSRVDissociateMemFromResmanKM(PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo)
+{
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        if(!psKernelMemInfo)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if(psKernelMemInfo->sMemBlk.hResItem)
+        {
+                eError = ResManDissociateRes(psKernelMemInfo->sMemBlk.hResItem, IMG_NULL);
+
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVDissociateMemFromResmanKM: ResManDissociateRes failed"));
+                        PVR_DBG_BREAK;
+                        return eError;
+                }
+
+                psKernelMemInfo->sMemBlk.hResItem = IMG_NULL;
+        }
+
+        return eError;
+}
+
diff --git a/drivers/gpu/pvr/mem_debug.c b/drivers/gpu/pvr/mem_debug.c
new file mode 100644
index 00000000000..cbe99120e21
--- /dev/null
+++ b/drivers/gpu/pvr/mem_debug.c
@@ -0,0 +1,250 @@
+/**********************************************************************
+ *
+ * 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 MEM_DEBUG_C
+#define MEM_DEBUG_C
+
+#if defined(PVRSRV_DEBUG_OS_MEMORY)
+
+#include "img_types.h"
+#include "services_headers.h"
+
+#if defined (__cplusplus)
+extern "C"
+{
+#endif
+
+#define STOP_ON_ERROR 0
+
+        
+
+        
+
+
+
+
+
+        IMG_BOOL MemCheck(const IMG_PVOID pvAddr, const IMG_UINT8 ui8Pattern, IMG_SIZE_T uSize)
+        {
+                IMG_UINT8 *pui8Addr;
+                for (pui8Addr = (IMG_UINT8*)pvAddr; uSize > 0; uSize--, pui8Addr++)
+                {
+                        if (*pui8Addr != ui8Pattern)
+                        {
+                                return IMG_FALSE;
+                        }
+                }
+                return IMG_TRUE;
+        }
+
+        
+
+        IMG_VOID OSCheckMemDebug(IMG_PVOID pvCpuVAddr, IMG_SIZE_T uSize, const IMG_CHAR *pszFileName, const IMG_UINT32 uLine)
+        {
+                OSMEM_DEBUG_INFO const *psInfo = (OSMEM_DEBUG_INFO *)((IMG_UINT32)pvCpuVAddr - TEST_BUFFER_PADDING_STATUS);
+
+                
+                if (pvCpuVAddr == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : null pointer"
+                                         " - referenced %s:%d - allocated %s:%d",
+                                         pvCpuVAddr,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+
+                
+                if (((IMG_UINT32)pvCpuVAddr&3) != 0)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : invalid alignment"
+                                         " - referenced %s:%d - allocated %s:%d",
+                                         pvCpuVAddr,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+
+                
+                if (!MemCheck((IMG_PVOID)psInfo->sGuardRegionBefore, 0xB1, sizeof(psInfo->sGuardRegionBefore)))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : guard region before overwritten"
+                                         " - referenced %s:%d - allocated %s:%d",
+                                         pvCpuVAddr,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+
+                
+                if (uSize != psInfo->uSize)
+                {
+                        PVR_DPF((PVR_DBG_WARNING, "Pointer 0x%X : supplied size was different to stored size (0x%X != 0x%X)"
+                                         " - referenced %s:%d - allocated %s:%d",
+                                         pvCpuVAddr, uSize, psInfo->uSize,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+
+                
+                if ((0x01234567 ^ psInfo->uSizeParityCheck) != psInfo->uSize)
+                {
+                        PVR_DPF((PVR_DBG_WARNING, "Pointer 0x%X : stored size parity error (0x%X != 0x%X)"
+                                         " - referenced %s:%d - allocated %s:%d",
+                                         pvCpuVAddr, psInfo->uSize, 0x01234567 ^ psInfo->uSizeParityCheck,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+                else
+                {
+                        
+                        uSize = psInfo->uSize;
+                }
+
+                
+                if (uSize)
+                {
+                        if (!MemCheck((IMG_VOID*)((IMG_UINT32)pvCpuVAddr + uSize), 0xB2, TEST_BUFFER_PADDING_AFTER))
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : guard region after overwritten"
+                                                 " - referenced from %s:%d - allocated from %s:%d",
+                                                 pvCpuVAddr,
+                                                 pszFileName, uLine,
+                                                 psInfo->sFileName, psInfo->uLineNo));
+                        }
+                }
+
+                
+                if (psInfo->eValid != isAllocated)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "Pointer 0x%X : not allocated (freed? %d)"
+                                         " - referenced %s:%d - freed %s:%d",
+                                         pvCpuVAddr, psInfo->eValid == isFree,
+                                         pszFileName, uLine,
+                                         psInfo->sFileName, psInfo->uLineNo));
+                        while (STOP_ON_ERROR);
+                }
+        }
+
+        IMG_VOID debug_strcpy(IMG_CHAR *pDest, const IMG_CHAR *pSrc)
+        {
+                IMG_SIZE_T i = 0;
+
+                for (; i < 128; i++) 
+                {
+                        *pDest = *pSrc;
+                        if (*pSrc == '\0') break;
+                        pDest++;
+                        pSrc++;
+                }
+        }
+
+        PVRSRV_ERROR OSAllocMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+                                                                                  IMG_UINT32 ui32Size,
+                                                                                  IMG_PVOID *ppvCpuVAddr,
+                                                                                  IMG_HANDLE *phBlockAlloc,
+                                                                                  IMG_CHAR *pszFilename,
+                                                                                  IMG_UINT32 ui32Line)
+        {
+                OSMEM_DEBUG_INFO *psInfo;
+
+                PVRSRV_ERROR eError;
+
+                eError = OSAllocMem_Debug_Linux_Memory_Allocations(ui32Flags,
+                                 ui32Size + TEST_BUFFER_PADDING,
+                                 ppvCpuVAddr,
+                                 phBlockAlloc,
+                                 pszFilename,
+                                 ui32Line);
+
+                if (eError != PVRSRV_OK)
+                {
+                        return eError;
+                }
+
+                
+                OSMemSet((IMG_CHAR *)(*ppvCpuVAddr) + TEST_BUFFER_PADDING_STATUS, 0xBB, ui32Size);
+                OSMemSet((IMG_CHAR *)(*ppvCpuVAddr) + ui32Size + TEST_BUFFER_PADDING_STATUS, 0xB2, TEST_BUFFER_PADDING_AFTER);
+
+                
+                psInfo = (OSMEM_DEBUG_INFO *)(*ppvCpuVAddr);
+
+                OSMemSet(psInfo->sGuardRegionBefore, 0xB1, sizeof(psInfo->sGuardRegionBefore));
+                debug_strcpy(psInfo->sFileName, pszFilename);
+                psInfo->uLineNo = ui32Line;
+                psInfo->eValid = isAllocated;
+                psInfo->uSize = ui32Size;
+                psInfo->uSizeParityCheck = 0x01234567 ^ ui32Size;
+
+                
+                *ppvCpuVAddr = (IMG_PVOID) ((IMG_UINT32)*ppvCpuVAddr)+TEST_BUFFER_PADDING_STATUS;
+
+#ifdef PVRSRV_LOG_MEMORY_ALLOCS
+                
+                PVR_TRACE(("Allocated pointer (after debug info): 0x%X from %s:%d", *ppvCpuVAddr, pszFilename, ui32Line));
+#endif
+
+                return PVRSRV_OK;
+        }
+
+        PVRSRV_ERROR OSFreeMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+                                                                                 IMG_UINT32 ui32Size,
+                                                                                 IMG_PVOID pvCpuVAddr,
+                                                                                 IMG_HANDLE hBlockAlloc,
+                                                                                 IMG_CHAR *pszFilename,
+                                                                                 IMG_UINT32 ui32Line)
+        {
+                OSMEM_DEBUG_INFO *psInfo;
+
+                
+                OSCheckMemDebug(pvCpuVAddr, ui32Size, pszFilename, ui32Line);
+
+                
+                OSMemSet(pvCpuVAddr, 0xBF, ui32Size + TEST_BUFFER_PADDING_AFTER);  
+
+                
+                psInfo = (OSMEM_DEBUG_INFO *)((IMG_UINT32) pvCpuVAddr - TEST_BUFFER_PADDING_STATUS);
+
+                
+                psInfo->uSize = 0;
+                psInfo->uSizeParityCheck = 0;
+                psInfo->eValid = isFree;
+                psInfo->uLineNo = ui32Line;
+                debug_strcpy(psInfo->sFileName, pszFilename);
+
+                return OSFreeMem_Debug_Linux_Memory_Allocations(ui32Flags, ui32Size + TEST_BUFFER_PADDING, psInfo, hBlockAlloc, pszFilename, ui32Line);
+        }
+
+#if defined (__cplusplus)
+
+}
+#endif
+
+#endif 
+
+#endif        
diff --git a/drivers/gpu/pvr/metrics.c b/drivers/gpu/pvr/metrics.c
new file mode 100644
index 00000000000..ee5cabd4998
--- /dev/null
+++ b/drivers/gpu/pvr/metrics.c
@@ -0,0 +1,160 @@
+/**********************************************************************
+ *
+ * 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 "metrics.h"
+
+#if defined(SUPPORT_VGX)
+#include "vgxapi_km.h"
+#endif
+
+#if defined(SUPPORT_SGX)
+#include "sgxapi_km.h"
+#endif
+
+#if defined(DEBUG) || defined(TIMING)
+
+static volatile IMG_UINT32 *pui32TimerRegister = 0;
+
+#define PVRSRV_TIMER_TOTAL_IN_TICKS(X)  asTimers[X].ui32Total
+#define PVRSRV_TIMER_TOTAL_IN_MS(X)             ((1000*asTimers[X].ui32Total)/ui32TicksPerMS)
+#define PVRSRV_TIMER_COUNT(X)                   asTimers[X].ui32Count
+
+
+Temporal_Data asTimers[PVRSRV_NUM_TIMERS]; 
+
+
+IMG_UINT32 PVRSRVTimeNow(IMG_VOID)
+{
+        if (!pui32TimerRegister)
+        {
+                static IMG_BOOL bFirstTime = IMG_TRUE;
+
+                if (bFirstTime)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVTimeNow: No timer register set up"));
+
+                        bFirstTime = IMG_FALSE;
+                }
+
+                return 0;
+        }
+
+#if defined(__sh__)
+
+        return (0xffffffff-*pui32TimerRegister);
+
+#else 
+
+        return 0;
+
+#endif 
+}
+
+
+static IMG_UINT32 PVRSRVGetCPUFreq(IMG_VOID)
+{
+        IMG_UINT32 ui32Time1, ui32Time2;
+
+        ui32Time1 = PVRSRVTimeNow();
+
+        OSWaitus(1000000);
+
+        ui32Time2 = PVRSRVTimeNow();
+
+        PVR_DPF((PVR_DBG_WARNING, "PVRSRVGetCPUFreq: timer frequency = %d Hz", ui32Time2 - ui32Time1));
+
+        return (ui32Time2 - ui32Time1);
+}
+
+
+IMG_VOID PVRSRVSetupMetricTimers(IMG_VOID *pvDevInfo)
+{
+        IMG_UINT32 ui32Loop;
+
+        PVR_UNREFERENCED_PARAMETER(pvDevInfo);
+
+        for(ui32Loop=0; ui32Loop < (PVRSRV_NUM_TIMERS); ui32Loop++)
+        {
+                asTimers[ui32Loop].ui32Total = 0;
+                asTimers[ui32Loop].ui32Count = 0;
+        }
+
+
+        #if defined(__sh__)
+
+                
+                
+                
+                
+                *TCR_2 = TIMER_DIVISOR;
+
+                
+                *TCOR_2 = *TCNT_2 = (IMG_UINT)0xffffffff;
+
+                
+                *TST_REG |= (IMG_UINT8)0x04;
+
+                pui32TimerRegister = (IMG_UINT32 *)TCNT_2;
+
+        #else 
+
+                pui32TimerRegister = 0;
+
+        #endif 
+
+}
+
+
+IMG_VOID PVRSRVOutputMetricTotals(IMG_VOID)
+{
+        IMG_UINT32 ui32TicksPerMS, ui32Loop;
+
+        ui32TicksPerMS = PVRSRVGetCPUFreq();
+
+        if (!ui32TicksPerMS)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVOutputMetricTotals: Failed to get CPU Freq"));
+                return;
+        }
+
+        for(ui32Loop=0; ui32Loop < (PVRSRV_NUM_TIMERS); ui32Loop++)
+        {
+                if (asTimers[ui32Loop].ui32Count & 0x80000000L)
+                {
+                        PVR_DPF((PVR_DBG_WARNING,"PVRSRVOutputMetricTotals: Timer %u is still ON", ui32Loop));
+                }
+        }
+#if 0
+        
+        PVR_DPF((PVR_DBG_ERROR," Timer(%u): Total = %u",PVRSRV_TIMER_EXAMPLE_1, PVRSRV_TIMER_TOTAL_IN_TICKS(PVRSRV_TIMER_EXAMPLE_1)));
+        PVR_DPF((PVR_DBG_ERROR," Timer(%u): Time = %ums",PVRSRV_TIMER_EXAMPLE_1, PVRSRV_TIMER_TOTAL_IN_MS(PVRSRV_TIMER_EXAMPLE_1)));
+        PVR_DPF((PVR_DBG_ERROR," Timer(%u): Count = %u",PVRSRV_TIMER_EXAMPLE_1, PVRSRV_TIMER_COUNT(PVRSRV_TIMER_EXAMPLE_1)));
+#endif
+}
+
+#endif 
+
diff --git a/drivers/gpu/pvr/metrics.h b/drivers/gpu/pvr/metrics.h
new file mode 100644
index 00000000000..2632f8dbe02
--- /dev/null
+++ b/drivers/gpu/pvr/metrics.h
@@ -0,0 +1,130 @@
+/**********************************************************************
+ *
+ * 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 _METRICS_
+#define _METRICS_
+
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+#if defined(DEBUG) || defined(TIMING)
+
+
+typedef struct 
+{
+        IMG_UINT32 ui32Start;
+        IMG_UINT32 ui32Stop;
+        IMG_UINT32 ui32Total;
+        IMG_UINT32 ui32Count;
+} Temporal_Data;
+
+extern Temporal_Data asTimers[]; 
+
+extern IMG_UINT32 PVRSRVTimeNow(IMG_VOID);
+extern IMG_VOID   PVRSRVSetupMetricTimers(IMG_VOID *pvDevInfo);
+extern IMG_VOID   PVRSRVOutputMetricTotals(IMG_VOID);
+
+
+#define PVRSRV_TIMER_DUMMY                              0
+
+#define PVRSRV_TIMER_EXAMPLE_1                  1
+#define PVRSRV_TIMER_EXAMPLE_2                  2
+
+
+#define PVRSRV_NUM_TIMERS               (PVRSRV_TIMER_EXAMPLE_2 + 1)
+
+#define PVRSRV_TIME_START(X)    { \
+                                                                        asTimers[X].ui32Count += 1; \
+                                                                        asTimers[X].ui32Count |= 0x80000000L; \
+                                                                        asTimers[X].ui32Start = PVRSRVTimeNow(); \
+                                                                        asTimers[X].ui32Stop  = 0; \
+                                                                }
+
+#define PVRSRV_TIME_SUSPEND(X)  { \
+                                                                        asTimers[X].ui32Stop += PVRSRVTimeNow() - asTimers[X].ui32Start; \
+                                                                }
+
+#define PVRSRV_TIME_RESUME(X)   { \
+                                                                        asTimers[X].ui32Start = PVRSRVTimeNow(); \
+                                                                }
+
+#define PVRSRV_TIME_STOP(X)             { \
+                                                                        asTimers[X].ui32Stop  += PVRSRVTimeNow() - asTimers[X].ui32Start; \
+                                                                        asTimers[X].ui32Total += asTimers[X].ui32Stop; \
+                                                                        asTimers[X].ui32Count &= 0x7FFFFFFFL; \
+                                                                }
+
+#define PVRSRV_TIME_RESET(X)    { \
+                                                                        asTimers[X].ui32Start = 0; \
+                                                                        asTimers[X].ui32Stop  = 0; \
+                                                                        asTimers[X].ui32Total = 0; \
+                                                                        asTimers[X].ui32Count = 0; \
+                                                                }
+
+
+#if defined(__sh__)
+
+#define TST_REG   ((volatile IMG_UINT8 *) (psDevInfo->pvSOCRegsBaseKM))         
+
+#define TCOR_2    ((volatile IMG_UINT *)  (psDevInfo->pvSOCRegsBaseKM+28))      
+#define TCNT_2    ((volatile IMG_UINT *)  (psDevInfo->pvSOCRegsBaseKM+32))      
+#define TCR_2     ((volatile IMG_UINT16 *)(psDevInfo->pvSOCRegsBaseKM+36))      
+
+#define TIMER_DIVISOR  4
+
+#endif 
+
+
+
+
+
+#else 
+
+
+
+#define PVRSRV_TIME_START(X)
+#define PVRSRV_TIME_SUSPEND(X)
+#define PVRSRV_TIME_RESUME(X)
+#define PVRSRV_TIME_STOP(X)
+#define PVRSRV_TIME_RESET(X)
+
+#define PVRSRVSetupMetricTimers(X)
+#define PVRSRVOutputMetricTotals()
+
+
+
+#endif 
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif 
+
diff --git a/drivers/gpu/pvr/mm.c b/drivers/gpu/pvr/mm.c
new file mode 100644
index 00000000000..ecaba8e1015
--- /dev/null
+++ b/drivers/gpu/pvr/mm.c
@@ -0,0 +1,2012 @@
+/**********************************************************************
+ *
+ * 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/mm.h>
+#include <linux/vmalloc.h>
+#include <asm/io.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+#include <linux/wrapper.h>
+#endif
+#include <linux/slab.h>
+#include <linux/highmem.h>
+#include <linux/sched.h>
+
+#include "img_defs.h"
+#include "services.h"
+#include "servicesint.h"
+#include "syscommon.h"
+#include "mutils.h"
+#include "mm.h"
+#include "pvrmmap.h"
+#include "mmap.h"
+#include "osfunc.h"
+#include "pvr_debug.h"
+#include "proc.h"
+#include "mutex.h"
+#include "lock.h"
+
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+        #include "lists.h"
+#endif
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+typedef enum {
+    DEBUG_MEM_ALLOC_TYPE_KMALLOC,
+    DEBUG_MEM_ALLOC_TYPE_VMALLOC,
+    DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES,
+    DEBUG_MEM_ALLOC_TYPE_IOREMAP,
+    DEBUG_MEM_ALLOC_TYPE_IO,
+    DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE,
+    DEBUG_MEM_ALLOC_TYPE_COUNT
+}DEBUG_MEM_ALLOC_TYPE;
+
+typedef struct _DEBUG_MEM_ALLOC_REC
+{
+    DEBUG_MEM_ALLOC_TYPE    eAllocType;
+        IMG_VOID                                *pvKey; 
+    IMG_VOID                *pvCpuVAddr;
+    IMG_UINT32              ulCpuPAddr;
+    IMG_VOID                *pvPrivateData;
+        IMG_UINT32                              ui32Bytes;
+        pid_t                                   pid;
+    IMG_CHAR                *pszFileName;
+    IMG_UINT32              ui32Line;
+    
+    struct _DEBUG_MEM_ALLOC_REC   *psNext;
+        struct _DEBUG_MEM_ALLOC_REC   **ppsThis;
+}DEBUG_MEM_ALLOC_REC;
+
+static IMPLEMENT_LIST_ANY_VA_2(DEBUG_MEM_ALLOC_REC, IMG_BOOL, IMG_FALSE)
+static IMPLEMENT_LIST_ANY_VA(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_FOR_EACH(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_INSERT(DEBUG_MEM_ALLOC_REC)
+static IMPLEMENT_LIST_REMOVE(DEBUG_MEM_ALLOC_REC)
+
+
+static DEBUG_MEM_ALLOC_REC *g_MemoryRecords;
+
+static IMG_UINT32 g_WaterMarkData[DEBUG_MEM_ALLOC_TYPE_COUNT];
+static IMG_UINT32 g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_COUNT];
+
+static IMG_UINT32 g_SysRAMWaterMark;
+static IMG_UINT32 g_SysRAMHighWaterMark;
+
+static IMG_UINT32 g_IOMemWaterMark;
+static IMG_UINT32 g_IOMemHighWaterMark;
+
+static IMG_VOID DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE eAllocType,
+                                       IMG_VOID *pvKey,
+                                       IMG_VOID *pvCpuVAddr,
+                                       IMG_UINT32 ulCpuPAddr,
+                                       IMG_VOID *pvPrivateData,
+                                       IMG_UINT32 ui32Bytes,
+                                       IMG_CHAR *pszFileName,
+                                       IMG_UINT32 ui32Line);
+
+static IMG_VOID DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE eAllocType, IMG_VOID *pvKey, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+static IMG_CHAR *DebugMemAllocRecordTypeToString(DEBUG_MEM_ALLOC_TYPE eAllocType);
+
+
+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);
+
+#endif
+
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+typedef struct _DEBUG_LINUX_MEM_AREA_REC
+{
+        LinuxMemArea                *psLinuxMemArea;
+    IMG_UINT32                  ui32Flags;
+        pid_t                                       pid;
+
+        struct _DEBUG_LINUX_MEM_AREA_REC  *psNext;
+        struct _DEBUG_LINUX_MEM_AREA_REC  **ppsThis;
+}DEBUG_LINUX_MEM_AREA_REC;
+
+
+static IMPLEMENT_LIST_ANY_VA(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_FOR_EACH(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_INSERT(DEBUG_LINUX_MEM_AREA_REC)
+static IMPLEMENT_LIST_REMOVE(DEBUG_LINUX_MEM_AREA_REC)
+
+
+
+
+static DEBUG_LINUX_MEM_AREA_REC *g_LinuxMemAreaRecords;
+static IMG_UINT32 g_LinuxMemAreaCount;
+static IMG_UINT32 g_LinuxMemAreaWaterMark;
+static IMG_UINT32 g_LinuxMemAreaHighWaterMark;
+
+
+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);
+
+#endif
+
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+static PVRSRV_LINUX_MUTEX g_sDebugMutex;
+#endif
+
+#if (defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS))
+static void ProcSeqStartstopDebugMutex(struct seq_file *sfile,IMG_BOOL start);
+#endif
+
+static LinuxKMemCache *psLinuxMemAreaCache;
+
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
+static IMG_VOID ReservePages(IMG_VOID *pvAddress, IMG_UINT32 ui32Length);
+static IMG_VOID UnreservePages(IMG_VOID *pvAddress, IMG_UINT32 ui32Length);
+#endif
+
+static LinuxMemArea *LinuxMemAreaStructAlloc(IMG_VOID);
+static IMG_VOID LinuxMemAreaStructFree(LinuxMemArea *psLinuxMemArea);
+#if defined(DEBUG_LINUX_MEM_AREAS)
+static IMG_VOID DebugLinuxMemAreaRecordAdd(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Flags);
+static DEBUG_LINUX_MEM_AREA_REC *DebugLinuxMemAreaRecordFind(LinuxMemArea *psLinuxMemArea);
+static IMG_VOID DebugLinuxMemAreaRecordRemove(LinuxMemArea *psLinuxMemArea);
+#endif
+
+PVRSRV_ERROR
+LinuxMMInit(IMG_VOID)
+{
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+        LinuxInitMutex(&g_sDebugMutex);
+#endif
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    {
+                g_SeqFileMemArea = CreateProcReadEntrySeq(
+                                                                        "mem_areas", 
+                                                                        NULL, 
+                                                                        ProcSeqNextMemArea,
+                                                                        ProcSeqShowMemArea,
+                                                                        ProcSeqOff2ElementMemArea,
+                                                                        ProcSeqStartstopDebugMutex
+                                                                   );
+                if(!g_SeqFileMemArea)
+        {
+            return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+    }
+#endif
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    {
+                g_SeqFileMemoryRecords =CreateProcReadEntrySeq(
+                                                                        "meminfo", 
+                                                                        NULL, 
+                                                                        ProcSeqNextMemoryRecords,
+                                                                        ProcSeqShowMemoryRecords, 
+                                                                        ProcSeqOff2ElementMemoryRecords,
+                                                                        ProcSeqStartstopDebugMutex
+                                                                   );
+        if(!g_SeqFileMemoryRecords)
+        {
+            return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+    }
+#endif
+
+    psLinuxMemAreaCache = KMemCacheCreateWrapper("img-mm", sizeof(LinuxMemArea), 0, 0);
+    if(!psLinuxMemAreaCache)
+    {
+        PVR_DPF((PVR_DBG_ERROR,"%s: failed to allocate kmem_cache", __FUNCTION__));
+        return PVRSRV_ERROR_OUT_OF_MEMORY;
+    }
+
+    return PVRSRV_OK;
+}
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+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=%d bytes",
+                                __FUNCTION__,
+                                psCurrentRecord->psLinuxMemArea,
+                                LinuxMemAreaTypeToString(psCurrentRecord->psLinuxMemArea->eAreaType),
+                                psCurrentRecord->psLinuxMemArea->ui32ByteSize));
+        
+        LinuxMemAreaDeepFree(psLinuxMemArea);
+}
+#endif
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+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%08x, "
+                                                        "allocated @ file=%s,line=%d",
+                        __FUNCTION__,
+                        DebugMemAllocRecordTypeToString(psCurrentRecord->eAllocType),
+                        psCurrentRecord->pvCpuVAddr,
+                        psCurrentRecord->ulCpuPAddr,
+                        psCurrentRecord->pszFileName,
+                        psCurrentRecord->ui32Line));
+        switch(psCurrentRecord->eAllocType)
+        {
+                case DEBUG_MEM_ALLOC_TYPE_KMALLOC:
+                        KFreeWrapper(psCurrentRecord->pvCpuVAddr);
+                        break;
+                case DEBUG_MEM_ALLOC_TYPE_IOREMAP:
+                        IOUnmapWrapper(psCurrentRecord->pvCpuVAddr);
+                        break;
+                case DEBUG_MEM_ALLOC_TYPE_IO:
+                        
+                        DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IO, psCurrentRecord->pvKey, __FILE__, __LINE__);
+                        break;
+                case DEBUG_MEM_ALLOC_TYPE_VMALLOC:
+                        VFreeWrapper(psCurrentRecord->pvCpuVAddr);
+                        break;
+                case DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES:
+                        
+                        DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, psCurrentRecord->pvKey, __FILE__, __LINE__);
+                        break;
+                case DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE:
+                        KMemCacheFreeWrapper(psCurrentRecord->pvPrivateData, psCurrentRecord->pvCpuVAddr);
+                        break;
+                default:
+                        PVR_ASSERT(0);
+        }
+}
+#endif
+
+
+IMG_VOID
+LinuxMMCleanup(IMG_VOID)
+{
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    {
+        if(g_LinuxMemAreaCount)
+        {
+            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);
+
+                RemoveProcEntrySeq( g_SeqFileMemArea );
+    }
+#endif
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    {
+        
+        
+                List_DEBUG_MEM_ALLOC_REC_ForEach(g_MemoryRecords,
+                                                                                LinuxMMCleanup_MemRecords_ForEachVa);
+
+                RemoveProcEntrySeq( g_SeqFileMemoryRecords );
+    }
+#endif
+
+    if(psLinuxMemAreaCache)
+    {
+        KMemCacheDestroyWrapper(psLinuxMemAreaCache); 
+        psLinuxMemAreaCache=NULL;
+    }
+}
+
+
+IMG_VOID *
+_KMallocWrapper(IMG_UINT32 ui32ByteSize, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+    IMG_VOID *pvRet;
+    pvRet = kmalloc(ui32ByteSize, GFP_KERNEL);
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    if(pvRet)
+    {
+        DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_KMALLOC,
+                               pvRet,
+                               pvRet,
+                               0,
+                               NULL,
+                               ui32ByteSize,
+                               pszFileName,
+                               ui32Line
+                               );
+    }
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+    return pvRet;
+}
+
+
+IMG_VOID
+_KFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_KMALLOC, pvCpuVAddr, pszFileName,  ui32Line);
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+    kfree(pvCpuVAddr);
+}
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+static IMG_VOID
+DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE eAllocType,
+                       IMG_VOID *pvKey,
+                       IMG_VOID *pvCpuVAddr,
+                       IMG_UINT32 ulCpuPAddr,
+                       IMG_VOID *pvPrivateData,
+                       IMG_UINT32 ui32Bytes,
+                       IMG_CHAR *pszFileName,
+                       IMG_UINT32 ui32Line)
+{
+    DEBUG_MEM_ALLOC_REC *psRecord;
+
+    LinuxLockMutex(&g_sDebugMutex);
+
+    psRecord = kmalloc(sizeof(DEBUG_MEM_ALLOC_REC), GFP_KERNEL);
+
+    psRecord->eAllocType = eAllocType;
+    psRecord->pvKey = pvKey;
+    psRecord->pvCpuVAddr = pvCpuVAddr;
+    psRecord->ulCpuPAddr = ulCpuPAddr;
+    psRecord->pvPrivateData = pvPrivateData;
+    psRecord->pid = current->pid;
+    psRecord->ui32Bytes = ui32Bytes;
+    psRecord->pszFileName = pszFileName;
+    psRecord->ui32Line = ui32Line;
+    
+        List_DEBUG_MEM_ALLOC_REC_Insert(&g_MemoryRecords, psRecord);
+    
+    g_WaterMarkData[eAllocType] += ui32Bytes;
+    if(g_WaterMarkData[eAllocType] > g_HighWaterMarkData[eAllocType])
+    {
+        g_HighWaterMarkData[eAllocType] = g_WaterMarkData[eAllocType];
+    }
+
+    if(eAllocType == DEBUG_MEM_ALLOC_TYPE_KMALLOC
+       || eAllocType == DEBUG_MEM_ALLOC_TYPE_VMALLOC
+       || eAllocType == DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES
+       || eAllocType == DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
+    {
+        g_SysRAMWaterMark += ui32Bytes;
+        if(g_SysRAMWaterMark > g_SysRAMHighWaterMark)
+        {
+            g_SysRAMHighWaterMark = g_SysRAMWaterMark;
+        }
+    }
+    else if(eAllocType == DEBUG_MEM_ALLOC_TYPE_IOREMAP
+            || eAllocType == DEBUG_MEM_ALLOC_TYPE_IO)
+    {
+        g_IOMemWaterMark += ui32Bytes;
+        if(g_IOMemWaterMark > g_IOMemHighWaterMark)
+        {
+            g_IOMemHighWaterMark = g_IOMemWaterMark;
+        }
+    }
+
+    LinuxUnLockMutex(&g_sDebugMutex);
+}
+
+
+static IMG_BOOL DebugMemAllocRecordRemove_AnyVaCb(DEBUG_MEM_ALLOC_REC *psCurrentRecord, va_list va)
+{
+        DEBUG_MEM_ALLOC_TYPE eAllocType;
+        IMG_VOID *pvKey;
+        
+        eAllocType = va_arg(va, DEBUG_MEM_ALLOC_TYPE);
+        pvKey = va_arg(va, IMG_VOID*);
+
+        if(psCurrentRecord->eAllocType == eAllocType
+                && psCurrentRecord->pvKey == pvKey)
+        {
+                eAllocType = psCurrentRecord->eAllocType;
+                g_WaterMarkData[eAllocType] -= psCurrentRecord->ui32Bytes;
+                
+                if(eAllocType == DEBUG_MEM_ALLOC_TYPE_KMALLOC
+                   || eAllocType == DEBUG_MEM_ALLOC_TYPE_VMALLOC
+                   || eAllocType == DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES
+                   || eAllocType == DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
+                {
+                        g_SysRAMWaterMark -= psCurrentRecord->ui32Bytes;
+                }
+                else if(eAllocType == DEBUG_MEM_ALLOC_TYPE_IOREMAP
+                                || eAllocType == DEBUG_MEM_ALLOC_TYPE_IO)
+                {
+                        g_IOMemWaterMark -= psCurrentRecord->ui32Bytes;
+                }
+                
+                List_DEBUG_MEM_ALLOC_REC_Remove(psCurrentRecord);
+                kfree(psCurrentRecord);
+
+                return IMG_TRUE;
+        }
+        else
+        {
+                return IMG_FALSE;
+        }
+}
+
+
+static IMG_VOID
+DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE eAllocType, IMG_VOID *pvKey, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+    LinuxLockMutex(&g_sDebugMutex);
+
+    
+        if(!List_DEBUG_MEM_ALLOC_REC_IMG_BOOL_Any_va(g_MemoryRecords,
+                                                                                                DebugMemAllocRecordRemove_AnyVaCb,
+                                                                                                eAllocType,
+                                                                                                pvKey))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for type=%s with pvKey=%p (called from %s, line %d\n",
+                __FUNCTION__, DebugMemAllocRecordTypeToString(eAllocType), pvKey,
+                pszFileName, ui32Line));
+        }
+
+    LinuxUnLockMutex(&g_sDebugMutex);
+}
+
+
+static IMG_CHAR *
+DebugMemAllocRecordTypeToString(DEBUG_MEM_ALLOC_TYPE eAllocType)
+{
+    IMG_CHAR *apszDebugMemoryRecordTypes[] = {
+        "KMALLOC",
+        "VMALLOC",
+        "ALLOC_PAGES",
+        "IOREMAP",
+        "IO",
+        "KMEM_CACHE_ALLOC"
+    };
+    return apszDebugMemoryRecordTypes[eAllocType];
+}
+#endif
+
+
+
+IMG_VOID *
+_VMallocWrapper(IMG_UINT32 ui32Bytes,
+                IMG_UINT32 ui32AllocFlags,
+                IMG_CHAR *pszFileName,
+                IMG_UINT32 ui32Line)
+{
+    pgprot_t PGProtFlags;
+    IMG_VOID *pvRet;
+    
+    switch(ui32AllocFlags & PVRSRV_HAP_CACHETYPE_MASK)
+    {
+        case PVRSRV_HAP_CACHED:
+            PGProtFlags = PAGE_KERNEL;
+            break;
+        case PVRSRV_HAP_WRITECOMBINE:
+            PGProtFlags = PGPROT_WC(PAGE_KERNEL);
+            break;
+        case PVRSRV_HAP_UNCACHED:
+            PGProtFlags = PGPROT_UC(PAGE_KERNEL);
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR,
+                     "VMAllocWrapper: unknown mapping flags=0x%08x",
+                     ui32AllocFlags));
+            dump_stack();
+            return NULL;
+    }
+
+        
+    pvRet = __vmalloc(ui32Bytes, GFP_KERNEL | __GFP_HIGHMEM, PGProtFlags);
+    
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    if(pvRet)
+    {
+        DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_VMALLOC,
+                               pvRet,
+                               pvRet,
+                               0,
+                               NULL,
+                               PAGE_ALIGN(ui32Bytes),
+                               pszFileName,
+                               ui32Line
+                               );
+    }
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+
+    return pvRet;
+}
+
+
+IMG_VOID
+_VFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_VMALLOC, pvCpuVAddr, pszFileName, ui32Line);
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+    vfree(pvCpuVAddr);
+}
+
+
+LinuxMemArea *
+NewVMallocLinuxMemArea(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags)
+{
+    LinuxMemArea *psLinuxMemArea;
+    IMG_VOID *pvCpuVAddr;
+
+    psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        goto failed;
+    }
+
+    pvCpuVAddr = VMallocWrapper(ui32Bytes, ui32AreaFlags);
+    if(!pvCpuVAddr)
+    {
+        goto failed;
+    }
+    
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
+    
+    ReservePages(pvCpuVAddr, ui32Bytes);
+#endif
+
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_VMALLOC;
+    psLinuxMemArea->uData.sVmalloc.pvVmallocAddress = pvCpuVAddr;
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
+    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:
+    PVR_DPF((PVR_DBG_ERROR, "%s: failed!", __FUNCTION__));
+    if(psLinuxMemArea)
+        LinuxMemAreaStructFree(psLinuxMemArea);
+    return NULL;
+}
+
+
+IMG_VOID
+FreeVMallocLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVR_ASSERT(psLinuxMemArea);
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_VMALLOC);
+    PVR_ASSERT(psLinuxMemArea->uData.sVmalloc.pvVmallocAddress);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
+        UnreservePages(psLinuxMemArea->uData.sVmalloc.pvVmallocAddress,
+                    psLinuxMemArea->ui32ByteSize);
+#endif
+
+    PVR_DPF((PVR_DBG_MESSAGE,"%s: pvCpuVAddr: %p",
+             __FUNCTION__, psLinuxMemArea->uData.sVmalloc.pvVmallocAddress));
+    VFreeWrapper(psLinuxMemArea->uData.sVmalloc.pvVmallocAddress);
+
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
+static IMG_VOID
+ReservePages(IMG_VOID *pvAddress, IMG_UINT32 ui32Length)
+{
+        IMG_VOID *pvPage;
+        IMG_VOID *pvEnd = pvAddress + ui32Length;
+
+        for(pvPage = pvAddress; pvPage < pvEnd;  pvPage += PAGE_SIZE)
+        {
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
+                SetPageReserved(vmalloc_to_page(pvPage));
+#else
+                mem_map_reserve(vmalloc_to_page(pvPage));
+#endif
+        }
+}
+
+
+static IMG_VOID
+UnreservePages(IMG_VOID *pvAddress, IMG_UINT32 ui32Length)
+{
+        IMG_VOID *pvPage;
+        IMG_VOID *pvEnd = pvAddress + ui32Length;
+
+        for(pvPage = pvAddress; pvPage < pvEnd;  pvPage += PAGE_SIZE)
+        {
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
+                ClearPageReserved(vmalloc_to_page(pvPage));
+#else
+                mem_map_unreserve(vmalloc_to_page(pvPage));
+#endif
+        }
+}
+#endif 
+
+
+IMG_VOID *
+_IORemapWrapper(IMG_CPU_PHYADDR BasePAddr,
+               IMG_UINT32 ui32Bytes,
+               IMG_UINT32 ui32MappingFlags,
+               IMG_CHAR *pszFileName,
+               IMG_UINT32 ui32Line)
+{
+    IMG_VOID *pvIORemapCookie;
+    
+    switch(ui32MappingFlags & PVRSRV_HAP_CACHETYPE_MASK)
+    {
+        case PVRSRV_HAP_CACHED:
+            pvIORemapCookie = (IMG_VOID *)IOREMAP(BasePAddr.uiAddr, ui32Bytes);
+            break;
+        case PVRSRV_HAP_WRITECOMBINE:
+            pvIORemapCookie = (IMG_VOID *)IOREMAP_WC(BasePAddr.uiAddr, ui32Bytes);
+            break;
+        case PVRSRV_HAP_UNCACHED:
+            pvIORemapCookie = (IMG_VOID *)IOREMAP_UC(BasePAddr.uiAddr, ui32Bytes);
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "IORemapWrapper: unknown mapping flags"));
+            return NULL;
+    }
+    
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    if(pvIORemapCookie)
+    {
+        DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_IOREMAP,
+                               pvIORemapCookie,
+                               pvIORemapCookie,
+                               BasePAddr.uiAddr,
+                               NULL,
+                               ui32Bytes,
+                               pszFileName,
+                               ui32Line
+                               );
+    }
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+
+    return pvIORemapCookie;
+}
+
+
+IMG_VOID
+_IOUnmapWrapper(IMG_VOID *pvIORemapCookie, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IOREMAP, pvIORemapCookie, pszFileName, ui32Line);
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+    iounmap(pvIORemapCookie);
+}
+
+
+LinuxMemArea *
+NewIORemapLinuxMemArea(IMG_CPU_PHYADDR BasePAddr,
+                       IMG_UINT32 ui32Bytes,
+                       IMG_UINT32 ui32AreaFlags)
+{
+    LinuxMemArea *psLinuxMemArea;
+    IMG_VOID *pvIORemapCookie;
+
+    psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        return NULL;
+    }
+
+    pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32AreaFlags);
+    if(!pvIORemapCookie)
+    {
+        LinuxMemAreaStructFree(psLinuxMemArea);
+        return NULL;
+    }
+
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_IOREMAP;
+    psLinuxMemArea->uData.sIORemap.pvIORemapCookie = pvIORemapCookie;
+    psLinuxMemArea->uData.sIORemap.CPUPhysAddr = BasePAddr;
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
+    INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
+#endif
+
+    return psLinuxMemArea;
+}
+
+
+IMG_VOID
+FreeIORemapLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_IOREMAP);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+    
+    IOUnmapWrapper(psLinuxMemArea->uData.sIORemap.pvIORemapCookie);
+
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+static IMG_BOOL
+TreatExternalPagesAsContiguous(IMG_SYS_PHYADDR *psSysPhysAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig)
+{
+        IMG_UINT32 ui32;
+        IMG_UINT32 ui32AddrChk;
+        IMG_UINT32 ui32NumPages = RANGE_TO_PAGES(ui32Bytes);
+
+        
+        for (ui32 = 0, ui32AddrChk = psSysPhysAddr[0].uiAddr;
+                ui32 < ui32NumPages;
+                ui32++, ui32AddrChk = (bPhysContig) ? (ui32AddrChk + PAGE_SIZE) : psSysPhysAddr[ui32].uiAddr)
+        {
+                if (!pfn_valid(PHYS_TO_PFN(ui32AddrChk)))
+                {
+                        break;
+                }
+        }
+        if (ui32 == ui32NumPages)
+        {
+                return IMG_FALSE;
+        }
+
+        if (!bPhysContig)
+        {
+                for (ui32 = 0, ui32AddrChk = psSysPhysAddr[0].uiAddr;
+                        ui32 < ui32NumPages;
+                        ui32++, ui32AddrChk += PAGE_SIZE)
+                {
+                        if (psSysPhysAddr[ui32].uiAddr != ui32AddrChk)
+                        {
+                                return IMG_FALSE;
+                        }
+                }
+        }
+
+        return IMG_TRUE;
+}
+#endif
+
+LinuxMemArea *NewExternalKVLinuxMemArea(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig, IMG_UINT32 ui32AreaFlags)
+{
+    LinuxMemArea *psLinuxMemArea;
+
+    psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        return NULL;
+    }
+
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_EXTERNAL_KV;
+    psLinuxMemArea->uData.sExternalKV.pvExternalKV = pvCPUVAddr;
+    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;
+    }
+    else
+    {
+        psLinuxMemArea->uData.sExternalKV.uPhysAddr.pSysPhysAddr = pBasePAddr;
+    }
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
+    INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
+#endif
+
+    return psLinuxMemArea;
+}
+
+
+IMG_VOID
+FreeExternalKVLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_EXTERNAL_KV);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+    
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+LinuxMemArea *
+NewIOLinuxMemArea(IMG_CPU_PHYADDR BasePAddr,
+                  IMG_UINT32 ui32Bytes,
+                  IMG_UINT32 ui32AreaFlags)
+{
+    LinuxMemArea *psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        return NULL;
+    }
+
+    
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_IO;
+    psLinuxMemArea->uData.sIO.CPUPhysAddr.uiAddr = BasePAddr.uiAddr;
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
+    INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_IO,
+                           (IMG_VOID *)BasePAddr.uiAddr,
+                           0,
+                           BasePAddr.uiAddr,
+                           NULL,
+                           ui32Bytes,
+                           "unknown",
+                           0
+                           );
+#endif
+   
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordAdd(psLinuxMemArea, ui32AreaFlags);
+#endif
+
+    return psLinuxMemArea;
+}
+
+
+IMG_VOID
+FreeIOLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_IO);
+    
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_IO,
+                              (IMG_VOID *)psLinuxMemArea->uData.sIO.CPUPhysAddr.uiAddr, __FILE__, __LINE__);
+#endif
+
+    
+
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+LinuxMemArea *
+NewAllocPagesLinuxMemArea(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags)
+{
+    LinuxMemArea *psLinuxMemArea;
+    IMG_UINT32 ui32PageCount;
+    struct page **pvPageList;
+    IMG_HANDLE hBlockPageList;
+    IMG_INT32 i;                
+    PVRSRV_ERROR eError;
+    
+    psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        goto failed_area_alloc;
+    }
+    
+    ui32PageCount = RANGE_TO_PAGES(ui32Bytes);
+    eError = OSAllocMem(0, sizeof(*pvPageList) * ui32PageCount, (IMG_VOID **)&pvPageList, &hBlockPageList,
+                                                        "Array of pages");
+    if(eError != PVRSRV_OK)
+    {
+        goto failed_page_list_alloc;
+    }
+    
+    for(i=0; i<(IMG_INT32)ui32PageCount; i++)
+    {
+        pvPageList[i] = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, 0);
+        if(!pvPageList[i])
+        {
+            goto failed_alloc_pages;
+        }
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))
+        
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))                
+        SetPageReserved(pvPageList[i]);
+#else
+        mem_map_reserve(pvPageList[i]);
+#endif
+#endif
+
+    }
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES,
+                           pvPageList,
+                           0,
+                           0,
+                           NULL,
+                           PAGE_ALIGN(ui32Bytes),
+                           "unknown",
+                           0
+                           );
+#endif
+
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_ALLOC_PAGES;
+    psLinuxMemArea->uData.sPageList.pvPageList = pvPageList;
+    psLinuxMemArea->uData.sPageList.hBlockPageList = hBlockPageList;
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = ui32AreaFlags;
+    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
+
+    return psLinuxMemArea;
+    
+failed_alloc_pages:
+    for(i--; i >= 0; i--)
+    {
+        __free_pages(pvPageList[i], 0);
+    }
+    (IMG_VOID) OSFreeMem(0, sizeof(*pvPageList) * ui32PageCount, pvPageList, hBlockPageList);
+        psLinuxMemArea->uData.sPageList.pvPageList = IMG_NULL; 
+failed_page_list_alloc:
+    LinuxMemAreaStructFree(psLinuxMemArea);
+failed_area_alloc:
+    PVR_DPF((PVR_DBG_ERROR, "%s: failed", __FUNCTION__));
+    
+    return NULL;
+}
+
+
+IMG_VOID
+FreeAllocPagesLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    IMG_UINT32 ui32PageCount;
+    struct page **pvPageList;
+    IMG_HANDLE hBlockPageList;
+    IMG_INT32 i;
+
+    PVR_ASSERT(psLinuxMemArea);
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_ALLOC_PAGES);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+    
+    ui32PageCount = RANGE_TO_PAGES(psLinuxMemArea->ui32ByteSize);
+    pvPageList = psLinuxMemArea->uData.sPageList.pvPageList;
+    hBlockPageList = psLinuxMemArea->uData.sPageList.hBlockPageList;
+    
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES, pvPageList, __FILE__, __LINE__);
+#endif
+
+    for(i=0;i<(IMG_INT32)ui32PageCount;i++)
+    {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15))               
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))                
+        ClearPageReserved(pvPageList[i]);
+#else
+        mem_map_reserve(pvPageList[i]);
+#endif          
+#endif  
+        __free_pages(pvPageList[i], 0);
+    }
+
+    (IMG_VOID) OSFreeMem(0, sizeof(*pvPageList) * ui32PageCount, pvPageList, hBlockPageList);
+        psLinuxMemArea->uData.sPageList.pvPageList = IMG_NULL; 
+
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+struct page*
+LinuxMemAreaOffsetToPage(LinuxMemArea *psLinuxMemArea,
+                         IMG_UINT32 ui32ByteOffset)
+{
+    IMG_UINT32 ui32PageIndex;
+    IMG_CHAR *pui8Addr;
+
+    switch(psLinuxMemArea->eAreaType)
+    {
+        case LINUX_MEM_AREA_ALLOC_PAGES:
+            ui32PageIndex = PHYS_TO_PFN(ui32ByteOffset);
+            return psLinuxMemArea->uData.sPageList.pvPageList[ui32PageIndex];
+ 
+        case LINUX_MEM_AREA_VMALLOC:
+            pui8Addr = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress;
+            pui8Addr += ui32ByteOffset;
+            return vmalloc_to_page(pui8Addr);
+ 
+        case LINUX_MEM_AREA_SUB_ALLOC:
+             
+            return LinuxMemAreaOffsetToPage(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea,
+                                            psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset
+                                             + ui32ByteOffset);
+        default:
+            PVR_DPF((PVR_DBG_ERROR,
+                    "%s: Unsupported request for struct page from LinuxMemArea with type=%s",
+                    __FUNCTION__, LinuxMemAreaTypeToString(psLinuxMemArea->eAreaType)));
+            return NULL;
+    }
+}
+
+
+LinuxKMemCache *
+KMemCacheCreateWrapper(IMG_CHAR *pszName,
+                       size_t Size,
+                       size_t Align,
+                       IMG_UINT32 ui32Flags)
+{
+#if defined(DEBUG_LINUX_SLAB_ALLOCATIONS)
+    ui32Flags |= SLAB_POISON|SLAB_RED_ZONE;
+#endif
+    return kmem_cache_create(pszName, Size, Align, ui32Flags, NULL
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22))
+                                , NULL
+#endif  
+                            );
+}
+
+
+IMG_VOID
+KMemCacheDestroyWrapper(LinuxKMemCache *psCache)
+{
+    kmem_cache_destroy(psCache);
+}
+
+
+IMG_VOID *
+_KMemCacheAllocWrapper(LinuxKMemCache *psCache,
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
+                      gfp_t Flags,
+#else
+                      IMG_INT Flags,
+#endif
+                      IMG_CHAR *pszFileName,
+                      IMG_UINT32 ui32Line)
+{
+    IMG_VOID *pvRet;
+    
+    pvRet = kmem_cache_zalloc(psCache, Flags);
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordAdd(DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE,
+                           pvRet,
+                           pvRet,
+                           0,
+                           psCache,
+                           kmem_cache_size(psCache),
+                           pszFileName,
+                           ui32Line
+                           );
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+    
+    return pvRet;
+}
+
+
+IMG_VOID
+_KMemCacheFreeWrapper(LinuxKMemCache *psCache, IMG_VOID *pvObject, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line)
+{
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    DebugMemAllocRecordRemove(DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE, pvObject, pszFileName, ui32Line);
+#else
+    PVR_UNREFERENCED_PARAMETER(pszFileName);
+    PVR_UNREFERENCED_PARAMETER(ui32Line);
+#endif
+
+    kmem_cache_free(psCache, pvObject);
+}
+
+
+const IMG_CHAR *
+KMemCacheNameWrapper(LinuxKMemCache *psCache)
+{
+    PVR_UNREFERENCED_PARAMETER(psCache);
+
+    
+    return "";
+}
+
+
+LinuxMemArea *
+NewSubLinuxMemArea(LinuxMemArea *psParentLinuxMemArea,
+                   IMG_UINT32 ui32ByteOffset,
+                   IMG_UINT32 ui32Bytes)
+{
+    LinuxMemArea *psLinuxMemArea;
+    
+    PVR_ASSERT((ui32ByteOffset+ui32Bytes) <= psParentLinuxMemArea->ui32ByteSize);
+    
+    psLinuxMemArea = LinuxMemAreaStructAlloc();
+    if(!psLinuxMemArea)
+    {
+        return NULL;
+    }
+    
+    psLinuxMemArea->eAreaType = LINUX_MEM_AREA_SUB_ALLOC;
+    psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea = psParentLinuxMemArea;
+    psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset = ui32ByteOffset;
+    psLinuxMemArea->ui32ByteSize = ui32Bytes;
+    psLinuxMemArea->ui32AreaFlags = psParentLinuxMemArea->ui32AreaFlags;
+    psLinuxMemArea->bNeedsCacheInvalidate = psParentLinuxMemArea->bNeedsCacheInvalidate;
+    INIT_LIST_HEAD(&psLinuxMemArea->sMMapOffsetStructList);
+    
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    {
+        DEBUG_LINUX_MEM_AREA_REC *psParentRecord;
+        psParentRecord = DebugLinuxMemAreaRecordFind(psParentLinuxMemArea);
+        DebugLinuxMemAreaRecordAdd(psLinuxMemArea, psParentRecord->ui32Flags);
+    }
+#endif
+    
+    return psLinuxMemArea;
+}
+
+
+static IMG_VOID
+FreeSubLinuxMemArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC);
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+    DebugLinuxMemAreaRecordRemove(psLinuxMemArea);
+#endif
+    
+    
+
+    LinuxMemAreaStructFree(psLinuxMemArea);
+}
+
+
+static LinuxMemArea *
+LinuxMemAreaStructAlloc(IMG_VOID)
+{
+#if 0
+    LinuxMemArea *psLinuxMemArea;
+    psLinuxMemArea = kmem_cache_alloc(psLinuxMemAreaCache, GFP_KERNEL);
+    printk(KERN_ERR "%s: psLinuxMemArea=%p\n", __FUNCTION__, psLinuxMemArea);
+    dump_stack();
+    return psLinuxMemArea;
+#else
+    return KMemCacheAllocWrapper(psLinuxMemAreaCache, GFP_KERNEL);
+#endif
+}
+
+
+static IMG_VOID
+LinuxMemAreaStructFree(LinuxMemArea *psLinuxMemArea)
+{
+    KMemCacheFreeWrapper(psLinuxMemAreaCache, psLinuxMemArea);
+    
+    
+}
+
+
+IMG_VOID
+LinuxMemAreaDeepFree(LinuxMemArea *psLinuxMemArea)
+{
+    switch(psLinuxMemArea->eAreaType)
+    {
+        case LINUX_MEM_AREA_VMALLOC:
+            FreeVMallocLinuxMemArea(psLinuxMemArea);
+            break;
+        case LINUX_MEM_AREA_ALLOC_PAGES:
+            FreeAllocPagesLinuxMemArea(psLinuxMemArea);
+            break;
+        case LINUX_MEM_AREA_IOREMAP:
+            FreeIORemapLinuxMemArea(psLinuxMemArea);
+            break;
+        case LINUX_MEM_AREA_EXTERNAL_KV:
+            FreeExternalKVLinuxMemArea(psLinuxMemArea);
+            break;
+        case LINUX_MEM_AREA_IO:
+            FreeIOLinuxMemArea(psLinuxMemArea);
+            break;
+        case LINUX_MEM_AREA_SUB_ALLOC:
+            FreeSubLinuxMemArea(psLinuxMemArea);
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "%s: Unknown are type (%d)\n",
+                     __FUNCTION__, psLinuxMemArea->eAreaType));
+            break;
+    }
+}
+
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+static IMG_VOID
+DebugLinuxMemAreaRecordAdd(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32Flags)
+{
+    DEBUG_LINUX_MEM_AREA_REC *psNewRecord;
+    const IMG_CHAR *pi8FlagsString;
+    
+    LinuxLockMutex(&g_sDebugMutex);
+
+    if(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        g_LinuxMemAreaWaterMark += psLinuxMemArea->ui32ByteSize;
+        if(g_LinuxMemAreaWaterMark > g_LinuxMemAreaHighWaterMark)
+        {
+            g_LinuxMemAreaHighWaterMark = g_LinuxMemAreaWaterMark;
+        }
+    }
+    g_LinuxMemAreaCount++;
+    
+    
+    psNewRecord = kmalloc(sizeof(DEBUG_LINUX_MEM_AREA_REC), GFP_KERNEL);
+    if(psNewRecord)
+    {
+        
+        psNewRecord->psLinuxMemArea = psLinuxMemArea;
+        psNewRecord->ui32Flags = ui32Flags;
+        psNewRecord->pid = current->pid;
+                
+                List_DEBUG_LINUX_MEM_AREA_REC_Insert(&g_LinuxMemAreaRecords, psNewRecord);
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+                 "%s: failed to allocate linux memory area record.",
+                 __FUNCTION__));
+    }
+    
+    
+    pi8FlagsString = HAPFlagsToString(ui32Flags);
+    if(strstr(pi8FlagsString, "UNKNOWN"))
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+                 "%s: Unexpected flags (0x%08x) associated with psLinuxMemArea @ %p",
+                 __FUNCTION__,
+                 ui32Flags,
+                 psLinuxMemArea));
+        
+    }
+
+    LinuxUnLockMutex(&g_sDebugMutex);
+}
+
+
+
+static IMG_VOID* MatchLinuxMemArea_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord,
+                                                                                   va_list va)
+{
+        LinuxMemArea *psLinuxMemArea;
+        
+        psLinuxMemArea = va_arg(va, LinuxMemArea*);
+        if(psCurrentRecord->psLinuxMemArea == psLinuxMemArea)
+        {
+                return psCurrentRecord;
+        }
+        else
+        {
+                return IMG_NULL;
+        }
+}
+
+
+static DEBUG_LINUX_MEM_AREA_REC *
+DebugLinuxMemAreaRecordFind(LinuxMemArea *psLinuxMemArea)
+{
+    DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord;
+
+    LinuxLockMutex(&g_sDebugMutex);
+        psCurrentRecord = List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+                                                                                                                MatchLinuxMemArea_AnyVaCb,
+                                                                                                                psLinuxMemArea);
+        
+    LinuxUnLockMutex(&g_sDebugMutex);
+
+    return psCurrentRecord;
+}
+
+
+static IMG_VOID
+DebugLinuxMemAreaRecordRemove(LinuxMemArea *psLinuxMemArea)
+{
+    DEBUG_LINUX_MEM_AREA_REC *psCurrentRecord;
+
+    LinuxLockMutex(&g_sDebugMutex);
+
+    if(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        g_LinuxMemAreaWaterMark -= psLinuxMemArea->ui32ByteSize;
+    }
+    g_LinuxMemAreaCount--;
+
+    
+        psCurrentRecord = List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+                                                                                                                MatchLinuxMemArea_AnyVaCb,
+                                                                                                                psLinuxMemArea);
+        if(psCurrentRecord)
+        {
+                
+                List_DEBUG_LINUX_MEM_AREA_REC_Remove(psCurrentRecord);
+                kfree(psCurrentRecord);
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: couldn't find an entry for psLinuxMemArea=%p\n",
+                     __FUNCTION__, psLinuxMemArea));
+        }
+
+    LinuxUnLockMutex(&g_sDebugMutex);
+}
+#endif
+
+
+IMG_VOID *
+LinuxMemAreaToCpuVAddr(LinuxMemArea *psLinuxMemArea)
+{
+    switch(psLinuxMemArea->eAreaType)
+    {
+        case LINUX_MEM_AREA_VMALLOC:
+            return psLinuxMemArea->uData.sVmalloc.pvVmallocAddress;
+        case LINUX_MEM_AREA_IOREMAP:
+            return psLinuxMemArea->uData.sIORemap.pvIORemapCookie;
+        case LINUX_MEM_AREA_EXTERNAL_KV:
+            return psLinuxMemArea->uData.sExternalKV.pvExternalKV;
+        case LINUX_MEM_AREA_SUB_ALLOC:
+        {
+            IMG_CHAR *pAddr =
+                LinuxMemAreaToCpuVAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea);  
+            if(!pAddr)
+            {
+                return NULL;
+            }
+            return pAddr + psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset;
+        }
+        default:
+            return NULL;
+    }
+}
+
+
+IMG_CPU_PHYADDR
+LinuxMemAreaToCpuPAddr(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32ByteOffset)
+{
+    IMG_CPU_PHYADDR CpuPAddr;
+    
+    CpuPAddr.uiAddr = 0;
+
+    switch(psLinuxMemArea->eAreaType)
+    {
+        case LINUX_MEM_AREA_IOREMAP:
+        {
+            CpuPAddr = psLinuxMemArea->uData.sIORemap.CPUPhysAddr;
+            CpuPAddr.uiAddr += ui32ByteOffset;
+            break;
+        }
+        case LINUX_MEM_AREA_EXTERNAL_KV:
+        {
+            if (psLinuxMemArea->uData.sExternalKV.bPhysContig)
+            {
+                CpuPAddr = SysSysPAddrToCpuPAddr(psLinuxMemArea->uData.sExternalKV.uPhysAddr.SysPhysAddr);
+                CpuPAddr.uiAddr += ui32ByteOffset;
+            }
+            else
+            {
+                IMG_UINT32 ui32PageIndex = PHYS_TO_PFN(ui32ByteOffset);
+                IMG_SYS_PHYADDR SysPAddr = psLinuxMemArea->uData.sExternalKV.uPhysAddr.pSysPhysAddr[ui32PageIndex];
+
+                CpuPAddr = SysSysPAddrToCpuPAddr(SysPAddr);
+                CpuPAddr.uiAddr += ADDR_TO_PAGE_OFFSET(ui32ByteOffset);
+            }
+            break;
+        }
+        case LINUX_MEM_AREA_IO:
+        {
+            CpuPAddr = psLinuxMemArea->uData.sIO.CPUPhysAddr;
+            CpuPAddr.uiAddr += ui32ByteOffset;
+            break;
+        }
+        case LINUX_MEM_AREA_VMALLOC:
+        {
+            IMG_CHAR *pCpuVAddr;
+            pCpuVAddr =
+                (IMG_CHAR *)psLinuxMemArea->uData.sVmalloc.pvVmallocAddress;
+            pCpuVAddr += ui32ByteOffset;
+            CpuPAddr.uiAddr = VMallocToPhys(pCpuVAddr);
+            break;
+        }
+        case LINUX_MEM_AREA_ALLOC_PAGES:
+        {
+            struct page *page;
+            IMG_UINT32 ui32PageIndex = PHYS_TO_PFN(ui32ByteOffset);
+            page = psLinuxMemArea->uData.sPageList.pvPageList[ui32PageIndex];
+            CpuPAddr.uiAddr = page_to_phys(page);
+            CpuPAddr.uiAddr += ADDR_TO_PAGE_OFFSET(ui32ByteOffset);
+            break;
+        }
+        case LINUX_MEM_AREA_SUB_ALLOC:
+        {
+            CpuPAddr =
+                OSMemHandleToCpuPAddr(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea,
+                                      psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset
+                                        + ui32ByteOffset);
+            break;
+        }
+        default:
+        {
+            PVR_DPF((PVR_DBG_ERROR, "%s: Unknown LinuxMemArea type (%d)\n",
+                     __FUNCTION__, psLinuxMemArea->eAreaType));
+            PVR_ASSERT(CpuPAddr.uiAddr);
+           break;
+        }
+   }
+    
+    return CpuPAddr;
+}
+
+
+IMG_BOOL
+LinuxMemAreaPhysIsContig(LinuxMemArea *psLinuxMemArea)
+{
+    switch(psLinuxMemArea->eAreaType)
+    {
+        case LINUX_MEM_AREA_IOREMAP:
+        case LINUX_MEM_AREA_IO:
+            return IMG_TRUE;
+
+        case LINUX_MEM_AREA_EXTERNAL_KV:
+            return psLinuxMemArea->uData.sExternalKV.bPhysContig;
+
+        case LINUX_MEM_AREA_VMALLOC:
+        case LINUX_MEM_AREA_ALLOC_PAGES:
+            return IMG_FALSE;
+
+        case LINUX_MEM_AREA_SUB_ALLOC:
+             
+            return LinuxMemAreaPhysIsContig(psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea);
+
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "%s: Unknown LinuxMemArea type (%d)\n",
+                     __FUNCTION__, psLinuxMemArea->eAreaType));
+            break;
+    }
+    return IMG_FALSE;
+}
+
+
+const IMG_CHAR *
+LinuxMemAreaTypeToString(LINUX_MEM_AREA_TYPE eMemAreaType)
+{
+    
+    switch(eMemAreaType)
+    {
+        case LINUX_MEM_AREA_IOREMAP:
+            return "LINUX_MEM_AREA_IOREMAP";
+        case LINUX_MEM_AREA_EXTERNAL_KV:
+            return "LINUX_MEM_AREA_EXTERNAL_KV";
+        case LINUX_MEM_AREA_IO:
+            return "LINUX_MEM_AREA_IO";
+        case LINUX_MEM_AREA_VMALLOC:
+            return "LINUX_MEM_AREA_VMALLOC";
+        case LINUX_MEM_AREA_SUB_ALLOC:
+            return "LINUX_MEM_AREA_SUB_ALLOC";
+        case LINUX_MEM_AREA_ALLOC_PAGES:
+            return "LINUX_MEM_AREA_ALLOC_PAGES";
+        default:
+            PVR_ASSERT(0);
+    }
+
+    return "";
+}
+
+
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+static void ProcSeqStartstopDebugMutex(struct seq_file *sfile, IMG_BOOL start) 
+{
+        if(start) 
+        {
+            LinuxLockMutex(&g_sDebugMutex);             
+        }
+        else
+        {
+            LinuxUnLockMutex(&g_sDebugMutex);
+        }
+}
+#endif 
+
+#if defined(DEBUG_LINUX_MEM_AREAS)
+
+static IMG_VOID* DecOffMemAreaRec_AnyVaCb(DEBUG_LINUX_MEM_AREA_REC *psNode, va_list va)
+{
+        off_t *pOff = va_arg(va, off_t*);
+        if (--(*pOff))
+        {
+                return IMG_NULL;
+        }
+        else
+        {
+                return psNode;
+        }
+}
+
+ 
+static void* ProcSeqNextMemArea(struct seq_file *sfile,void* el,loff_t off) 
+{
+    DEBUG_LINUX_MEM_AREA_REC *psRecord;
+        psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
+                                List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+                                                                                                        DecOffMemAreaRec_AnyVaCb,
+                                                                                                        &off);
+        return (void*)psRecord;
+}
+
+static void* ProcSeqOff2ElementMemArea(struct seq_file * sfile, loff_t off)
+{
+    DEBUG_LINUX_MEM_AREA_REC *psRecord;
+        if(!off) 
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+        psRecord = (DEBUG_LINUX_MEM_AREA_REC*)
+                                List_DEBUG_LINUX_MEM_AREA_REC_Any_va(g_LinuxMemAreaRecords,
+                                                                                                        DecOffMemAreaRec_AnyVaCb,
+                                                                                                        &off);
+        return (void*)psRecord;
+}
+
+
+static void ProcSeqShowMemArea(struct seq_file *sfile,void* el)
+{
+    DEBUG_LINUX_MEM_AREA_REC *psRecord = (DEBUG_LINUX_MEM_AREA_REC*)el; 
+        if(el == PVR_PROC_SEQ_START_TOKEN) 
+        {
+
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+        seq_printf( sfile,
+                                  "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,
+                          g_LinuxMemAreaWaterMark,
+                          g_LinuxMemAreaHighWaterMark,
+                          "psLinuxMemArea",
+                          "LinuxMemType",
+                          "CpuVAddr",
+                          "CpuPAddr",
+                          "Bytes",
+                          "Pid",
+                          "Flags"
+                         );
+#else
+        seq_printf( sfile,
+                          "<mem_areas_header>\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,
+                          g_LinuxMemAreaHighWaterMark
+                         );
+#endif
+                return;
+        }
+
+        seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+                       "%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>%08x</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)
+                      );
+
+}
+
+#endif 
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+
+static IMG_VOID* DecOffMemAllocRec_AnyVaCb(DEBUG_MEM_ALLOC_REC *psNode, va_list va)
+{
+        off_t *pOff = va_arg(va, off_t*);
+        if (--(*pOff))
+        {
+                return IMG_NULL;
+        }
+        else
+        {
+                return psNode;
+        }
+}
+
+
+ 
+static void* ProcSeqNextMemoryRecords(struct seq_file *sfile,void* el,loff_t off) 
+{
+    DEBUG_MEM_ALLOC_REC *psRecord;
+        psRecord = (DEBUG_MEM_ALLOC_REC*)
+                List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
+                                                                                DecOffMemAllocRec_AnyVaCb,
+                                                                                &off);
+#if defined(DEBUG_LINUX_XML_PROC_FILES)
+        if(!psRecord) 
+        {
+                seq_printf( sfile, "</meminfo>\n");
+        }
+#endif
+
+        return (void*)psRecord;
+}
+
+static void* ProcSeqOff2ElementMemoryRecords(struct seq_file *sfile, loff_t off)
+{
+    DEBUG_MEM_ALLOC_REC *psRecord;
+        if(!off) 
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+        psRecord = (DEBUG_MEM_ALLOC_REC*)
+                List_DEBUG_MEM_ALLOC_REC_Any_va(g_MemoryRecords,
+                                                                                DecOffMemAllocRec_AnyVaCb,
+                                                                                &off);
+
+#if defined(DEBUG_LINUX_XML_PROC_FILES)
+        if(!psRecord) 
+        {
+                seq_printf( sfile, "</meminfo>\n");
+        }
+#endif
+
+        return (void*)psRecord;
+}
+
+static void ProcSeqShowMemoryRecords(struct seq_file *sfile,void* el)
+{
+    DEBUG_MEM_ALLOC_REC *psRecord = (DEBUG_MEM_ALLOC_REC*)el;
+        if(el == PVR_PROC_SEQ_START_TOKEN) 
+        {
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+        
+        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: %d bytes\n",
+                           "Highest Water Mark of bytes allocated via kmalloc",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+        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: %d bytes\n",
+                           "Highest Water Mark of bytes allocated via vmalloc",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+        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: %d bytes\n",
+                           "Highest Water Mark of bytes allocated via alloc_pages",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+        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: %d bytes\n",
+                           "Highest Water Mark of bytes allocated via ioremap",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+        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: %d bytes\n",
+                           "Highest Water Mark of bytes allocated for \"IO\" memory areas",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+        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: %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: %d bytes\n",
+                           "The Current Water Mark for memory allocated from system RAM",
+                           g_SysRAMWaterMark);
+        seq_printf( sfile, "%-60s: %d bytes\n",
+                           "The Highest Water Mark for memory allocated from system RAM",
+                           g_SysRAMHighWaterMark);
+        seq_printf( sfile, "%-60s: %d bytes\n",
+                           "The Current Water Mark for memory allocated from IO memory",
+                           g_IOMemWaterMark);
+        seq_printf( sfile, "%-60s: %d bytes\n",
+                           "The Highest Water Mark for memory allocated from IO memory",
+                           g_IOMemHighWaterMark);
+
+        seq_printf( sfile, "\n");
+
+                seq_printf( sfile, "Details for all known allocations:\n"
+                           "%-16s %-8s %-8s %-10s %-5s %-10s %s\n",
+                           "Type",
+                           "CpuVAddr",
+                           "CpuPAddr",
+                           "Bytes",
+                           "PID",
+                           "PrivateData",
+                           "Filename:Line");
+
+#else 
+                
+                
+                seq_printf( sfile, "<meminfo>\n<meminfo_header>\n");
+                seq_printf( sfile,
+                           "<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=\"%d\"/>\n",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_KMALLOC]);
+                seq_printf( sfile,
+                           "<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=\"%d\"/>\n",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_VMALLOC]);
+                seq_printf( sfile,
+                           "<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=\"%d\"/>\n",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_ALLOC_PAGES]);
+                seq_printf( sfile,
+                           "<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=\"%d\"/>\n",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IOREMAP]);
+                seq_printf( sfile,
+                           "<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=\"%d\"/>\n",
+                           g_HighWaterMarkData[DEBUG_MEM_ALLOC_TYPE_IO]);
+                seq_printf( sfile,
+                           "<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=\"%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=\"%d\"/>\n",
+                           g_SysRAMWaterMark);
+                seq_printf( sfile,
+                           "<watermark key=\"mr15\" description=\"system_ram_high\" bytes=\"%d\"/>\n",
+                           g_SysRAMHighWaterMark);
+                seq_printf( sfile,
+                           "<watermark key=\"mr16\" description=\"system_io_current\" bytes=\"%d\"/>\n",
+                           g_IOMemWaterMark);
+                seq_printf( sfile,
+                           "<watermark key=\"mr17\" description=\"system_io_high\" bytes=\"%d\"/>\n",
+                           g_IOMemHighWaterMark);
+
+                seq_printf( sfile, "</meminfo_header>\n");
+
+#endif 
+                return;
+        }
+
+    if(psRecord->eAllocType != DEBUG_MEM_ALLOC_TYPE_KMEM_CACHE)
+    {
+                seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+                           "%-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>%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>%d</line>\n"
+                           "</allocation>\n",
+#endif
+                           DebugMemAllocRecordTypeToString(psRecord->eAllocType),
+                           psRecord->pvCpuVAddr,
+                           psRecord->ulCpuPAddr,
+                           psRecord->ui32Bytes,
+                           psRecord->pid,
+                           "NULL",
+                           psRecord->pszFileName,
+                           psRecord->ui32Line);
+    }
+    else
+    {
+                seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+                           "%-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>%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>%d</line>\n"
+                           "</allocation>\n",
+#endif
+                           DebugMemAllocRecordTypeToString(psRecord->eAllocType),
+                           psRecord->pvCpuVAddr,
+                           psRecord->ulCpuPAddr,
+                           psRecord->ui32Bytes,
+                           psRecord->pid,
+                           KMemCacheNameWrapper(psRecord->pvPrivateData),
+                           psRecord->pszFileName,
+                           psRecord->ui32Line);
+    }
+}
+
+#endif 
+
+
+#if defined(DEBUG_LINUX_MEM_AREAS) || defined(DEBUG_LINUX_MMAP_AREAS)
+const IMG_CHAR *
+HAPFlagsToString(IMG_UINT32 ui32Flags)
+{
+    static IMG_CHAR szFlags[50];
+    IMG_INT32 i32Pos = 0;
+    IMG_UINT32 ui32CacheTypeIndex, ui32MapTypeIndex;
+    IMG_CHAR *apszCacheTypes[] = {
+        "UNCACHED",
+        "CACHED",
+        "WRITECOMBINE",
+        "UNKNOWN"
+    };
+    IMG_CHAR *apszMapType[] = {
+        "KERNEL_ONLY",
+        "SINGLE_PROCESS",
+        "MULTI_PROCESS",
+        "FROM_EXISTING_PROCESS",
+        "NO_CPU_VIRTUAL",
+        "UNKNOWN"
+    };
+    
+    
+    if(ui32Flags & PVRSRV_HAP_UNCACHED){
+        ui32CacheTypeIndex=0;
+    }else if(ui32Flags & PVRSRV_HAP_CACHED){
+        ui32CacheTypeIndex=1;
+    }else if(ui32Flags & PVRSRV_HAP_WRITECOMBINE){
+        ui32CacheTypeIndex=2;
+    }else{
+        ui32CacheTypeIndex=3;
+        PVR_DPF((PVR_DBG_ERROR, "%s: unknown cache type (%u)",
+                 __FUNCTION__, (ui32Flags & PVRSRV_HAP_CACHETYPE_MASK)));
+    }
+
+    
+    if(ui32Flags & PVRSRV_HAP_KERNEL_ONLY){
+        ui32MapTypeIndex = 0;
+    }else if(ui32Flags & PVRSRV_HAP_SINGLE_PROCESS){
+        ui32MapTypeIndex = 1;
+    }else if(ui32Flags & PVRSRV_HAP_MULTI_PROCESS){
+        ui32MapTypeIndex = 2;
+    }else if(ui32Flags & PVRSRV_HAP_FROM_EXISTING_PROCESS){
+        ui32MapTypeIndex = 3;
+    }else if(ui32Flags & PVRSRV_HAP_NO_CPU_VIRTUAL){
+        ui32MapTypeIndex = 4;
+    }else{
+        ui32MapTypeIndex = 5;
+        PVR_DPF((PVR_DBG_ERROR, "%s: unknown map type (%u)",
+                 __FUNCTION__, (ui32Flags & PVRSRV_HAP_MAPTYPE_MASK)));
+    }
+
+    i32Pos = sprintf(szFlags, "%s|", apszCacheTypes[ui32CacheTypeIndex]);
+    if (i32Pos <= 0)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "%s: sprintf for cache type %u failed (%d)",
+                __FUNCTION__, ui32CacheTypeIndex, i32Pos));
+        szFlags[0] = 0;
+    }
+    else
+    {
+        sprintf(szFlags + i32Pos, "%s", apszMapType[ui32MapTypeIndex]);
+    }
+
+    return szFlags;
+}
+#endif
+
diff --git a/drivers/gpu/pvr/mm.h b/drivers/gpu/pvr/mm.h
new file mode 100644
index 00000000000..047b3ad540c
--- /dev/null
+++ b/drivers/gpu/pvr/mm.h
@@ -0,0 +1,333 @@
+/**********************************************************************
+ *
+ * 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 __IMG_LINUX_MM_H__
+#define __IMG_LINUX_MM_H__
+
+#ifndef AUTOCONF_INCLUDED
+ #include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/list.h>
+
+#include <asm/io.h>
+
+#define PHYS_TO_PFN(phys) ((phys) >> PAGE_SHIFT)
+#define PFN_TO_PHYS(pfn) ((pfn) << PAGE_SHIFT)
+
+#define RANGE_TO_PAGES(range) (((range) + (PAGE_SIZE - 1)) >> PAGE_SHIFT)
+
+#define ADDR_TO_PAGE_OFFSET(addr) (((unsigned long)(addr)) & (PAGE_SIZE - 1))
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+#define REMAP_PFN_RANGE(vma, addr, pfn, size, prot) remap_pfn_range(vma, addr, pfn, size, prot)
+#else
+#define REMAP_PFN_RANGE(vma, addr, pfn, size, prot) remap_page_range(vma, addr, PFN_TO_PHYS(pfn), size, prot)
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12))
+#define IO_REMAP_PFN_RANGE(vma, addr, pfn, size, prot) io_remap_pfn_range(vma, addr, pfn, size, prot)
+#else
+#define IO_REMAP_PFN_RANGE(vma, addr, pfn, size, prot) io_remap_page_range(vma, addr, PFN_TO_PHYS(pfn), size, prot)
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
+#define VM_INSERT_PAGE(vma, addr, page) vm_insert_page(vma, addr, page)
+#else
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+#define VM_INSERT_PAGE(vma, addr, page) remap_pfn_range(vma, addr, page_to_pfn(page), PAGE_SIZE, vma->vm_page_prot);
+#else
+#define VM_INSERT_PAGE(vma, addr, page) remap_page_range(vma, addr, page_to_phys(page), PAGE_SIZE, vma->vm_page_prot);
+#endif
+#endif
+
+static inline IMG_UINT32 VMallocToPhys(IMG_VOID *pCpuVAddr)
+{
+        return (page_to_phys(vmalloc_to_page(pCpuVAddr)) + ADDR_TO_PAGE_OFFSET(pCpuVAddr));
+                
+}
+
+typedef enum {
+    LINUX_MEM_AREA_IOREMAP,
+        LINUX_MEM_AREA_EXTERNAL_KV,
+    LINUX_MEM_AREA_IO,
+    LINUX_MEM_AREA_VMALLOC,
+    LINUX_MEM_AREA_ALLOC_PAGES,
+    LINUX_MEM_AREA_SUB_ALLOC,
+    LINUX_MEM_AREA_TYPE_COUNT
+}LINUX_MEM_AREA_TYPE;
+
+typedef struct _LinuxMemArea LinuxMemArea;
+
+
+struct _LinuxMemArea {
+    LINUX_MEM_AREA_TYPE eAreaType;
+    union _uData
+    {
+        struct _sIORemap
+        {
+            
+            IMG_CPU_PHYADDR CPUPhysAddr;
+            IMG_VOID *pvIORemapCookie;
+        }sIORemap;
+        struct _sExternalKV
+        {
+            
+            IMG_BOOL bPhysContig;
+            union {
+                    
+                    IMG_SYS_PHYADDR SysPhysAddr;
+                    IMG_SYS_PHYADDR *pSysPhysAddr;
+            } uPhysAddr;
+            IMG_VOID *pvExternalKV;
+        }sExternalKV;
+        struct _sIO
+        {
+            
+            IMG_CPU_PHYADDR CPUPhysAddr;
+        }sIO;
+        struct _sVmalloc
+        {
+            
+            IMG_VOID *pvVmallocAddress;
+        }sVmalloc;
+        struct _sPageList
+        {
+            
+            struct page **pvPageList;
+            IMG_HANDLE hBlockPageList;
+        }sPageList;
+        struct _sSubAlloc
+        {
+            
+            LinuxMemArea *psParentLinuxMemArea;
+            IMG_UINT32 ui32ByteOffset;
+        }sSubAlloc;
+    }uData;
+
+    IMG_UINT32 ui32ByteSize;            
+
+    IMG_UINT32 ui32AreaFlags;           
+
+    IMG_BOOL bMMapRegistered;           
+
+    IMG_BOOL bNeedsCacheInvalidate;     
+
+    
+    struct list_head    sMMapItem;
+
+    
+    struct list_head    sMMapOffsetStructList;
+};
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17))
+typedef kmem_cache_t LinuxKMemCache;
+#else
+typedef struct kmem_cache LinuxKMemCache;
+#endif
+
+
+PVRSRV_ERROR LinuxMMInit(IMG_VOID);
+
+
+IMG_VOID LinuxMMCleanup(IMG_VOID);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define KMallocWrapper(ui32ByteSize) _KMallocWrapper(ui32ByteSize, __FILE__, __LINE__)
+#else
+#define KMallocWrapper(ui32ByteSize) _KMallocWrapper(ui32ByteSize, NULL, 0)
+#endif
+IMG_VOID *_KMallocWrapper(IMG_UINT32 ui32ByteSize, IMG_CHAR *szFileName, IMG_UINT32 ui32Line);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define KFreeWrapper(pvCpuVAddr) _KFreeWrapper(pvCpuVAddr, __FILE__, __LINE__)
+#else
+#define KFreeWrapper(pvCpuVAddr) _KFreeWrapper(pvCpuVAddr, NULL, 0)
+#endif
+IMG_VOID _KFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define VMallocWrapper(ui32Bytes, ui32AllocFlags) _VMallocWrapper(ui32Bytes, ui32AllocFlags, __FILE__, __LINE__)
+#else
+#define VMallocWrapper(ui32Bytes, ui32AllocFlags) _VMallocWrapper(ui32Bytes, ui32AllocFlags, NULL, 0)
+#endif
+IMG_VOID *_VMallocWrapper(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AllocFlags, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define VFreeWrapper(pvCpuVAddr) _VFreeWrapper(pvCpuVAddr, __FILE__, __LINE__)
+#else
+#define VFreeWrapper(pvCpuVAddr) _VFreeWrapper(pvCpuVAddr, NULL, 0)
+#endif
+IMG_VOID _VFreeWrapper(IMG_VOID *pvCpuVAddr, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+
+LinuxMemArea *NewVMallocLinuxMemArea(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags);
+
+
+IMG_VOID FreeVMallocLinuxMemArea(LinuxMemArea *psLinuxMemArea);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags) \
+    _IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags, __FILE__, __LINE__)
+#else
+#define IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags) \
+    _IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags, NULL, 0)
+#endif
+IMG_VOID *_IORemapWrapper(IMG_CPU_PHYADDR BasePAddr,
+                          IMG_UINT32 ui32Bytes,
+                          IMG_UINT32 ui32MappingFlags,
+                          IMG_CHAR *pszFileName,
+                          IMG_UINT32 ui32Line);
+
+
+LinuxMemArea *NewIORemapLinuxMemArea(IMG_CPU_PHYADDR BasePAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags);
+
+
+IMG_VOID FreeIORemapLinuxMemArea(LinuxMemArea *psLinuxMemArea);
+
+LinuxMemArea *NewExternalKVLinuxMemArea(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_BOOL bPhysContig, IMG_UINT32 ui32AreaFlags);
+
+
+IMG_VOID FreeExternalKVLinuxMemArea(LinuxMemArea *psLinuxMemArea);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define IOUnmapWrapper(pvIORemapCookie) \
+    _IOUnmapWrapper(pvIORemapCookie, __FILE__, __LINE__)
+#else
+#define IOUnmapWrapper(pvIORemapCookie) \
+    _IOUnmapWrapper(pvIORemapCookie, NULL, 0)
+#endif
+IMG_VOID _IOUnmapWrapper(IMG_VOID *pvIORemapCookie, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+
+struct page *LinuxMemAreaOffsetToPage(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32ByteOffset);
+
+
+LinuxKMemCache *KMemCacheCreateWrapper(IMG_CHAR *pszName, size_t Size, size_t Align, IMG_UINT32 ui32Flags);
+
+
+IMG_VOID KMemCacheDestroyWrapper(LinuxKMemCache *psCache);
+
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define KMemCacheAllocWrapper(psCache, Flags) _KMemCacheAllocWrapper(psCache, Flags, __FILE__, __LINE__)
+#else
+#define KMemCacheAllocWrapper(psCache, Flags) _KMemCacheAllocWrapper(psCache, Flags, NULL, 0)
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
+IMG_VOID *_KMemCacheAllocWrapper(LinuxKMemCache *psCache, gfp_t Flags, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+#else
+IMG_VOID *_KMemCacheAllocWrapper(LinuxKMemCache *psCache, int Flags, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+#endif
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+#define KMemCacheFreeWrapper(psCache, pvObject) _KMemCacheFreeWrapper(psCache, pvObject, __FILE__, __LINE__)
+#else
+#define KMemCacheFreeWrapper(psCache, pvObject) _KMemCacheFreeWrapper(psCache, pvObject, NULL, 0)
+#endif
+IMG_VOID _KMemCacheFreeWrapper(LinuxKMemCache *psCache, IMG_VOID *pvObject, IMG_CHAR *pszFileName, IMG_UINT32 ui32Line);
+
+
+const IMG_CHAR *KMemCacheNameWrapper(LinuxKMemCache *psCache);
+
+
+LinuxMemArea *NewIOLinuxMemArea(IMG_CPU_PHYADDR BasePAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags);
+
+
+IMG_VOID FreeIOLinuxMemArea(LinuxMemArea *psLinuxMemArea);
+
+
+LinuxMemArea *NewAllocPagesLinuxMemArea(IMG_UINT32 ui32Bytes, IMG_UINT32 ui32AreaFlags);
+
+
+IMG_VOID FreeAllocPagesLinuxMemArea(LinuxMemArea *psLinuxMemArea);
+
+
+LinuxMemArea *NewSubLinuxMemArea(LinuxMemArea *psParentLinuxMemArea,
+                                 IMG_UINT32 ui32ByteOffset,
+                                 IMG_UINT32 ui32Bytes);
+
+
+IMG_VOID LinuxMemAreaDeepFree(LinuxMemArea *psLinuxMemArea);
+
+
+#if defined(LINUX_MEM_AREAS_DEBUG)
+IMG_VOID LinuxMemAreaRegister(LinuxMemArea *psLinuxMemArea);
+#else
+#define LinuxMemAreaRegister(X)
+#endif
+
+
+IMG_VOID *LinuxMemAreaToCpuVAddr(LinuxMemArea *psLinuxMemArea);
+
+
+IMG_CPU_PHYADDR LinuxMemAreaToCpuPAddr(LinuxMemArea *psLinuxMemArea, IMG_UINT32 ui32ByteOffset);
+
+
+#define  LinuxMemAreaToCpuPFN(psLinuxMemArea, ui32ByteOffset) PHYS_TO_PFN(LinuxMemAreaToCpuPAddr(psLinuxMemArea, ui32ByteOffset).uiAddr)
+
+IMG_BOOL LinuxMemAreaPhysIsContig(LinuxMemArea *psLinuxMemArea);
+
+static inline LinuxMemArea *
+LinuxMemAreaRoot(LinuxMemArea *psLinuxMemArea)
+{
+    if(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        return psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea;
+    }
+    else
+    {
+        return psLinuxMemArea;
+    }
+}
+
+
+static inline LINUX_MEM_AREA_TYPE
+LinuxMemAreaRootType(LinuxMemArea *psLinuxMemArea)
+{
+    return LinuxMemAreaRoot(psLinuxMemArea)->eAreaType;
+}
+
+
+const IMG_CHAR *LinuxMemAreaTypeToString(LINUX_MEM_AREA_TYPE eMemAreaType);
+
+
+#if defined(DEBUG) || defined(DEBUG_LINUX_MEM_AREAS)
+const IMG_CHAR *HAPFlagsToString(IMG_UINT32 ui32Flags);
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/mmap.c b/drivers/gpu/pvr/mmap.c
new file mode 100644
index 00000000000..66cef26e522
--- /dev/null
+++ b/drivers/gpu/pvr/mmap.c
@@ -0,0 +1,1132 @@
+/**********************************************************************
+ *
+ * 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/mm.h>
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+#include <linux/wrapper.h>
+#endif
+#include <linux/slab.h>
+#include <asm/io.h>
+#include <asm/page.h>
+#include <asm/shmparam.h>
+#include <asm/pgtable.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#include <linux/sched.h>
+#include <asm/current.h>
+#endif
+#if defined(SUPPORT_DRI_DRM)
+#include <drm/drmP.h>
+#endif
+
+#include "img_defs.h"
+#include "services.h"
+#include "servicesint.h"
+#include "pvrmmap.h"
+#include "mutils.h"
+#include "mmap.h"
+#include "mm.h"
+#include "pvr_debug.h"
+#include "osfunc.h"
+#include "proc.h"
+#include "mutex.h"
+#include "handle.h"
+#include "perproc.h"
+#include "env_perproc.h"
+#include "bridged_support.h"
+#if defined(SUPPORT_DRI_DRM)
+#include "pvr_drm.h"
+#endif
+
+#if !defined(PVR_SECURE_HANDLES)
+#error "The mmap code requires PVR_SECURE_HANDLES"
+#endif
+
+static PVRSRV_LINUX_MUTEX g_sMMapMutex;
+
+static LinuxKMemCache *g_psMemmapCache = NULL;
+static LIST_HEAD(g_sMMapAreaList);
+static LIST_HEAD(g_sMMapOffsetStructList);
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+static IMG_UINT32 g_ui32RegisteredAreas = 0;
+static IMG_UINT32 g_ui32TotalByteSize = 0;
+#endif
+
+
+#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       (FIRST_PHYSICAL_PFN + MAX_MMAP_HANDLE)
+#define FIRST_SPECIAL_PFN       (LAST_PHYSICAL_PFN + 1)
+#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 <= LAST_PHYSICAL_PFN)) ? IMG_TRUE : IMG_FALSE;
+}
+
+static inline IMG_BOOL
+PFNIsSpecial(IMG_UINT32 pfn)
+{
+        
+        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)
+{
+        if (PFNIsPhysical(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)
+{
+    PKV_OFFSET_STRUCT psOffsetStruct;
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
+    const IMG_CHAR *pszName = LinuxMemAreaTypeToString(LinuxMemAreaRootType(psLinuxMemArea));
+#endif
+
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
+    PVR_DPF((PVR_DBG_MESSAGE,
+             "%s(%s, psLinuxMemArea: 0x%p, ui32AllocFlags: 0x%8x)",
+             __FUNCTION__, pszName, psLinuxMemArea, psLinuxMemArea->ui32AreaFlags));
+#endif
+
+    PVR_ASSERT(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC || LinuxMemAreaRoot(psLinuxMemArea)->eAreaType != LINUX_MEM_AREA_SUB_ALLOC);
+
+    PVR_ASSERT(psLinuxMemArea->bMMapRegistered);
+
+    psOffsetStruct = KMemCacheAllocWrapper(g_psMemmapCache, GFP_KERNEL);
+    if(psOffsetStruct == IMG_NULL)
+    {
+        PVR_DPF((PVR_DBG_ERROR,"PVRMMapRegisterArea: Couldn't alloc another mapping record from cache"));
+        return IMG_NULL;
+    }
+    
+    psOffsetStruct->ui32MMapOffset = ui32Offset;
+
+    psOffsetStruct->psLinuxMemArea = psLinuxMemArea;
+
+    psOffsetStruct->ui32RealByteSize = ui32RealByteSize;
+
+    
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+    psOffsetStruct->ui32TID = GetCurrentThreadID();
+#endif
+    psOffsetStruct->ui32PID = OSGetCurrentProcessIDKM();
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    
+    psOffsetStruct->pszName = pszName;
+#endif
+
+    list_add_tail(&psOffsetStruct->sAreaItem, &psLinuxMemArea->sMMapOffsetStructList);
+
+    return psOffsetStruct;
+}
+
+
+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=%p, CpuPAddr=0x%08X", __FUNCTION__,
+             psOffsetStruct->psLinuxMemArea,
+             CpuPAddr.uiAddr));
+#endif
+    
+    KMemCacheFreeWrapper(g_psMemmapCache, psOffsetStruct);
+}
+
+
+static inline IMG_VOID
+DetermineUsersSizeAndByteOffset(LinuxMemArea *psLinuxMemArea,
+                               IMG_UINT32 *pui32RealByteSize,
+                               IMG_UINT32 *pui32ByteOffset)
+{
+    IMG_UINT32 ui32PageAlignmentOffset;
+    IMG_CPU_PHYADDR CpuPAddr;
+    
+    CpuPAddr = LinuxMemAreaToCpuPAddr(psLinuxMemArea, 0);
+    ui32PageAlignmentOffset = ADDR_TO_PAGE_OFFSET(CpuPAddr.uiAddr);
+    
+    *pui32ByteOffset = ui32PageAlignmentOffset;
+
+    *pui32RealByteSize = PAGE_ALIGN(psLinuxMemArea->ui32ByteSize + ui32PageAlignmentOffset);
+}
+
+
+PVRSRV_ERROR
+PVRMMapOSMemHandleToMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                IMG_HANDLE hMHandle,
+                                IMG_UINT32 *pui32MMapOffset,
+                                IMG_UINT32 *pui32ByteOffset,
+                                IMG_UINT32 *pui32RealByteSize,
+                                IMG_UINT32 *pui32UserVAddr)
+{
+    LinuxMemArea *psLinuxMemArea;
+    PKV_OFFSET_STRUCT psOffsetStruct;
+    IMG_HANDLE hOSMemHandle;
+    PVRSRV_ERROR eError;
+
+    LinuxLockMutex(&g_sMMapMutex);
+
+    PVR_ASSERT(PVRSRVGetMaxHandle(psPerProc->psHandleBase) <= MAX_MMAP_HANDLE);
+
+    eError = PVRSRVLookupOSMemHandle(psPerProc->psHandleBase, &hOSMemHandle, hMHandle);
+    if (eError != PVRSRV_OK)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle %p failed", __FUNCTION__, hMHandle));
+
+        goto exit_unlock;
+    }
+
+    psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+    DetermineUsersSizeAndByteOffset(psLinuxMemArea,
+                                   pui32RealByteSize,
+                                   pui32ByteOffset);
+
+    
+    list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+    {
+        if (psPerProc->ui32PID == psOffsetStruct->ui32PID)
+        {
+
+           PVR_ASSERT(*pui32RealByteSize == psOffsetStruct->ui32RealByteSize);
+           
+           *pui32MMapOffset = psOffsetStruct->ui32MMapOffset;
+           *pui32UserVAddr = psOffsetStruct->ui32UserVAddr;
+           psOffsetStruct->ui32RefCount++;
+
+           eError = PVRSRV_OK;
+           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);
+    if (psOffsetStruct == IMG_NULL)
+    {
+        eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+        goto exit_unlock;
+    }
+
+    
+    list_add_tail(&psOffsetStruct->sMMapItem, &g_sMMapOffsetStructList);
+
+    psOffsetStruct->bOnMMapList = IMG_TRUE;
+
+    psOffsetStruct->ui32RefCount++;
+
+    eError = PVRSRV_OK;
+
+        
+
+
+        *pui32MMapOffset = *pui32MMapOffset << (PAGE_SHIFT - 12);
+
+exit_unlock:
+    LinuxUnLockMutex(&g_sMMapMutex);
+
+    return eError;
+}
+
+
+PVRSRV_ERROR
+PVRMMapReleaseMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                IMG_HANDLE hMHandle,
+                                IMG_BOOL *pbMUnmap,
+                                IMG_UINT32 *pui32RealByteSize,
+                                IMG_UINT32 *pui32UserVAddr)
+{
+    LinuxMemArea *psLinuxMemArea;
+    PKV_OFFSET_STRUCT psOffsetStruct;
+    IMG_HANDLE hOSMemHandle;
+    PVRSRV_ERROR eError;
+    IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
+
+    LinuxLockMutex(&g_sMMapMutex);
+
+    PVR_ASSERT(PVRSRVGetMaxHandle(psPerProc->psHandleBase) <= MAX_MMAP_HANDLE);
+
+    eError = PVRSRVLookupOSMemHandle(psPerProc->psHandleBase, &hOSMemHandle, hMHandle);
+    if (eError != PVRSRV_OK)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "%s: Lookup of handle %p failed", __FUNCTION__, hMHandle));
+
+        goto exit_unlock;
+    }
+
+    psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+    
+    list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+    {
+        if (psOffsetStruct->ui32PID == ui32PID)
+        {
+            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 %p", __FUNCTION__, psOffsetStruct, psLinuxMemArea));
+                eError = PVRSRV_ERROR_STILL_MAPPED;
+                goto exit_unlock;
+            }
+
+            psOffsetStruct->ui32RefCount--;
+
+            *pbMUnmap = (IMG_BOOL)((psOffsetStruct->ui32RefCount == 0) && (psOffsetStruct->ui32UserVAddr != 0));
+
+            *pui32UserVAddr = (*pbMUnmap) ? psOffsetStruct->ui32UserVAddr : 0;
+            *pui32RealByteSize = (*pbMUnmap) ? psOffsetStruct->ui32RealByteSize : 0;
+
+            eError = PVRSRV_OK;
+            goto exit_unlock;
+        }
+    }
+
+    
+    PVR_DPF((PVR_DBG_ERROR, "%s: Mapping data not found for handle %p (memory area %p)", __FUNCTION__, hMHandle, psLinuxMemArea));
+
+    eError =  PVRSRV_ERROR_MAPPING_NOT_FOUND;
+
+exit_unlock:
+    LinuxUnLockMutex(&g_sMMapMutex);
+
+    return eError;
+}
+
+static inline PKV_OFFSET_STRUCT
+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;
+            }
+        }
+    }
+
+    return IMG_NULL;
+}
+
+
+static IMG_BOOL
+DoMapToUser(LinuxMemArea *psLinuxMemArea,
+            struct vm_area_struct* ps_vma,
+            IMG_UINT32 ui32ByteOffset)
+{
+    IMG_UINT32 ui32ByteSize;
+
+    if (psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        return DoMapToUser(LinuxMemAreaRoot(psLinuxMemArea),             
+                    ps_vma,
+                    psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset + ui32ByteOffset);
+    }
+
+    
+    ui32ByteSize = ps_vma->vm_end - ps_vma->vm_start;
+    PVR_ASSERT(ADDR_TO_PAGE_OFFSET(ui32ByteSize) == 0);
+
+#if defined (__sparc__)
+    
+#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);
+
+        if(result == 0)
+        {
+            return IMG_TRUE;
+        }
+
+        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)
+        {
+            IMG_UINT32 pfn =  LinuxMemAreaToCpuPFN(psLinuxMemArea, ui32PA);
+
+            if (!pfn_valid(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;
+            IMG_INT result;
+
+            pfn =  LinuxMemAreaToCpuPFN(psLinuxMemArea, ui32PA);
+
+#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));
+
+                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;
+        }
+    }
+
+    return IMG_TRUE;
+}
+
+
+static IMG_VOID
+MMapVOpenNoLock(struct vm_area_struct* ps_vma)
+{
+    PKV_OFFSET_STRUCT psOffsetStruct = (PKV_OFFSET_STRUCT)ps_vma->vm_private_data;
+    PVR_ASSERT(psOffsetStruct != IMG_NULL)
+    psOffsetStruct->ui32Mapped++;
+    PVR_ASSERT(!psOffsetStruct->bOnMMapList);
+
+    if (psOffsetStruct->ui32Mapped > 1)
+    {
+        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 %d, ui32Mapped %d",
+             __FUNCTION__,
+             psOffsetStruct->psLinuxMemArea,
+             LinuxMemAreaToCpuVAddr(psOffsetStruct->psLinuxMemArea),
+             psOffsetStruct->ui32MMapOffset,
+             psOffsetStruct->ui32Mapped));
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+    MOD_INC_USE_COUNT;
+#endif
+}
+
+
+static void
+MMapVOpen(struct vm_area_struct* ps_vma)
+{
+    LinuxLockMutex(&g_sMMapMutex);
+
+    MMapVOpenNoLock(ps_vma);
+
+    LinuxUnLockMutex(&g_sMMapMutex);
+}
+
+
+static IMG_VOID
+MMapVCloseNoLock(struct vm_area_struct* ps_vma)
+{
+    PKV_OFFSET_STRUCT psOffsetStruct = (PKV_OFFSET_STRUCT)ps_vma->vm_private_data;
+    PVR_ASSERT(psOffsetStruct != IMG_NULL)
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    PVR_DPF((PVR_DBG_MESSAGE,
+             "%s: psLinuxMemArea %p, CpuVAddr %p ui32MMapOffset %d, ui32Mapped %d",
+             __FUNCTION__,
+             psOffsetStruct->psLinuxMemArea,
+             LinuxMemAreaToCpuVAddr(psOffsetStruct->psLinuxMemArea),
+             psOffsetStruct->ui32MMapOffset,
+             psOffsetStruct->ui32Mapped));
+#endif
+
+    PVR_ASSERT(!psOffsetStruct->bOnMMapList);
+    psOffsetStruct->ui32Mapped--;
+    if (psOffsetStruct->ui32Mapped == 0)
+    {
+        if (psOffsetStruct->ui32RefCount != 0)
+        {
+                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);
+    }
+
+    ps_vma->vm_private_data = NULL;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+    MOD_DEC_USE_COUNT;
+#endif
+}
+
+static void
+MMapVClose(struct vm_area_struct* ps_vma)
+{
+    LinuxLockMutex(&g_sMMapMutex);
+
+    MMapVCloseNoLock(ps_vma);
+
+    LinuxUnLockMutex(&g_sMMapMutex);
+}
+
+
+static struct vm_operations_struct MMapIOOps =
+{
+        .open=MMapVOpen,
+        .close=MMapVClose
+};
+
+
+int
+PVRMMap(struct file* pFile, struct vm_area_struct* ps_vma)
+{
+    IMG_UINT32 ui32ByteSize;
+    PKV_OFFSET_STRUCT psOffsetStruct;
+    int iRetVal = 0;
+
+    PVR_UNREFERENCED_PARAMETER(pFile);
+
+    LinuxLockMutex(&g_sMMapMutex);
+    
+    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 %d(0x%08x)",
+            __FUNCTION__,
+            ps_vma->vm_pgoff,
+            ui32ByteSize, ui32ByteSize));
+   
+    psOffsetStruct = FindOffsetStructByOffset(ps_vma->vm_pgoff, ui32ByteSize);
+    if (psOffsetStruct == IMG_NULL)
+    {
+#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 0x%lx",
+             __FUNCTION__, ps_vma->vm_pgoff));
+        iRetVal = -EINVAL;
+#endif
+        goto unlock_and_return;
+    }
+    list_del(&psOffsetStruct->sMMapItem);
+    psOffsetStruct->bOnMMapList = IMG_FALSE;
+
+    
+    if (((ps_vma->vm_flags & VM_WRITE) != 0) &&
+        ((ps_vma->vm_flags & VM_SHARED) == 0))
+    {
+        PVR_DPF((PVR_DBG_ERROR, "%s: Cannot mmap non-shareable writable areas", __FUNCTION__));
+        iRetVal = -EINVAL;
+        goto unlock_and_return;
+    }
+   
+    PVR_DPF((PVR_DBG_MESSAGE, "%s: Mapped psLinuxMemArea 0x%p\n",
+         __FUNCTION__, psOffsetStruct->psLinuxMemArea));
+
+    ps_vma->vm_flags |= VM_RESERVED;
+    ps_vma->vm_flags |= VM_IO;
+
+    
+    ps_vma->vm_flags |= VM_DONTEXPAND;
+    
+    
+    ps_vma->vm_flags |= VM_DONTCOPY;
+
+    ps_vma->vm_private_data = (void *)psOffsetStruct;
+    
+    switch(psOffsetStruct->psLinuxMemArea->ui32AreaFlags & PVRSRV_HAP_CACHETYPE_MASK)
+    {
+        case PVRSRV_HAP_CACHED:
+            
+            break;
+        case PVRSRV_HAP_WRITECOMBINE:
+            ps_vma->vm_page_prot = PGPROT_WC(ps_vma->vm_page_prot);
+            break;
+        case PVRSRV_HAP_UNCACHED:
+            ps_vma->vm_page_prot = PGPROT_UC(ps_vma->vm_page_prot);
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "%s: unknown cache type", __FUNCTION__));
+            iRetVal = -EINVAL;
+            goto unlock_and_return;
+    }
+    
+    
+    ps_vma->vm_ops = &MMapIOOps;
+    
+    if(!DoMapToUser(psOffsetStruct->psLinuxMemArea, ps_vma, 0))
+    {
+        iRetVal = -EAGAIN;
+        goto unlock_and_return;
+    }
+    
+    PVR_ASSERT(psOffsetStruct->ui32UserVAddr == 0)
+
+    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",
+             __FUNCTION__, ps_vma->vm_pgoff));
+    
+unlock_and_return:
+    if (iRetVal != 0 && psOffsetStruct != IMG_NULL)
+    {
+        DestroyOffsetStruct(psOffsetStruct);
+    }
+
+    LinuxUnLockMutex(&g_sMMapMutex);
+    
+    return iRetVal;
+}
+
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+
+static void ProcSeqStartstopMMapRegistations(struct seq_file *sfile,IMG_BOOL start) 
+{
+        if(start) 
+        {
+            LinuxLockMutex(&g_sMMapMutex);              
+        }
+        else
+        {
+            LinuxUnLockMutex(&g_sMMapMutex);
+        }
+}
+
+
+static void* ProcSeqOff2ElementMMapRegistrations(struct seq_file *sfile, loff_t off)
+{
+    LinuxMemArea *psLinuxMemArea;
+        if(!off) 
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+    list_for_each_entry(psLinuxMemArea, &g_sMMapAreaList, sMMapItem)
+    {
+        PKV_OFFSET_STRUCT psOffsetStruct;
+
+                list_for_each_entry(psOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+        {
+                off--;
+                if (off == 0)
+                {                               
+                                PVR_ASSERT(psOffsetStruct->psLinuxMemArea == psLinuxMemArea);
+                                return (void*)psOffsetStruct;
+                    }
+        }
+    }
+        return (void*)0;
+}
+
+static void* ProcSeqNextMMapRegistrations(struct seq_file *sfile,void* el,loff_t off)
+{
+        return ProcSeqOff2ElementMMapRegistrations(sfile,off);
+}
+
+
+static void ProcSeqShowMMapRegistrations(struct seq_file *sfile, void *el)
+{
+        KV_OFFSET_STRUCT *psOffsetStruct = (KV_OFFSET_STRUCT*)el;
+    LinuxMemArea *psLinuxMemArea;
+        IMG_UINT32 ui32RealByteSize;
+        IMG_UINT32 ui32ByteOffset;
+
+        if(el == PVR_PROC_SEQ_START_TOKEN) 
+        {
+        seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+                                                  "Allocations registered for mmap: %u\n"
+                          "In total these areas correspond to %u bytes\n"
+                          "psLinuxMemArea "
+                                                  "UserVAddr "
+                                                  "KernelVAddr "
+                                                  "CpuPAddr "
+                          "MMapOffset "
+                          "ByteLength "
+                          "LinuxMemType             "
+                                                  "Pid   Name     Flags\n",
+#else
+                          "<mmap_header>\n"
+                          "\t<count>%u</count>\n"
+                          "\t<bytes>%u</bytes>\n"
+                          "</mmap_header>\n",
+#endif
+                                                  g_ui32RegisteredAreas,
+                          g_ui32TotalByteSize
+                          );
+                return;
+        }
+
+        psLinuxMemArea = psOffsetStruct->psLinuxMemArea;
+
+        DetermineUsersSizeAndByteOffset(psLinuxMemArea,
+                                                                        &ui32RealByteSize,
+                                                                        &ui32ByteOffset);
+
+        seq_printf( sfile,
+#if !defined(DEBUG_LINUX_XML_PROC_FILES)
+                                                "%-8p       %08x %-8p %08x %08x   %-8d   %-24s %-5u %-8s %08x(%s)\n",
+#else
+                        "<mmap_record>\n"
+                                                "\t<pointer>%-8p</pointer>\n"
+                        "\t<user_virtual>%-8x</user_virtual>\n"
+                        "\t<kernel_virtual>%-8p</kernel_virtual>\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>%-5u</pid>\n"
+                        "\t<name>%-8s</name>\n"
+                        "\t<flags>%08x</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));
+}
+
+#endif
+
+
+PVRSRV_ERROR
+PVRMMapRegisterArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVRSRV_ERROR eError;
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
+    const IMG_CHAR *pszName = LinuxMemAreaTypeToString(LinuxMemAreaRootType(psLinuxMemArea));
+#endif
+
+    LinuxLockMutex(&g_sMMapMutex);
+
+#if defined(DEBUG) || defined(DEBUG_LINUX_MMAP_AREAS)
+    PVR_DPF((PVR_DBG_MESSAGE,
+             "%s(%s, psLinuxMemArea 0x%p, ui32AllocFlags 0x%8x)",
+             __FUNCTION__, pszName, psLinuxMemArea,  psLinuxMemArea->ui32AreaFlags));
+#endif
+
+    PVR_ASSERT(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC || LinuxMemAreaRoot(psLinuxMemArea)->eAreaType != LINUX_MEM_AREA_SUB_ALLOC);
+
+    
+    if(psLinuxMemArea->bMMapRegistered)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "%s: psLinuxMemArea 0x%p is already registered",
+                __FUNCTION__, psLinuxMemArea));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+        goto exit_unlock;
+    }
+
+    list_add_tail(&psLinuxMemArea->sMMapItem, &g_sMMapAreaList);
+
+    psLinuxMemArea->bMMapRegistered = IMG_TRUE;
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    g_ui32RegisteredAreas++;
+    
+    if (psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        g_ui32TotalByteSize += psLinuxMemArea->ui32ByteSize;
+    }
+#endif
+
+    eError = PVRSRV_OK;
+
+exit_unlock:
+    LinuxUnLockMutex(&g_sMMapMutex);
+
+    return eError;
+}
+
+
+PVRSRV_ERROR
+PVRMMapRemoveRegisteredArea(LinuxMemArea *psLinuxMemArea)
+{
+    PVRSRV_ERROR eError;
+    PKV_OFFSET_STRUCT psOffsetStruct, psTmpOffsetStruct;
+
+    LinuxLockMutex(&g_sMMapMutex);
+
+    PVR_ASSERT(psLinuxMemArea->bMMapRegistered);
+
+    list_for_each_entry_safe(psOffsetStruct, psTmpOffsetStruct, &psLinuxMemArea->sMMapOffsetStructList, sAreaItem)
+    {
+        if (psOffsetStruct->ui32Mapped != 0)
+        {
+             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
+        {
+              
+             PVR_DPF((PVR_DBG_WARNING, "%s: psOffsetStruct 0x%p was never mapped",  __FUNCTION__, psOffsetStruct));
+        }
+
+        PVR_ASSERT((psOffsetStruct->ui32Mapped == 0) && psOffsetStruct->bOnMMapList);
+
+        DestroyOffsetStruct(psOffsetStruct);
+    }
+
+    list_del(&psLinuxMemArea->sMMapItem);
+
+    psLinuxMemArea->bMMapRegistered = IMG_FALSE;
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    g_ui32RegisteredAreas--;
+    if (psLinuxMemArea->eAreaType != LINUX_MEM_AREA_SUB_ALLOC)
+    {
+        g_ui32TotalByteSize -= psLinuxMemArea->ui32ByteSize;
+    }
+#endif
+
+    eError = PVRSRV_OK;
+
+exit_unlock:
+    LinuxUnLockMutex(&g_sMMapMutex);
+    return eError;
+}
+
+
+PVRSRV_ERROR
+LinuxMMapPerProcessConnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc)
+{
+    PVR_UNREFERENCED_PARAMETER(psEnvPerProc);
+
+    return PVRSRV_OK;
+}
+
+IMG_VOID
+LinuxMMapPerProcessDisconnect(PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc)
+{
+    PKV_OFFSET_STRUCT psOffsetStruct, psTmpOffsetStruct;
+    IMG_BOOL bWarn = IMG_FALSE;
+    IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
+
+    PVR_UNREFERENCED_PARAMETER(psEnvPerProc);
+
+    LinuxLockMutex(&g_sMMapMutex);
+
+    list_for_each_entry_safe(psOffsetStruct, psTmpOffsetStruct, &g_sMMapOffsetStructList, sMMapItem)
+    {
+        if (psOffsetStruct->ui32PID == ui32PID)
+        {
+            if (!bWarn)
+            {
+                PVR_DPF((PVR_DBG_WARNING, "%s: process has unmapped offset structures. Removing them", __FUNCTION__));
+                bWarn = IMG_TRUE;
+            }
+            PVR_ASSERT(psOffsetStruct->ui32Mapped == 0);
+            PVR_ASSERT(psOffsetStruct->bOnMMapList);
+
+            DestroyOffsetStruct(psOffsetStruct);
+        }
+    }
+
+    LinuxUnLockMutex(&g_sMMapMutex);
+}
+
+
+PVRSRV_ERROR LinuxMMapPerProcessHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase)
+{
+    PVRSRV_ERROR eError;
+
+    eError = PVRSRVSetMaxHandle(psHandleBase, MAX_MMAP_HANDLE);
+    if (eError != PVRSRV_OK)
+    {
+        PVR_DPF((PVR_DBG_ERROR,"%s: failed to set handle limit (%d)", __FUNCTION__, eError));
+        return eError;
+    }
+
+    return eError;
+}
+
+
+IMG_VOID
+PVRMMapInit(IMG_VOID)
+{
+    LinuxInitMutex(&g_sMMapMutex);
+
+    g_psMemmapCache = KMemCacheCreateWrapper("img-mmap", sizeof(KV_OFFSET_STRUCT), 0, 0);
+    if (!g_psMemmapCache)
+    {
+        PVR_DPF((PVR_DBG_ERROR,"%s: failed to allocate kmem_cache", __FUNCTION__));
+        goto error;
+    }
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+        g_ProcMMap = CreateProcReadEntrySeq("mmap", NULL, 
+                                                  ProcSeqNextMMapRegistrations,
+                                                  ProcSeqShowMMapRegistrations,
+                                                  ProcSeqOff2ElementMMapRegistrations,
+                                                  ProcSeqStartstopMMapRegistations
+                                                 );
+#endif  
+    return;
+
+error:
+    PVRMMapCleanup();
+    return;
+}
+
+
+IMG_VOID
+PVRMMapCleanup(IMG_VOID)
+{
+    PVRSRV_ERROR eError;
+
+    if (!list_empty(&g_sMMapAreaList))
+    {
+        LinuxMemArea *psLinuxMemArea, *psTmpMemArea;
+
+        PVR_DPF((PVR_DBG_ERROR, "%s: Memory areas are still registered with MMap", __FUNCTION__));
+        
+        PVR_TRACE(("%s: Unregistering memory areas", __FUNCTION__));
+        list_for_each_entry_safe(psLinuxMemArea, psTmpMemArea, &g_sMMapAreaList, sMMapItem)
+        {
+                eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "%s: PVRMMapRemoveRegisteredArea failed (%d)", __FUNCTION__, eError));
+                }
+                PVR_ASSERT(eError == PVRSRV_OK);
+
+                LinuxMemAreaDeepFree(psLinuxMemArea);
+        }
+    }
+    PVR_ASSERT(list_empty((&g_sMMapAreaList)));
+
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    RemoveProcEntrySeq(g_ProcMMap);
+#endif 
+
+    if(g_psMemmapCache)
+    {
+        KMemCacheDestroyWrapper(g_psMemmapCache);
+        g_psMemmapCache = NULL;
+    }
+}
diff --git a/drivers/gpu/pvr/mmap.h b/drivers/gpu/pvr/mmap.h
new file mode 100644
index 00000000000..486154a241f
--- /dev/null
+++ b/drivers/gpu/pvr/mmap.h
@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * 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(__MMAP_H__)
+#define __MMAP_H__
+
+#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"
+
+typedef struct KV_OFFSET_STRUCT_TAG
+{
+    
+    IMG_UINT32                  ui32Mapped;
+
+    
+    IMG_UINT32                  ui32MMapOffset;
+    
+    IMG_UINT32                  ui32RealByteSize;
+
+    
+    LinuxMemArea                *psLinuxMemArea;
+    
+#if !defined(PVR_MAKE_ALL_PFNS_SPECIAL)
+    
+    IMG_UINT32                  ui32TID;
+#endif
+
+    
+    IMG_UINT32                  ui32PID;
+
+    
+    IMG_BOOL                    bOnMMapList;
+
+    
+    IMG_UINT32                  ui32RefCount;
+
+    
+    IMG_UINT32                  ui32UserVAddr;
+
+    
+#if defined(DEBUG_LINUX_MMAP_AREAS)
+    const IMG_CHAR              *pszName;
+#endif
+    
+   
+   struct list_head             sMMapItem;
+
+   
+   struct list_head             sAreaItem;
+}KV_OFFSET_STRUCT, *PKV_OFFSET_STRUCT;
+
+
+
+IMG_VOID PVRMMapInit(IMG_VOID);
+
+
+IMG_VOID PVRMMapCleanup(IMG_VOID);
+
+
+PVRSRV_ERROR PVRMMapRegisterArea(LinuxMemArea *psLinuxMemArea);
+
+
+PVRSRV_ERROR PVRMMapRemoveRegisteredArea(LinuxMemArea *psLinuxMemArea);
+
+
+PVRSRV_ERROR PVRMMapOSMemHandleToMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                             IMG_HANDLE hMHandle,
+                                             IMG_UINT32 *pui32MMapOffset,
+                                             IMG_UINT32 *pui32ByteOffset,
+                                             IMG_UINT32 *pui32RealByteSize,                                                  IMG_UINT32 *pui32UserVAddr);
+
+PVRSRV_ERROR
+PVRMMapReleaseMMapData(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                IMG_HANDLE hMHandle,
+                                IMG_BOOL *pbMUnmap,
+                                IMG_UINT32 *pui32RealByteSize,
+                                IMG_UINT32 *pui32UserVAddr);
+
+int PVRMMap(struct file* pFile, struct vm_area_struct* ps_vma);
+
+
+#endif  
+
diff --git a/drivers/gpu/pvr/module.c b/drivers/gpu/pvr/module.c
new file mode 100644
index 00000000000..43a3a27adae
--- /dev/null
+++ b/drivers/gpu/pvr/module.c
@@ -0,0 +1,744 @@
+/**********************************************************************
+ *
+ * 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
+
+#if !defined(SUPPORT_DRI_DRM)
+        
+        #if defined(LDM_PLATFORM)
+                #define PVR_LDM_PLATFORM_MODULE
+                #define PVR_LDM_MODULE
+        #else
+                #if defined(LDM_PCI)
+                        #define PVR_LDM_PCI_MODULE
+                        #define PVR_LDM_MODULE
+                #endif
+        #endif
+#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>
+
+#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/platform_device.h>
+#endif 
+
+#if defined(PVR_LDM_PCI_MODULE)
+#include <linux/pci.h>
+#endif 
+
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+#include <asm/uaccess.h>
+#endif
+
+#include "img_defs.h"
+#include "services.h"
+#include "kerneldisplay.h"
+#include "kernelbuffer.h"
+#include "syscommon.h"
+#include "pvrmmap.h"
+#include "mutils.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 "proc.h"
+#include "pvrmodule.h"
+#include "private_data.h"
+#include "lock.h"
+#include "linkage.h"
+
+#if defined(SUPPORT_DRI_DRM)
+#include "pvr_drm.h"
+#endif
+#define DRVNAME         PVRSRV_MODNAME
+#define DEVNAME         PVRSRV_MODNAME
+
+#if defined(SUPPORT_DRI_DRM)
+#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
+#else
+#define PRIVATE_DATA(pFile) ((pFile)->private_data)
+#endif
+
+MODULE_SUPPORTED_DEVICE(DEVNAME);
+
+#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 
+
+ 
+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 IMG_INT PVRSRVOpen(struct inode* pInode, struct file* pFile);
+static IMG_INT PVRSRVRelease(struct inode* pInode, struct file* pFile);
+
+static struct file_operations pvrsrv_fops =
+{
+        .owner=THIS_MODULE,
+         
+        .unlocked_ioctl=(IMG_VOID*)PVRSRV_BridgeDispatchKM,
+        .open=PVRSRVOpen,
+        .release=PVRSRVRelease,
+        .mmap=PVRMMap,
+};
+#endif
+
+PVRSRV_LINUX_MUTEX gPVRSRVLock;
+
+IMG_UINT32 gui32ReleasePID;
+
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+static IMG_UINT32 gPVRPowerLevel;
+#endif
+
+#if defined(PVR_LDM_MODULE)
+
+#if defined(PVR_LDM_PLATFORM_MODULE)
+#define LDM_DEV struct platform_device
+#define LDM_DRV struct platform_driver
+#endif 
+
+#if defined(PVR_LDM_PCI_MODULE)
+#define LDM_DEV struct pci_dev
+#define LDM_DRV struct pci_driver
+#endif 
+
+#if defined(PVR_LDM_PLATFORM_MODULE)
+static IMG_INT PVRSRVDriverRemove(LDM_DEV *device);
+static IMG_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);
+#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);
+
+#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) },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(pci, powervr_id_table);
+#endif
+
+static LDM_DRV powervr_driver = {
+#if defined(PVR_LDM_PLATFORM_MODULE)
+        .driver = {
+                .name           = DRVNAME,
+        },
+#endif
+#if defined(PVR_LDM_PCI_MODULE)
+        .name           = DRVNAME,
+        .id_table = powervr_id_table,
+#endif
+        .probe          = PVRSRVDriverProbe,
+#if defined(PVR_LDM_PLATFORM_MODULE)
+        .remove         = PVRSRVDriverRemove,
+#endif
+#if defined(PVR_LDM_PCI_MODULE)
+        .remove         = __devexit_p(PVRSRVDriverRemove),
+#endif
+        .suspend        = PVRSRVDriverSuspend,
+        .resume         = PVRSRVDriverResume,
+        .shutdown       = PVRSRVDriverShutdown,
+};
+
+LDM_DEV *gpsPVRLDMDev;
+
+#if defined(MODULE) && defined(PVR_LDM_PLATFORM_MODULE)
+
+static IMG_VOID PVRSRVDeviceRelease(struct device *pDevice)
+{
+        PVR_UNREFERENCED_PARAMETER(pDevice);
+}
+
+static struct platform_device powervr_device = {
+        .name                   = DEVNAME,
+        .id                             = -1,
+        .dev                    = {
+                .release        = PVRSRVDeviceRelease
+        }
+};
+
+#endif 
+
+#if defined(PVR_LDM_PLATFORM_MODULE)
+static IMG_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)
+#endif
+{
+        SYS_DATA *psSysData;
+
+        PVR_TRACE(("PVRSRVDriverProbe(pDevice=%p)", pDevice));
+
+#if 0
+        
+        if (PerDeviceSysInitialise((IMG_PVOID)pDevice) != PVRSRV_OK)
+        {
+                return -EINVAL;
+        }
+#endif  
+        
+        psSysData = SysAcquireDataNoCheck();
+        if ( psSysData == IMG_NULL)
+        {
+                gpsPVRLDMDev = pDevice;
+
+                if (SysInitialise() != PVRSRV_OK)
+                {
+                        return -ENODEV;
+                }
+        }
+
+        return 0;
+}
+
+
+#if defined (PVR_LDM_PLATFORM_MODULE)
+static IMG_INT PVRSRVDriverRemove(LDM_DEV *pDevice)
+#endif
+#if defined(PVR_LDM_PCI_MODULE)
+static IMG_VOID __devexit PVRSRVDriverRemove(LDM_DEV *pDevice)
+#endif
+{
+        SYS_DATA *psSysData;
+
+        PVR_TRACE(("PVRSRVDriverRemove(pDevice=%p)", pDevice));
+
+        SysAcquireData(&psSysData);
+        
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+        if (gPVRPowerLevel != 0)
+        {
+                if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
+                {
+                        gPVRPowerLevel = 0;
+                }
+        }
+#endif
+        (IMG_VOID)SysDeinitialise(psSysData);
+
+        gpsPVRLDMDev = IMG_NULL;
+
+#if 0
+        if (PerDeviceSysDeInitialise((IMG_PVOID)pDevice) != PVRSRV_OK)
+        {
+                return -EINVAL;
+        }
+#endif
+
+#if defined (PVR_LDM_PLATFORM_MODULE)
+        return 0;
+#endif
+#if defined (PVR_LDM_PCI_MODULE)
+        return;
+#endif
+}
+
+
+static IMG_VOID PVRSRVDriverShutdown(LDM_DEV *pDevice)
+{
+        PVR_TRACE(("PVRSRVDriverShutdown(pDevice=%p)", pDevice));
+
+        (IMG_VOID) PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3);
+}
+
+#endif 
+
+
+#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)
+#else
+static IMG_INT PVRSRVDriverSuspend(LDM_DEV *pDevice, pm_message_t state)
+#endif
+{
+#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)
+        {
+                return -EINVAL;
+        }
+#endif
+        return 0;
+}
+
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVDriverResume(struct drm_device *pDevice)
+#else
+static IMG_INT PVRSRVDriverResume(LDM_DEV *pDevice)
+#endif
+{
+#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)
+        {
+                return -EINVAL;
+        }
+#endif
+        return 0;
+}
+#endif 
+
+
+#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];
+        IMG_UINT32 PVRPowerLevel;
+
+        if (count != sizeof(data_buffer))
+        {
+                return -EINVAL;
+        }
+        else
+        {
+                if (copy_from_user(data_buffer, buffer, count))
+                        return -EINVAL;
+                if (data_buffer[count - 1] != '\n')
+                        return -EINVAL;
+                PVRPowerLevel = data_buffer[0] - '0';
+                if (PVRPowerLevel != gPVRPowerLevel)
+                {
+                        if (PVRPowerLevel != 0)
+                        {
+                                if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D3) != PVRSRV_OK)
+                                {
+                                        return -EINVAL;
+                                }
+                        }
+                        else
+                        {
+                                if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) != PVRSRV_OK)
+                                {
+                                        return -EINVAL;
+                                }
+                        }
+
+                        gPVRPowerLevel = PVRPowerLevel;
+                }
+        }
+        return (count);
+}
+
+void ProcSeqShowPowerLevel(struct seq_file *sfile,void* el)     
+{
+        seq_printf(sfile, "%lu\n", gPVRPowerLevel);
+}
+
+#endif
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVOpen(struct drm_device unref__ *dev, struct drm_file *pFile)
+#else
+static IMG_INT PVRSRVOpen(struct inode unref__ * pInode, struct file *pFile)
+#endif
+{
+        PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
+        IMG_HANDLE hBlockAlloc;
+        IMG_INT iRet = -ENOMEM;
+        PVRSRV_ERROR eError;
+        IMG_UINT32 ui32PID;
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+        PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
+#endif
+
+#if defined(SUPPORT_DRI_DRM)
+        PVR_UNREFERENCED_PARAMETER(dev);
+#else
+        PVR_UNREFERENCED_PARAMETER(pInode);
+#endif
+
+        LinuxLockMutex(&gPVRSRVLock);
+
+        ui32PID = OSGetCurrentProcessIDKM();
+
+        if (PVRSRVProcessConnect(ui32PID) != 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,
+                                                &hBlockAlloc,
+                                                "File Private Data");
+
+        if(eError != PVRSRV_OK)
+                goto err_unlock;
+
+#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;
+        PRIVATE_DATA(pFile) = psPrivateData;
+        iRet = 0;
+err_unlock:     
+        LinuxUnLockMutex(&gPVRSRVLock);
+        return iRet;
+}
+
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRSRVRelease(struct drm_device unref__ *dev, struct drm_file *pFile)
+#else
+static IMG_INT PVRSRVRelease(struct inode unref__ * pInode, struct file *pFile)
+#endif
+{
+        PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
+
+#if defined(SUPPORT_DRI_DRM)
+        PVR_UNREFERENCED_PARAMETER(dev);
+#else
+        PVR_UNREFERENCED_PARAMETER(pInode);
+#endif
+
+        LinuxLockMutex(&gPVRSRVLock);
+
+        psPrivateData = PRIVATE_DATA(pFile);
+
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+        list_del(&psPrivateData->sDRMAuthListItem);
+#endif
+
+        
+        gui32ReleasePID = psPrivateData->ui32OpenPID;
+        PVRSRVProcessDisconnect(psPrivateData->ui32OpenPID);
+        gui32ReleasePID = 0;
+
+        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                          sizeof(PVRSRV_FILE_PRIVATE_DATA),
+                          psPrivateData, psPrivateData->hBlockAlloc);
+
+        PRIVATE_DATA(pFile) = NULL; 
+
+        LinuxUnLockMutex(&gPVRSRVLock);
+        return 0;
+}
+
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT PVRCore_Init(IMG_VOID)
+#else
+static IMG_INT __init PVRCore_Init(IMG_VOID)
+#endif
+{
+        IMG_INT error;
+#if !defined(PVR_LDM_MODULE)
+        PVRSRV_ERROR eError;
+#else
+        struct device *psDev;
+#endif
+
+#if !defined(SUPPORT_DRI_DRM)
+        
+        PVRDPFInit();
+#endif
+        PVR_TRACE(("PVRCore_Init"));
+
+        LinuxInitMutex(&gPVRSRVLock);
+
+        if (CreateProcEntries ())
+        {
+                error = -ENOMEM;
+                return error;
+        }
+
+        if (PVROSFuncInit() != PVRSRV_OK)
+        {
+                error = -ENOMEM;
+                goto init_failed;
+        }
+
+        PVRLinuxMUtilsInit();
+
+        if(LinuxMMInit() != PVRSRV_OK)
+        {
+                error = -ENOMEM;
+                goto init_failed;
+        }
+
+        LinuxBridgeInit();
+
+        PVRMMapInit();
+
+#if defined(PVR_LDM_MODULE)
+
+#if defined(PVR_LDM_PLATFORM_MODULE)
+        if ((error = platform_driver_register(&powervr_driver)) != 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to register platform driver (%d)", error));
+
+                goto init_failed;
+        }
+
+#if defined(MODULE)
+        if ((error = platform_device_register(&powervr_device)) != 0)
+        {
+                platform_driver_unregister(&powervr_driver);
+
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to register platform device (%d)", error));
+
+                goto init_failed;
+        }
+#endif
+#endif 
+
+#if defined(PVR_LDM_PCI_MODULE)
+        if ((error = pci_register_driver(&powervr_driver)) != 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to register PCI driver (%d)", error));
+
+                goto init_failed;
+        }
+#endif 
+
+#else 
+        
+        if ((eError = SysInitialise()) != PVRSRV_OK)
+        {
+                error = -ENODEV;
+#if defined(TCF_REV) && (TCF_REV == 110)
+                if(eError == PVRSRV_ERROR_NOT_SUPPORTED)
+                {
+                        printk("\nAtlas wrapper (FPGA image) version mismatch");
+                        error = -ENODEV;
+                }
+#endif
+                goto init_failed;
+        }
+#endif 
+
+#if !defined(SUPPORT_DRI_DRM)
+        AssignedMajorNumber = register_chrdev(0, DEVNAME, &pvrsrv_fops);
+
+        if (AssignedMajorNumber <= 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to get major number"));
+
+                error = -EBUSY;
+                goto sys_deinit;
+        }
+
+        PVR_TRACE(("PVRCore_Init: major device %d", AssignedMajorNumber));
+#endif 
+
+#if defined(PVR_LDM_MODULE)
+        
+        psPvrClass = class_create(THIS_MODULE, "pvr");
+
+        if (IS_ERR(psPvrClass))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to create class (%ld)", PTR_ERR(psPvrClass)));
+                error = -EBUSY;
+                goto unregister_device;
+        }
+
+        psDev = device_create(psPvrClass, NULL, MKDEV(AssignedMajorNumber, 0),
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26))
+                                  NULL,
+#endif 
+                                  DEVNAME);
+        if (IS_ERR(psDev))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRCore_Init: unable to create device (%ld)", PTR_ERR(psDev)));
+                error = -EBUSY;
+                goto destroy_class;
+        }
+#endif 
+
+        return 0;
+
+#if defined(PVR_LDM_MODULE)
+destroy_class:
+        class_destroy(psPvrClass);
+unregister_device:
+        unregister_chrdev((IMG_UINT)AssignedMajorNumber, DRVNAME);
+#endif
+#if !defined(SUPPORT_DRI_DRM)
+sys_deinit:
+#endif
+#if defined(PVR_LDM_MODULE)
+#if defined(PVR_LDM_PCI_MODULE)
+        pci_unregister_driver(&powervr_driver);
+#endif
+
+#if defined (PVR_LDM_PLATFORM_MODULE)
+#if defined (MODULE)
+        platform_device_unregister(&powervr_device);
+#endif
+        platform_driver_unregister(&powervr_driver);
+#endif
+
+#else   
+        
+        {
+                SYS_DATA *psSysData;
+
+                psSysData = SysAcquireDataNoCheck();
+                if (psSysData != IMG_NULL)
+                {
+                        (IMG_VOID)SysDeinitialise(psSysData);
+                }
+        }
+#endif  
+init_failed:
+        PVRMMapCleanup();
+        LinuxMMCleanup();
+        LinuxBridgeDeInit();
+        PVROSFuncDeInit();
+        RemoveProcEntries();
+
+        return error;
+
+} 
+
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_VOID PVRCore_Cleanup(IMG_VOID)
+#else
+static IMG_VOID __exit PVRCore_Cleanup(IMG_VOID)
+#endif
+{
+        SYS_DATA *psSysData;
+
+        PVR_TRACE(("PVRCore_Cleanup"));
+
+        SysAcquireData(&psSysData);
+
+#if defined(PVR_LDM_MODULE)
+        device_destroy(psPvrClass, MKDEV(AssignedMajorNumber, 0));
+        class_destroy(psPvrClass);
+#endif
+
+#if !defined(SUPPORT_DRI_DRM)
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22))
+        if (
+#endif  
+                unregister_chrdev((IMG_UINT)AssignedMajorNumber, DRVNAME)
+#if !(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22))
+                                                                ;
+#else   
+                                                                )
+        {
+                PVR_DPF((PVR_DBG_ERROR," can't unregister device major %d", AssignedMajorNumber));
+        }
+#endif  
+#endif  
+
+#if defined(PVR_LDM_MODULE)
+
+#if defined(PVR_LDM_PCI_MODULE)
+        pci_unregister_driver(&powervr_driver);
+#endif
+
+#if defined (PVR_LDM_PLATFORM_MODULE)
+#if defined (MODULE)
+        platform_device_unregister(&powervr_device);
+#endif
+        platform_driver_unregister(&powervr_driver);
+#endif
+
+#else 
+#if defined(DEBUG) && defined(PVR_MANUAL_POWER_CONTROL)
+        if (gPVRPowerLevel != 0)
+        {
+                if (PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE_D0) == PVRSRV_OK)
+                {
+                        gPVRPowerLevel = 0;
+                }
+        }
+#endif
+        
+        (IMG_VOID)SysDeinitialise(psSysData);
+#endif 
+
+        PVRMMapCleanup();
+
+        LinuxMMCleanup();
+
+        LinuxBridgeDeInit();
+
+        PVROSFuncDeInit();
+
+        RemoveProcEntries();
+
+        PVR_TRACE(("PVRCore_Cleanup: unloading"));
+}
+
+#if !defined(SUPPORT_DRI_DRM)
+module_init(PVRCore_Init);
+module_exit(PVRCore_Cleanup);
+#endif
diff --git a/drivers/gpu/pvr/mutex.c b/drivers/gpu/pvr/mutex.c
new file mode 100644
index 00000000000..09963ad9f00
--- /dev/null
+++ b/drivers/gpu/pvr/mutex.c
@@ -0,0 +1,136 @@
+/**********************************************************************
+ *
+ * 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/errno.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
+#include <linux/mutex.h>
+#else
+#include <asm/semaphore.h>
+#endif
+#include <linux/module.h>
+
+#include <img_defs.h>
+#include <services.h>
+
+#include "mutex.h"
+
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
+
+IMG_VOID LinuxInitMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    mutex_init(psPVRSRVMutex);
+}
+
+IMG_VOID LinuxLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    mutex_lock(psPVRSRVMutex);
+}
+
+PVRSRV_ERROR LinuxLockMutexInterruptible(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    if(mutex_lock_interruptible(psPVRSRVMutex) == -EINTR)
+    {
+        return PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR;
+    }
+    else
+    {
+        return PVRSRV_OK;
+    }
+}
+
+IMG_INT32 LinuxTryLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    return mutex_trylock(psPVRSRVMutex);
+}
+
+IMG_VOID LinuxUnLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    mutex_unlock(psPVRSRVMutex);
+}
+
+IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    return (mutex_is_locked(psPVRSRVMutex)) ? IMG_TRUE : IMG_FALSE;
+}
+
+
+#else 
+
+
+IMG_VOID LinuxInitMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    init_MUTEX(&psPVRSRVMutex->sSemaphore);
+    atomic_set(&psPVRSRVMutex->Count, 0);
+}
+
+IMG_VOID LinuxLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    down(&psPVRSRVMutex->sSemaphore);
+    atomic_dec(&psPVRSRVMutex->Count);
+}
+
+PVRSRV_ERROR LinuxLockMutexInterruptible(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    if(down_interruptible(&psPVRSRVMutex->sSemaphore) == -EINTR)
+    {
+        
+        return PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR;
+    }else{
+        atomic_dec(&psPVRSRVMutex->Count);
+        return PVRSRV_OK;
+    }
+}
+
+IMG_INT32 LinuxTryLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    IMG_INT32 Status = down_trylock(&psPVRSRVMutex->sSemaphore);
+    if(Status == 0)
+    {
+        atomic_dec(&psPVRSRVMutex->Count);
+    }
+
+    return Status;
+}
+
+IMG_VOID LinuxUnLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    atomic_inc(&psPVRSRVMutex->Count);
+    up(&psPVRSRVMutex->sSemaphore);
+}
+
+IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex)
+{
+    IMG_INT32 iCount;
+    
+    iCount = atomic_read(&psPVRSRVMutex->Count);
+
+    return (IMG_BOOL)iCount;
+}
+
+#endif 
+
diff --git a/drivers/gpu/pvr/mutex.h b/drivers/gpu/pvr/mutex.h
new file mode 100644
index 00000000000..b24a5990f8f
--- /dev/null
+++ b/drivers/gpu/pvr/mutex.h
@@ -0,0 +1,70 @@
+/**********************************************************************
+ *
+ * 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 __INCLUDED_LINUX_MUTEX_H_
+#define __INCLUDED_LINUX_MUTEX_H_
+
+#include <linux/version.h>
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
+#include <linux/mutex.h>
+#else
+#include <asm/semaphore.h>
+#endif
+
+
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15))
+
+typedef struct mutex PVRSRV_LINUX_MUTEX;
+
+#else 
+
+
+typedef struct {
+    struct semaphore sSemaphore;
+    
+    atomic_t Count;
+}PVRSRV_LINUX_MUTEX;
+
+#endif
+
+
+extern IMG_VOID LinuxInitMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+extern IMG_VOID LinuxLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+extern PVRSRV_ERROR LinuxLockMutexInterruptible(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+extern IMG_INT32 LinuxTryLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+extern IMG_VOID LinuxUnLockMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+extern IMG_BOOL LinuxIsLockedMutex(PVRSRV_LINUX_MUTEX *psPVRSRVMutex);
+
+
+#endif 
+
diff --git a/drivers/gpu/pvr/mutils.c b/drivers/gpu/pvr/mutils.c
new file mode 100644
index 00000000000..83eab51bb1d
--- /dev/null
+++ b/drivers/gpu/pvr/mutils.c
@@ -0,0 +1,133 @@
+/**********************************************************************
+ *
+ * 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/spinlock.h>
+#include <linux/mm.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+
+#include "img_defs.h"
+#include "pvr_debug.h"
+#include "mutils.h"
+
+#if defined(SUPPORT_LINUX_X86_PAT)
+#define PAT_LINUX_X86_WC        1
+
+#define PAT_X86_ENTRY_BITS      8
+
+#define PAT_X86_BIT_PWT         1U
+#define PAT_X86_BIT_PCD         2U
+#define PAT_X86_BIT_PAT         4U
+#define PAT_X86_BIT_MASK        (PAT_X86_BIT_PAT | PAT_X86_BIT_PCD | PAT_X86_BIT_PWT)
+
+static IMG_BOOL g_write_combining_available = IMG_FALSE;
+
+#define PROT_TO_PAT_INDEX(v, B) ((v & _PAGE_ ## B) ? PAT_X86_BIT_ ## B : 0)
+
+static inline IMG_UINT
+pvr_pat_index(pgprotval_t prot_val)
+{
+        IMG_UINT ret = 0;
+        pgprotval_t val = prot_val & _PAGE_CACHE_MASK;
+
+        ret |= PROT_TO_PAT_INDEX(val, PAT);
+        ret |= PROT_TO_PAT_INDEX(val, PCD);
+        ret |= PROT_TO_PAT_INDEX(val, PWT);
+
+        return ret;
+}
+
+static inline IMG_UINT
+pvr_pat_entry(u64 pat, IMG_UINT index)
+{
+        return (IMG_UINT)(pat >> (index * PAT_X86_ENTRY_BITS)) & PAT_X86_BIT_MASK;
+}
+
+static IMG_VOID
+PVRLinuxX86PATProbe(IMG_VOID)
+{
+        
+        if (cpu_has_pat)         
+        {
+                u64 pat;
+                IMG_UINT pat_index;
+                IMG_UINT pat_entry;
+
+                PVR_TRACE(("%s: PAT available", __FUNCTION__));
+                
+                rdmsrl(MSR_IA32_CR_PAT, pat);
+                PVR_TRACE(("%s: Top 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat >> 32)));
+                PVR_TRACE(("%s: Bottom 32 bits of PAT: 0x%.8x", __FUNCTION__, (IMG_UINT)(pat)));
+
+                pat_index = pvr_pat_index(_PAGE_CACHE_WC);
+                PVR_TRACE(("%s: PAT index for write combining: %u", __FUNCTION__, pat_index));
+
+                pat_entry = pvr_pat_entry(pat, pat_index);
+                PVR_TRACE(("%s: PAT entry for write combining: 0x%.2x (should be 0x%.2x)", __FUNCTION__, pat_entry, PAT_LINUX_X86_WC));
+
+#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)
+                g_write_combining_available = (IMG_BOOL)(pat_entry == PAT_LINUX_X86_WC);
+#endif
+        }
+#if defined(DEBUG)
+#if defined(SUPPORT_LINUX_X86_WRITECOMBINE)
+        if (g_write_combining_available)
+        {
+                PVR_TRACE(("%s: Write combining available via PAT", __FUNCTION__));
+        }
+        else
+        {
+                PVR_TRACE(("%s: Write combining not available", __FUNCTION__));
+        }
+#else   
+        PVR_TRACE(("%s: Write combining disabled in driver build", __FUNCTION__));
+#endif  
+#endif  
+}
+
+pgprot_t
+pvr_pgprot_writecombine(pgprot_t prot)
+{
+    
+     
+    return (g_write_combining_available) ?
+                __pgprot((pgprot_val(prot) & ~_PAGE_CACHE_MASK) | _PAGE_CACHE_WC) : pgprot_noncached(prot);
+}
+#endif  
+
+IMG_VOID
+PVRLinuxMUtilsInit(IMG_VOID)
+{
+#if defined(SUPPORT_LINUX_X86_PAT)
+        PVRLinuxX86PATProbe();
+#endif
+}
+
diff --git a/drivers/gpu/pvr/mutils.h b/drivers/gpu/pvr/mutils.h
new file mode 100644
index 00000000000..943c2bd80a3
--- /dev/null
+++ b/drivers/gpu/pvr/mutils.h
@@ -0,0 +1,101 @@
+/**********************************************************************
+ *
+ * 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 __IMG_LINUX_MUTILS_H__
+#define __IMG_LINUX_MUTILS_H__
+
+#ifndef AUTOCONF_INCLUDED
+#include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+
+#if !(defined(__i386__) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)))
+#if defined(SUPPORT_LINUX_X86_PAT)
+#undef SUPPORT_LINUX_X86_PAT
+#endif
+#endif
+
+#if defined(SUPPORT_LINUX_X86_PAT)
+        pgprot_t pvr_pgprot_writecombine(pgprot_t prot);
+        #define PGPROT_WC(pv)   pvr_pgprot_writecombine(pv)
+#else
+        #if defined(__arm__) || defined(__sh__)
+                #define PGPROT_WC(pv)   pgprot_writecombine(pv)
+        #else
+                #if defined(__i386__)
+                        #define PGPROT_WC(pv)   pgprot_noncached(pv)
+                #else
+                        #define PGPROT_WC(pv)   pgprot_noncached(pv)
+                        #error  Unsupported architecture!
+                #endif
+        #endif
+#endif
+
+#define PGPROT_UC(pv)   pgprot_noncached(pv)
+
+#if defined(__i386__) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
+        #define IOREMAP(pa, bytes)      ioremap_cache(pa, bytes)
+#else   
+        #if defined(__arm__) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+                #define IOREMAP(pa, bytes)      ioremap_cached(pa, bytes)
+        #else
+                #define IOREMAP(pa, bytes)      ioremap(pa, bytes)
+        #endif
+#endif
+
+#if defined(SUPPORT_LINUX_X86_PAT)
+        #if defined(SUPPORT_LINUX_X86_WRITECOMBINE)
+                #define IOREMAP_WC(pa, bytes) ioremap_wc(pa, bytes)
+        #else
+                #define IOREMAP_WC(pa, bytes) ioremap_nocache(pa, bytes)
+        #endif
+#else
+        #if defined(__arm__)
+                #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27))
+                        #define IOREMAP_WC(pa, bytes) ioremap_wc(pa, bytes)
+                #else
+                        #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+                                #define IOREMAP_WC(pa, bytes)   ioremap_nocache(pa, bytes)
+                        #else
+                                #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17))
+                                        #define IOREMAP_WC(pa, bytes)   __ioremap(pa, bytes, L_PTE_BUFFERABLE)
+                                #else
+                                        #define IOREMAP_WC(pa, bytes)   __ioremap(pa, bytes, , L_PTE_BUFFERABLE, 1)
+                                #endif
+                        #endif
+                #endif
+        #else
+                #define IOREMAP_WC(pa, bytes)   ioremap_nocache(pa, bytes)
+        #endif
+#endif
+
+#define IOREMAP_UC(pa, bytes)   ioremap_nocache(pa, bytes)
+
+IMG_VOID PVRLinuxMUtilsInit(IMG_VOID);
+
+#endif 
+
diff --git a/drivers/gpu/pvr/ocpdefs.h b/drivers/gpu/pvr/ocpdefs.h
new file mode 100644
index 00000000000..43744e3448f
--- /dev/null
+++ b/drivers/gpu/pvr/ocpdefs.h
@@ -0,0 +1,271 @@
+/**********************************************************************
+ *
+ * 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 
+
diff --git a/drivers/gpu/pvr/omap3/oemfuncs.h b/drivers/gpu/pvr/omap3/oemfuncs.h
new file mode 100644
index 00000000000..d28356463cf
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/oemfuncs.h
@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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
+
diff --git a/drivers/gpu/pvr/omap3/sysconfig.c b/drivers/gpu/pvr/omap3/sysconfig.c
new file mode 100644
index 00000000000..00520992b93
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/sysconfig.c
@@ -0,0 +1,970 @@
+/**********************************************************************
+ *
+ * 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;
+}
diff --git a/drivers/gpu/pvr/omap3/sysconfig.h b/drivers/gpu/pvr/omap3/sysconfig.h
new file mode 100644
index 00000000000..dd8a07d988d
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/sysconfig.h
@@ -0,0 +1,59 @@
+/**********************************************************************
+ *
+ * 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           0x4000
+
+#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
diff --git a/drivers/gpu/pvr/omap3/sysinfo.h b/drivers/gpu/pvr/omap3/sysinfo.h
new file mode 100644
index 00000000000..07718276b8d
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/sysinfo.h
@@ -0,0 +1,40 @@
+/**********************************************************************
+ *
+ * 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
diff --git a/drivers/gpu/pvr/omap3/syslocal.h b/drivers/gpu/pvr/omap3/syslocal.h
new file mode 100644
index 00000000000..351ed695275
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/syslocal.h
@@ -0,0 +1,135 @@
+/**********************************************************************
+ *
+ * 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
+
+
diff --git a/drivers/gpu/pvr/omap3/sysutils.c b/drivers/gpu/pvr/omap3/sysutils.c
new file mode 100644
index 00000000000..d2c4231315c
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/sysutils.c
@@ -0,0 +1,33 @@
+/**********************************************************************
+ *
+ * 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
diff --git a/drivers/gpu/pvr/omap3/sysutils_linux_wqueue_compat.c b/drivers/gpu/pvr/omap3/sysutils_linux_wqueue_compat.c
new file mode 100644
index 00000000000..93c5b7c5b3a
--- /dev/null
+++ b/drivers/gpu/pvr/omap3/sysutils_linux_wqueue_compat.c
@@ -0,0 +1,489 @@
+/**********************************************************************
+ *
+ * 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 <linux/platform_device.h>
+#include <plat/omap-pm.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
+
+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 defined(SGX530) && (SGX_CORE_REV == 125)
+        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
+        return PVRSRV_OK;
+}
+
+static IMG_VOID PowerLockWrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+        if (!in_interrupt())
+        {
+                BUG_ON(in_atomic());
+                mutex_lock(&psSysSpecData->sPowerLock);
+
+        }
+}
+
+static IMG_VOID PowerLockUnwrap(SYS_SPECIFIC_DATA *psSysSpecData)
+{
+        if (!in_interrupt())
+        {
+                BUG_ON(in_atomic());
+                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
+
+        ForceMaxSGXClocks(psSysSpecData);
+
+        atomic_set(&psSysSpecData->sSGXClocksEnabled, 1);
+
+#else   /* !defined(NO_HARDWARE) */
+        PVR_UNREFERENCED_PARAMETER(psSysData);
+#endif  /* !defined(NO_HARDWARE) */
+        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);
+        }
+
+        omap_pm_set_min_bus_tput(&gpsPVRLDMDev->dev, OCP_INITIATOR_AGENT, 0);
+
+        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
+}
diff --git a/drivers/gpu/pvr/omap4/oemfuncs.h b/drivers/gpu/pvr/omap4/oemfuncs.h
new file mode 100644
index 00000000000..d28356463cf
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/oemfuncs.h
@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * 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
+
diff --git a/drivers/gpu/pvr/omap4/sysconfig.c b/drivers/gpu/pvr/omap4/sysconfig.c
new file mode 100644
index 00000000000..3b4955445b7
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/sysconfig.c
@@ -0,0 +1,978 @@
+/**********************************************************************
+ *
+ * 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(SGX540)
+#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_OMAP4430_OCP_REGS_SYS_PHYS_BASE             (SYS_OMAP4430_SGX_REGS_SYS_PHYS_BASE + EUR_CR_OCP_REVISION)
+#define SYS_OMAP4430_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_OMAP4430_SGX_REGS_SIZE,
+                                                                         &gsSGXRegsCPUVAddr,
+                                                                         &sCpuPAddr);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+        gsSGXDeviceMap.sRegsCpuPBase = sCpuPAddr;
+        gsSGXDeviceMap.sRegsSysPBase = SysCpuPAddrToSysPAddr(gsSGXDeviceMap.sRegsCpuPBase);
+        gsSGXDeviceMap.ui32RegsSize = SYS_OMAP4430_SGX_REGS_SIZE;
+#if defined(__linux__)
+
+        gsSGXDeviceMap.pvRegsCpuVBase = gsSGXRegsCPUVAddr;
+#else
+
+        gsSGXDeviceMap.pvRegsCpuVBase = IMG_NULL;
+#endif
+
+        OSMemSet(gsSGXRegsCPUVAddr, 0, SYS_OMAP4430_SGX_REGS_SIZE);
+
+
+
+
+        gsSGXDeviceMap.ui32IRQ = 0;
+
+#else
+
+        gsSGXDeviceMap.sRegsSysPBase.uiAddr = SYS_OMAP4430_SGX_REGS_SYS_PHYS_BASE;
+        gsSGXDeviceMap.sRegsCpuPBase = SysSysPAddrToCpuPAddr(gsSGXDeviceMap.sRegsSysPBase);
+        gsSGXDeviceMap.ui32RegsSize = SYS_OMAP4430_SGX_REGS_SIZE;
+
+        gsSGXDeviceMap.ui32IRQ = SYS_OMAP4430_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_OMAP4430_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_OMAP4430_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;
+#if !defined(NO_OMAP_TIMER)
+        IMG_CPU_PHYADDR         TimerRegPhysBase;
+#endif
+#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;
+        }
+
+#if !defined(NO_OMAP_TIMER)
+        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);
+#endif
+
+#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_OMAP4430_OCP_REGS_SYS_PHYS_BASE;
+                sOCPRegsCpuPBase                = SysSysPAddrToCpuPAddr(sOCPRegsSysPBase);
+
+                gpvOCPRegsLinAddr               = OSMapPhysToLin(sOCPRegsCpuPBase,
+                                                                                                 SYS_OMAP4430_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_OMAP4430_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 !defined(NO_OMAP_TIMER)
+        if(gpsSysData->pvSOCTimerRegisterKM)
+        {
+                OSUnReservePhys(gpsSysData->pvSOCTimerRegisterKM,
+                                                4,
+                                                PVRSRV_HAP_MULTI_PROCESS|PVRSRV_HAP_UNCACHED,
+                                                gpsSysData->hSOCTimerRegisterOSMemHandle);
+        }
+#endif
+
+        SysDeinitialiseCommon(gpsSysData);
+
+#if defined(NO_HARDWARE)
+        if(SYS_SPECIFIC_DATA_TEST(gpsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LOCATEDEV))
+        {
+
+                OSBaseFreeContigMemory(SYS_OMAP4430_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;
+}
diff --git a/drivers/gpu/pvr/omap4/sysconfig.h b/drivers/gpu/pvr/omap4/sysconfig.h
new file mode 100644
index 00000000000..7fcf84b2e8d
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/sysconfig.h
@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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 "OMAP4"
+
+#if defined(SGX_CLK_PER_192)
+#define SYS_SGX_CLOCK_SPEED 192000000
+#else
+#if defined(SGX_CLK_CORE_DIV8)
+#define SYS_SGX_CLOCK_SPEED 190464000
+#else
+#if defined(SGX_CLK_CORE_DIV5)
+#if defined(CONFIG_SGX_REV110)
+#define SYS_SGX_CLOCK_SPEED 304742400
+#endif
+#if defined(CONFIG_SGX_REV120)
+#define SYS_SGX_CLOCK_SPEED 320000000
+#endif
+#endif
+#endif
+#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         (100)
+#endif
+
+
+
+#define SYS_OMAP4430_SGX_REGS_SYS_PHYS_BASE  0x56000000
+#define SYS_OMAP4430_SGX_REGS_SIZE           0xFFFF
+
+#define SYS_OMAP4430_SGX_IRQ                             53 /* OMAP 4 IRQs are offset by 32 */
+
+
+
+#endif
diff --git a/drivers/gpu/pvr/omap4/sysinfo.h b/drivers/gpu/pvr/omap4/sysinfo.h
new file mode 100644
index 00000000000..07718276b8d
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/sysinfo.h
@@ -0,0 +1,40 @@
+/**********************************************************************
+ *
+ * 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
diff --git a/drivers/gpu/pvr/omap4/syslocal.h b/drivers/gpu/pvr/omap4/syslocal.h
new file mode 100644
index 00000000000..ecf203b912e
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/syslocal.h
@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * 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(NO_OMAP_TIMER)
+#if defined(DEBUG) || defined(TIMING)
+        struct clk      *psGPT11_FCK;
+        struct clk      *psGPT11_ICK;
+#endif
+#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
+
+
diff --git a/drivers/gpu/pvr/omap4/sysutils.c b/drivers/gpu/pvr/omap4/sysutils.c
new file mode 100644
index 00000000000..d2c4231315c
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/sysutils.c
@@ -0,0 +1,33 @@
+/**********************************************************************
+ *
+ * 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
diff --git a/drivers/gpu/pvr/omap4/sysutils_linux_wqueue_compat.c b/drivers/gpu/pvr/omap4/sysutils_linux_wqueue_compat.c
new file mode 100644
index 00000000000..fa0cc696f80
--- /dev/null
+++ b/drivers/gpu/pvr/omap4/sysutils_linux_wqueue_compat.c
@@ -0,0 +1,238 @@
+/**********************************************************************
+ *
+ * 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
+
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA unref__ *psSysData)
+{
+        return PVRSRV_OK;
+}
+
+IMG_VOID SysPowerLockUnwrap(SYS_DATA unref__ *psSysData)
+{
+}
+
+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 = SYS_SGX_CLOCK_SPEED;
+        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;
+
+        if (atomic_read(&psSysSpecData->sSGXClocksEnabled) != 0)
+        {
+                return PVRSRV_OK;
+        }
+
+        PVR_DPF((PVR_DBG_MESSAGE, "EnableSGXClocks: Enabling SGX Clocks"));
+
+
+        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"));
+
+        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);
+                psSysSpecData->bSysClocksOneTimeInit = IMG_TRUE;
+        }
+
+        eError = PVRSRV_OK;
+        goto Exit;
+
+#if !defined(NO_OMAP_TIMER)
+#if defined(DEBUG) || defined(TIMING)
+ExitDisableGPT11ICK:
+ExitDisableGPT11FCK:
+ExitUnRegisterConstraintNotifications:
+#endif
+#endif
+Exit:
+        return eError;
+}
+
+IMG_VOID DisableSystemClocks(SYS_DATA *psSysData)
+{
+#if !defined(NO_OMAP_TIMER)
+#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
+#endif
+
+        PVR_TRACE(("DisableSystemClocks: Disabling System Clocks"));
+
+        DisableSGXClocks(psSysData);
+
+#if !defined(NO_OMAP_TIMER)
+#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);
+        }
+
+
+#endif
+#endif
+}
diff --git a/drivers/gpu/pvr/omaplfb/omaplfb.h b/drivers/gpu/pvr/omaplfb/omaplfb.h
new file mode 100644
index 00000000000..f16e8e04098
--- /dev/null
+++ b/drivers/gpu/pvr/omaplfb/omaplfb.h
@@ -0,0 +1,166 @@
+/**********************************************************************
+ *
+ * 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__
+
+extern IMG_BOOL PVRGetDisplayClassJTable(PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable);
+
+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_FLIP_ITEM_TAG
+{
+        OMAP_HANDLE      hCmdComplete;
+        unsigned long    ulSwapInterval;
+        OMAP_BOOL        bValid;
+        OMAP_BOOL        bFlipped;
+        OMAP_BOOL        bCmdCompleted;
+        IMG_SYS_PHYADDR* sSysAddr;
+
+} OMAPLFB_FLIP_ITEM;
+
+typedef struct PVRPDP_SWAPCHAIN_TAG
+{
+        unsigned long                   ulBufferCount;
+        OMAPLFB_BUFFER*                 psBuffer;
+        OMAPLFB_FLIP_ITEM*              psFlipItems;
+        unsigned long                   ulInsertIndex;
+        unsigned long                   ulRemoveIndex;
+        PVRSRV_DC_DISP2SRV_KMJTABLE*    psPVRJTable;
+        OMAP_BOOL                       bFlushCommands;
+        unsigned long                   ulSetFlushStateRefCount;
+        OMAP_BOOL                       bBlanked;
+        spinlock_t*                     psSwapChainLock;
+        void*                           pvDevInfo;
+
+} 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;
+        IMG_SYS_PHYADDR     sSysAddr;
+        IMG_CPU_VIRTADDR    sCPUVAddr;
+        PVRSRV_PIXEL_FORMAT ePixelFormat;
+
+}OMAPLFB_FBINFO;
+
+typedef struct OMAPLFB_DEVINFO_TAG
+{
+        IMG_UINT32                      uDeviceID;
+        OMAPLFB_BUFFER                  sSystemBuffer;
+        PVRSRV_DC_DISP2SRV_KMJTABLE     sPVRJTable;
+        PVRSRV_DC_SRV2DISP_KMJTABLE     sDCJTable;
+        OMAPLFB_FBINFO                  sFBInfo;
+        OMAPLFB_SWAPCHAIN*              psSwapChain;
+        OMAP_BOOL                       bFlushCommands;
+        struct fb_info*                 psLINFBInfo;
+        struct notifier_block           sLINNotifBlock;
+        OMAP_BOOL                       bDeviceSuspended;
+        struct mutex                    sSwapChainLockMutex;
+        IMG_DEV_VIRTADDR                sDisplayDevVAddr;
+        DISPLAY_INFO                    sDisplayInfo;
+        DISPLAY_FORMAT                  sDisplayFormat;
+        DISPLAY_DIMS                    sDisplayDim;
+        struct workqueue_struct*        sync_display_wq;
+        struct work_struct              sync_display_work;
+
+}  OMAPLFB_DEVINFO;
+
+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;
+
+#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)
+
+#define DISPLAY_DEVICE_NAME "PowerVR OMAP Linux Display Driver"
+#define DRVNAME "omaplfb"
+#define DEVNAME DRVNAME
+#define DRIVER_PREFIX DRVNAME
+
+#define FRAMEBUFFER_COUNT               num_registered_fb
+
+#ifdef  DEBUG
+#define DEBUG_PRINTK(format, ...) printk("DEBUG " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#else
+#define DEBUG_PRINTK(format,...)
+#endif
+
+#define WARNING_PRINTK(format, ...) printk("WARNING " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+#define ERROR_PRINTK(format, ...) printk("ERROR " DRIVER_PREFIX \
+        " (%s %i): " format "\n", __func__, __LINE__, ## __VA_ARGS__)
+
+OMAP_ERROR OMAPLFBInit(void);
+OMAP_ERROR OMAPLFBDeinit(void);
+void *OMAPLFBAllocKernelMem(unsigned long ulSize);
+void OMAPLFBFreeKernelMem(void *pvMem);
+void OMAPLFBWaitForSync(OMAPLFB_DEVINFO *psDevInfo);
+OMAP_ERROR OMAPLFBGetLibFuncAddr(char *szFunctionName,
+        PFN_DC_GET_PVRJTABLE *ppfnFuncTable);
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr);
+#ifdef LDM_PLATFORM
+void OMAPLFBDriverSuspend(void);
+void OMAPLFBDriverResume(void);
+#endif
+
+#endif
+
diff --git a/drivers/gpu/pvr/omaplfb/omaplfb_displayclass.c b/drivers/gpu/pvr/omaplfb/omaplfb_displayclass.c
new file mode 100644
index 00000000000..a2ad4e6e5d6
--- /dev/null
+++ b/drivers/gpu/pvr/omaplfb/omaplfb_displayclass.c
@@ -0,0 +1,1723 @@
+/**********************************************************************
+ *
+ * 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>
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
+#include <plat/vrfb.h>
+#include <plat/display.h>
+#else
+#include <mach/vrfb.h>
+#include <mach/display.h>
+#endif
+
+#ifdef RELEASE
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#undef DEBUG
+#else
+#undef DEBUG
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#endif
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/notifier.h>
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omaplfb.h"
+
+#define OMAPLFB_COMMAND_COUNT           1
+#define MAX_BUFFERS_FLIPPING            3
+/* Put 0 as desired bpp to use the default in the framebuffer */
+#define DESIRED_BPP                     0 /* Possible values 32,16,0 */
+
+/* Pointer Display->Services */
+static PFN_DC_GET_PVRJTABLE pfnGetPVRJTable = NULL;
+
+/* Pointer to the display devices */
+static OMAPLFB_DEVINFO *pDisplayDevices = NULL;
+
+static void OMAPLFBSyncIHandler(struct work_struct*);
+
+/*
+ * Swap to display buffer. This buffer refers to one inside the
+ * framebuffer memory.
+ * in: hDevice, hBuffer, ui32SwapInterval, hPrivateTag, ui32ClipRectCount,
+ * psClipRect
+ */
+static PVRSRV_ERROR SwapToDCBuffer(IMG_HANDLE hDevice,
+                                   IMG_HANDLE hBuffer,
+                                   IMG_UINT32 ui32SwapInterval,
+                                   IMG_HANDLE hPrivateTag,
+                                   IMG_UINT32 ui32ClipRectCount,
+                                   IMG_RECT *psClipRect)
+{
+        /* Nothing to do */
+        return PVRSRV_OK;
+}
+
+/*
+ * Set display destination rectangle.
+ * in: hDevice, hSwapChain, psRect
+ */
+static PVRSRV_ERROR SetDCDstRect(IMG_HANDLE hDevice,
+        IMG_HANDLE hSwapChain,
+        IMG_RECT *psRect)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display source rectangle.
+ * in: hDevice, hSwapChain, psRect
+ */
+static PVRSRV_ERROR SetDCSrcRect(IMG_HANDLE hDevice,
+                                 IMG_HANDLE hSwapChain,
+                                 IMG_RECT *psRect)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display destination colour key.
+ * in: hDevice, hSwapChain, ui32CKColour
+ */
+static PVRSRV_ERROR SetDCDstColourKey(IMG_HANDLE hDevice,
+                                      IMG_HANDLE hSwapChain,
+                                      IMG_UINT32 ui32CKColour)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Set display source colour key.
+ * in: hDevice, hSwapChain, ui32CKColour
+ */
+static PVRSRV_ERROR SetDCSrcColourKey(IMG_HANDLE hDevice,
+                                      IMG_HANDLE hSwapChain,
+                                      IMG_UINT32 ui32CKColour)
+{
+        /* Nothing to do */
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+/*
+ * Closes the display.
+ * in: hDevice
+ */
+static PVRSRV_ERROR CloseDCDevice(IMG_HANDLE hDevice)
+{
+        /* Nothing to do */
+        return PVRSRV_OK;
+}
+
+/*
+ * Flushes the sync queue present in the specified swap chain.
+ * in: psSwapChain
+ */
+static void FlushInternalSyncQueue(OMAPLFB_SWAPCHAIN *psSwapChain)
+{
+#ifdef DEBUG
+        OMAPLFB_DEVINFO *psDevInfo = (OMAPLFB_DEVINFO *) psSwapChain->pvDevInfo;
+#endif
+        OMAPLFB_FLIP_ITEM *psFlipItem;
+        unsigned long            ulMaxIndex;
+        unsigned long            i;
+        
+        psFlipItem = &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+#ifdef DEBUG
+        DEBUG_PRINTK("Flushing sync queue on display %u",
+                psDevInfo->uDeviceID);
+#endif
+        for(i = 0; i < psSwapChain->ulBufferCount; i++)
+        {
+                if (psFlipItem->bValid == OMAP_FALSE)
+                        continue;
+
+                DEBUG_PRINTK("Flushing swap buffer index %lu",
+                        psSwapChain->ulRemoveIndex);
+
+                /* Flip the buffer if it hasn't been flipped */
+                if(psFlipItem->bFlipped == OMAP_FALSE)
+                {
+                        OMAPLFBFlip(psSwapChain,
+                                (unsigned long)psFlipItem->sSysAddr);
+                }
+
+                /* If the command didn't complete, assume it did */
+                if(psFlipItem->bCmdCompleted == OMAP_FALSE)
+                {
+                        DEBUG_PRINTK("Calling command complete for swap "
+                                "buffer index %lu",
+                                psSwapChain->ulRemoveIndex);
+                        psSwapChain->psPVRJTable->pfnPVRSRVCmdComplete(
+                                (IMG_HANDLE)psFlipItem->hCmdComplete,
+                                IMG_TRUE);
+                }
+                
+                psSwapChain->ulRemoveIndex++;
+                if(psSwapChain->ulRemoveIndex > ulMaxIndex)
+                        psSwapChain->ulRemoveIndex = 0;
+                
+                /* Put the state of the buffer to be used again later */
+                psFlipItem->bFlipped = OMAP_FALSE;
+                psFlipItem->bCmdCompleted = OMAP_FALSE;
+                psFlipItem->bValid = OMAP_FALSE;
+                psFlipItem =
+                        &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        }
+
+        psSwapChain->ulInsertIndex = 0;
+        psSwapChain->ulRemoveIndex = 0;
+}
+
+/*
+ * Sets the flush state of the specified display device
+ * at the swap chain level without blocking the call.
+ * in: psDevInfo, bFlushState
+ */
+static void SetFlushStateInternalNoLock(OMAPLFB_DEVINFO* psDevInfo,
+                                        OMAP_BOOL bFlushState)
+{
+        OMAPLFB_SWAPCHAIN *psSwapChain = psDevInfo->psSwapChain;
+
+        /* Nothing to do if there is no swap chain */
+        if (psSwapChain == NULL){
+                DEBUG_PRINTK("Swap chain is null, nothing to do for"
+                        " display %u", psDevInfo->uDeviceID);
+                return;
+        }
+
+        if (bFlushState)
+        {
+                DEBUG_PRINTK("Desired flushState is true for display %u",
+                        psDevInfo->uDeviceID);
+                if (psSwapChain->ulSetFlushStateRefCount == 0)
+                {
+                        psSwapChain->bFlushCommands = OMAP_TRUE;
+                        FlushInternalSyncQueue(psSwapChain);
+                }
+                psSwapChain->ulSetFlushStateRefCount++;
+        }
+        else
+        {
+                DEBUG_PRINTK("Desired flushState is false for display %u",
+                        psDevInfo->uDeviceID);
+                if (psSwapChain->ulSetFlushStateRefCount != 0)
+                {
+                        psSwapChain->ulSetFlushStateRefCount--;
+                        if (psSwapChain->ulSetFlushStateRefCount == 0)
+                        {
+                                psSwapChain->bFlushCommands = OMAP_FALSE;
+                        }
+                }
+        }
+}
+
+/*
+ * Sets the flush state of the specified display device
+ * at the swap chain level blocking the call if needed.
+ * in: psDevInfo, bFlushState
+ */
+static IMG_VOID SetFlushStateInternal(OMAPLFB_DEVINFO* psDevInfo,
+                                      OMAP_BOOL bFlushState)
+{
+        DEBUG_PRINTK("Executing for display %u",
+                psDevInfo->uDeviceID);
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+        SetFlushStateInternalNoLock(psDevInfo, bFlushState);
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+}
+
+/*
+ * Sets the flush state of the specified display device
+ * at device level blocking the call if needed.
+ * in: psDevInfo, bFlushState
+ */
+static void SetFlushStateExternal(OMAPLFB_DEVINFO* psDevInfo,
+                                  OMAP_BOOL bFlushState)
+{
+        DEBUG_PRINTK("Executing for display %u",
+                psDevInfo->uDeviceID);
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+        if (psDevInfo->bFlushCommands != bFlushState)
+        {
+                psDevInfo->bFlushCommands = bFlushState;
+                SetFlushStateInternalNoLock(psDevInfo, bFlushState);
+        }
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+}
+
+/*
+ * Unblank the framebuffer display
+ * in: psDevInfo
+ */
+static OMAP_ERROR UnBlankDisplay(OMAPLFB_DEVINFO *psDevInfo)
+{
+        DEBUG_PRINTK("Executing for display %u",
+                psDevInfo->uDeviceID);
+
+        acquire_console_sem();
+        if (fb_blank(psDevInfo->psLINFBInfo, FB_BLANK_UNBLANK))
+        {
+                release_console_sem();
+                WARNING_PRINTK("fb_blank failed");
+                return OMAP_ERROR_GENERIC;
+        }
+        release_console_sem();
+
+        return OMAP_OK;
+}
+
+/*
+ * Framebuffer listener
+ * in: psNotif, event, data
+ */
+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;
+        int i;
+
+        DEBUG_PRINTK("Framebuffer event (%lu) happened", event);
+        if (event != FB_EVENT_BLANK){
+                DEBUG_PRINTK("Ignoring");
+                return 0;
+        }
+
+        DEBUG_PRINTK("Event is FB_EVENT_BLANK");
+        
+        psDevInfo = 0;
+        for(i = 0; i < FRAMEBUFFER_COUNT; i++)
+        {
+                if(psFBEvent->info == (&pDisplayDevices[i])->psLINFBInfo)
+                {
+                        psDevInfo = &pDisplayDevices[i];
+                        break;
+                }
+        }
+
+        if(!psDevInfo)
+        {
+                WARNING_PRINTK("Unable to find the display related to "
+                        " the framebuffer event");
+                return 1;
+        }
+
+        psSwapChain = psDevInfo->psSwapChain;
+
+        if(!psSwapChain)
+        {
+                DEBUG_PRINTK("No swapchain associated with this display");
+                return 0;
+        }
+
+        bBlanked = (*(IMG_INT *)psFBEvent->data != 0) ?
+                OMAP_TRUE: OMAP_FALSE;
+
+        /* Check if the blank state is the same as the swap chain */
+        if (bBlanked != psSwapChain->bBlanked)
+        {
+                DEBUG_PRINTK("Executing for display %u",
+                        psDevInfo->uDeviceID);
+
+                /* Set the new blank state in the swap chain */
+                psSwapChain->bBlanked = bBlanked;
+
+                if (bBlanked)
+                {
+                        DEBUG_PRINTK("Requesting flush state true for"
+                                " display %u", psDevInfo->uDeviceID);
+                        SetFlushStateInternal(psDevInfo, OMAP_TRUE);
+                }
+                else
+                {
+                        DEBUG_PRINTK("Requesting flush state false for"
+                                " display %u", psDevInfo->uDeviceID);
+                        SetFlushStateInternal(psDevInfo, OMAP_FALSE);
+                }
+        }
+        else
+        {
+                DEBUG_PRINTK("Ignoring event for display %u",
+                        psDevInfo->uDeviceID);
+        }
+
+        return 0;
+}
+
+/*
+ * Registers a listener for changes in the framebuffer
+ * in: psDevInfo
+ */
+static OMAP_ERROR EnableLFBEventNotification(OMAPLFB_DEVINFO *psDevInfo)
+{
+        OMAPLFB_SWAPCHAIN *psSwapChain = psDevInfo->psSwapChain;
+        OMAP_ERROR         eError;
+        
+        memset(&psDevInfo->sLINNotifBlock, 0,
+                sizeof(psDevInfo->sLINNotifBlock));
+
+        /* Register the function to listen the changes */
+        psDevInfo->sLINNotifBlock.notifier_call = FrameBufferEvents;
+        psSwapChain->bBlanked = OMAP_FALSE;
+
+        DEBUG_PRINTK("Registering framebuffer event listener for"
+                " display %u", psDevInfo->uDeviceID);
+
+        if (fb_register_client(&psDevInfo->sLINNotifBlock))
+        {
+                WARNING_PRINTK("fb_register_client failed for"
+                        " display %u", psDevInfo->uDeviceID);
+                return OMAP_ERROR_GENERIC;
+        }
+
+        eError = UnBlankDisplay(psDevInfo);
+        if (eError != OMAP_OK)
+        {
+                WARNING_PRINTK("UnBlankDisplay failed for"
+                        " display %u", psDevInfo->uDeviceID);
+                return eError;
+        }
+
+        return OMAP_OK;
+}
+
+/*
+ * Unregister a listener from the framebuffer
+ * in: psDevInfo
+ */
+static OMAP_ERROR DisableLFBEventNotification(OMAPLFB_DEVINFO *psDevInfo)
+{
+        DEBUG_PRINTK("Removing framebuffer event listener for"
+                " display %u", psDevInfo->uDeviceID);
+
+        if (fb_unregister_client(&psDevInfo->sLINNotifBlock))
+        {
+                WARNING_PRINTK("fb_unregister_client failed for"
+                        " display %u", psDevInfo->uDeviceID);
+                return OMAP_ERROR_GENERIC;
+        }
+
+        return OMAP_OK;
+}
+
+/*
+ * Opens the display.
+ * in: ui32DeviceID, phDevice
+ * out: psSystemBufferSyncData
+ */
+static PVRSRV_ERROR OpenDCDevice(IMG_UINT32 ui32DeviceID,
+                                 IMG_HANDLE *phDevice,
+                                 PVRSRV_SYNC_DATA* psSystemBufferSyncData)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        int i;
+
+        psDevInfo = 0;
+        for(i = 0; i < FRAMEBUFFER_COUNT; i++)
+        {
+                if (ui32DeviceID == (&pDisplayDevices[i])->uDeviceID)
+                {
+                        psDevInfo = &pDisplayDevices[i];
+                        break;
+                }
+        }
+
+        if(!psDevInfo)
+        {
+                WARNING_PRINTK("Unable to identify display device with id %i",
+                        (int)ui32DeviceID);
+                return 1;
+        }
+
+        psDevInfo->sSystemBuffer.psSyncData = psSystemBufferSyncData;
+        if ( UnBlankDisplay(psDevInfo) != OMAP_OK)
+        {
+                WARNING_PRINTK("UnBlankDisplay failed for"
+                        " display %u", psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED;
+        }
+        *phDevice = (IMG_HANDLE)psDevInfo;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the available formats for the display.
+ * in: hDevice
+ * out: pui32NumFormats, psFormat
+ */
+static PVRSRV_ERROR EnumDCFormats(IMG_HANDLE hDevice,
+                                  IMG_UINT32 *pui32NumFormats,
+                                  DISPLAY_FORMAT *psFormat)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        if(!hDevice || !pui32NumFormats)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        *pui32NumFormats = 1;
+        
+        if(psFormat)
+                psFormat[0] = psDevInfo->sDisplayFormat;
+        else
+                WARNING_PRINTK("Display format is null for"
+                        " display %u", psDevInfo->uDeviceID);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the available dimensions for the display.
+ * in: hDevice, psFormat
+ * out: pui32NumDims, psDim
+ */
+static PVRSRV_ERROR EnumDCDims(IMG_HANDLE hDevice, 
+                               DISPLAY_FORMAT *psFormat,
+                               IMG_UINT32 *pui32NumDims,
+                               DISPLAY_DIMS *psDim)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        if(!hDevice || !psFormat || !pui32NumDims)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        *pui32NumDims = 1;
+        
+        if(psDim)
+                psDim[0] = psDevInfo->sDisplayDim;
+        else
+                WARNING_PRINTK("Display dimensions are null for"
+                        " display %u", psDevInfo->uDeviceID);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display framebuffer physical address.
+ * in: hDevice
+ * out: phBuffer
+ */
+static PVRSRV_ERROR GetDCSystemBuffer(IMG_HANDLE hDevice, IMG_HANDLE *phBuffer)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+
+        if(!hDevice || !phBuffer)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        *phBuffer = (IMG_HANDLE)&psDevInfo->sSystemBuffer;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display general information.
+ * in: hDevice
+ * out: psDCInfo
+ */
+static PVRSRV_ERROR GetDCInfo(IMG_HANDLE hDevice, DISPLAY_INFO *psDCInfo)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+
+        if(!hDevice || !psDCInfo)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        *psDCInfo = psDevInfo->sDisplayInfo;
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Gets the display framebuffer virtual address.
+ * in: hDevice
+ * out: ppsSysAddr, pui32ByteSize, ppvCpuVAddr, phOSMapInfo, pbIsContiguous
+ */
+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;
+
+        if(!hDevice || !hBuffer || !ppsSysAddr || !pui32ByteSize )
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        psSystemBuffer = (OMAPLFB_BUFFER *)hBuffer;
+        *ppsSysAddr = &psSystemBuffer->sSysAddr;
+        *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;
+}
+
+/*
+ * Creates a swap chain. Called when a 3D application begins.
+ * in: hDevice, ui32Flags, ui32BufferCount, psDstSurfAttrib, psSrcSurfAttrib
+ * ui32OEMFlags
+ * out: phSwapChain, ppsSyncData, pui32SwapChainID
+ */
+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_FLIP_ITEM *psFlipItems;
+        IMG_UINT32 i;
+        PVRSRV_ERROR eError = PVRSRV_OK;
+        IMG_UINT32 ui32BuffersToSkip;
+        
+        if(!hDevice || !psDstSurfAttrib || !psSrcSurfAttrib ||
+                !ppsSyncData || !phSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        
+        if (psDevInfo->sDisplayInfo.ui32MaxSwapChains == 0)
+        {
+                ERROR_PRINTK("Unable to operate with 0 MaxSwapChains for"
+                        " display %u", psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_NOT_SUPPORTED;
+        }
+
+        if(psDevInfo->psSwapChain != NULL)
+        {
+                ERROR_PRINTK("Swap chain already exists for"
+                        " display %u", psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_FLIP_CHAIN_EXISTS;
+        }
+
+        if(ui32BufferCount > psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers)
+        {
+                ERROR_PRINTK("Too many buffers. Trying to use %u buffers while"
+                        " there is only %u available for display %u",
+                        (unsigned int)ui32BufferCount,
+                        (unsigned int)psDevInfo->
+                        sDisplayInfo.ui32MaxSwapChainBuffers,
+                        psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_TOOMANYBUFFERS;
+        }
+
+
+        if ((psDevInfo->sFBInfo.ulRoundedBufferSize *
+                (unsigned long)ui32BufferCount) > psDevInfo->sFBInfo.ulFBSize)
+        {
+                ERROR_PRINTK("Too many buffers. Trying to use %u buffers "
+                        "(%lu bytes each) while there is only %lu memory for"
+                        " display %u",
+                        (unsigned int)ui32BufferCount,
+                        psDevInfo->sFBInfo.ulRoundedBufferSize,
+                        psDevInfo->sFBInfo.ulFBSize,
+                        psDevInfo->uDeviceID);
+                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))
+        {
+                ERROR_PRINTK("Destination surface attributes differ from the"
+                        " current framebuffer for display %u",
+                        psDevInfo->uDeviceID);
+                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))
+        {
+                ERROR_PRINTK("Destination surface attributes differ from the"
+                        " target destination surface for display %u",
+                        psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }               
+
+        /* Allocate memory needed for the swap chain */
+        psSwapChain = (OMAPLFB_SWAPCHAIN*)OMAPLFBAllocKernelMem(
+                sizeof(OMAPLFB_SWAPCHAIN));
+        if(!psSwapChain)
+        {
+                ERROR_PRINTK("Out of memory to allocate swap chain for"
+                        " display %u", psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        DEBUG_PRINTK("Creating swap chain 0x%lx for display %u",
+                (unsigned long)psSwapChain, psDevInfo->uDeviceID);
+
+        /* Allocate memory for the buffer abstraction structures */
+        psBuffer = (OMAPLFB_BUFFER*)OMAPLFBAllocKernelMem(
+                sizeof(OMAPLFB_BUFFER) * ui32BufferCount);
+        if(!psBuffer)
+        {
+                ERROR_PRINTK("Out of memory to allocate the buffer"
+                        " abstraction structures for display %u",
+                        psDevInfo->uDeviceID);
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorFreeSwapChain;
+        }
+
+        /* Allocate memory for the flip item abstraction structures */
+        psFlipItems = (OMAPLFB_FLIP_ITEM *)OMAPLFBAllocKernelMem(
+                sizeof(OMAPLFB_FLIP_ITEM) * ui32BufferCount);
+        if (!psFlipItems)
+        {
+                ERROR_PRINTK("Out of memory to allocate the flip item"
+                        " abstraction structures for display %u",
+                        psDevInfo->uDeviceID);
+                eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto ErrorFreeBuffers;
+        }
+
+        /* Assign to the swap chain structure the initial data */
+        psSwapChain->ulBufferCount = (unsigned long)ui32BufferCount;
+        psSwapChain->psBuffer = psBuffer;
+        psSwapChain->psFlipItems = psFlipItems;
+        psSwapChain->ulInsertIndex = 0;
+        psSwapChain->ulRemoveIndex = 0;
+        psSwapChain->psPVRJTable = &psDevInfo->sPVRJTable;
+        psSwapChain->pvDevInfo = (void*)psDevInfo;
+
+        /*
+         * Init the workqueue (single thread, freezable and real time)
+         * and its own work for this display
+         */
+        INIT_WORK(&psDevInfo->sync_display_work, OMAPLFBSyncIHandler);
+        psDevInfo->sync_display_wq =
+                __create_workqueue("pvr_display_sync_wq", 1, 1, 1);
+
+        DEBUG_PRINTK("Swap chain will have %u buffers for display %u",
+                (unsigned int)ui32BufferCount, psDevInfo->uDeviceID);
+        /* Link the buffers available like a circular list */
+        for(i=0; i<ui32BufferCount-1; i++)
+        {
+                psBuffer[i].psNext = &psBuffer[i+1];
+        }
+        psBuffer[i].psNext = &psBuffer[0];
+
+        /* Initialize each buffer abstraction structure */
+        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;
+                DEBUG_PRINTK("Display %u buffer index %u has physical "
+                        "address 0x%x",
+                        psDevInfo->uDeviceID,
+                        (unsigned int)i,
+                        (unsigned int)psBuffer[i].sSysAddr.uiAddr);
+        }
+
+        /* Initialize each flip item abstraction structure */
+        for(i=0; i<ui32BufferCount; i++)
+        {
+                psFlipItems[i].bValid = OMAP_FALSE;
+                psFlipItems[i].bFlipped = OMAP_FALSE;
+                psFlipItems[i].bCmdCompleted = OMAP_FALSE;
+        }
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+        
+        psDevInfo->psSwapChain = psSwapChain;
+        psSwapChain->bFlushCommands = psDevInfo->bFlushCommands;
+        if (psSwapChain->bFlushCommands)
+                psSwapChain->ulSetFlushStateRefCount = 1;
+        else
+                psSwapChain->ulSetFlushStateRefCount = 0;
+                
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        if (EnableLFBEventNotification(psDevInfo)!= OMAP_OK)
+        {
+                WARNING_PRINTK("Couldn't enable framebuffer event"
+                        " notification for display %u",
+                        psDevInfo->uDeviceID);
+                goto ErrorUnRegisterDisplayClient;
+        }
+        
+        *phSwapChain = (IMG_HANDLE)psSwapChain;
+
+        return PVRSRV_OK;
+
+ErrorUnRegisterDisplayClient:
+        OMAPLFBFreeKernelMem(psFlipItems);
+ErrorFreeBuffers:
+        OMAPLFBFreeKernelMem(psBuffer);
+ErrorFreeSwapChain:
+        OMAPLFBFreeKernelMem(psSwapChain);
+
+        return eError;
+}
+
+/*
+ * Destroy a swap chain. Called when a 3D application ends.
+ * in: hDevice, hSwapChain
+ */
+static PVRSRV_ERROR DestroyDCSwapChain(IMG_HANDLE hDevice,
+        IMG_HANDLE hSwapChain)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        OMAPLFB_SWAPCHAIN *psSwapChain;
+        OMAP_ERROR eError;
+        
+        if(!hDevice || !hSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device pointer");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        DEBUG_PRINTK("Destroying swap chain for display %u",
+                psDevInfo->uDeviceID);
+
+        eError = DisableLFBEventNotification(psDevInfo);
+        if (eError != OMAP_OK)
+        {
+                WARNING_PRINTK("Couldn't disable framebuffer event "
+                        "notification");
+        }
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        FlushInternalSyncQueue(psSwapChain);
+
+        /*
+         * Present the buffer which is at the base of address of
+         * the framebuffer
+         */
+        OMAPLFBFlip(psSwapChain,
+                (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
+        psDevInfo->psSwapChain = NULL;
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        /* Destroy the workqueue */
+        flush_workqueue(psDevInfo->sync_display_wq);
+        destroy_workqueue(psDevInfo->sync_display_wq);
+
+        OMAPLFBFreeKernelMem(psSwapChain->psFlipItems);
+        OMAPLFBFreeKernelMem(psSwapChain->psBuffer);
+        OMAPLFBFreeKernelMem(psSwapChain);
+
+        return PVRSRV_OK;
+}
+
+
+/*
+ * Get display buffers. These are the buffers that can be allocated
+ * inside the framebuffer memory.
+ * in: hDevice, hSwapChain
+ * out: pui32BufferCount, phBuffer
+ */
+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)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device %u pointer",
+                        psDevInfo->uDeviceID);
+                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;
+}
+
+/*
+ * Sets the display state.
+ * in: ui32State, hDevice
+ */
+static IMG_VOID SetDCState(IMG_HANDLE hDevice, IMG_UINT32 ui32State)
+{
+        OMAPLFB_DEVINFO *psDevInfo = (OMAPLFB_DEVINFO *)hDevice;
+
+        switch (ui32State)
+        {
+                case DC_STATE_FLUSH_COMMANDS:
+                        DEBUG_PRINTK("Setting state to flush commands for"
+                                " display %u", psDevInfo->uDeviceID);
+                        SetFlushStateExternal(psDevInfo, OMAP_TRUE);
+                        break;
+                case DC_STATE_NO_FLUSH_COMMANDS:
+                        DEBUG_PRINTK("Setting state to not flush commands for"
+                                " display %u", psDevInfo->uDeviceID);
+                        SetFlushStateExternal(psDevInfo, OMAP_FALSE);
+                        break;
+                default:
+                        WARNING_PRINTK("Unknown command state %u for display"
+                                " %u", (unsigned int)ui32State,
+                                psDevInfo->uDeviceID);
+                        break;
+        }
+}
+
+/*
+ * Swap to display system buffer. This buffer refers to the one which
+ * is that fits in the framebuffer memory.
+ * in: hDevice, hSwapChain
+ */
+static PVRSRV_ERROR SwapToDCSystem(IMG_HANDLE hDevice,
+                                   IMG_HANDLE hSwapChain)
+{
+        OMAPLFB_DEVINFO   *psDevInfo;
+        OMAPLFB_SWAPCHAIN *psSwapChain;
+
+        if(!hDevice || !hSwapChain)
+        {
+                ERROR_PRINTK("Invalid parameters");
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psDevInfo = (OMAPLFB_DEVINFO*)hDevice;
+        psSwapChain = (OMAPLFB_SWAPCHAIN*)hSwapChain;
+
+        DEBUG_PRINTK("Executing for display %u",
+                psDevInfo->uDeviceID);
+
+        if (psSwapChain != psDevInfo->psSwapChain)
+        {
+                ERROR_PRINTK("Swap chain handler differs from the one "
+                        "present in the display device %u pointer",
+                        psDevInfo->uDeviceID);
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+        
+        FlushInternalSyncQueue(psSwapChain);
+        OMAPLFBFlip(psSwapChain,
+                (unsigned long)psDevInfo->sFBInfo.sSysAddr.uiAddr);
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+
+        return PVRSRV_OK;
+}
+
+/*
+ * Handles the synchronization with the display
+ * in: work
+ */
+static void OMAPLFBSyncIHandler(struct work_struct *work)
+{
+        OMAPLFB_DEVINFO *psDevInfo = container_of(work, OMAPLFB_DEVINFO,
+                sync_display_work);
+        OMAPLFB_FLIP_ITEM *psFlipItem;
+        OMAPLFB_SWAPCHAIN *psSwapChain;
+        unsigned long ulMaxIndex;
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        psSwapChain = psDevInfo->psSwapChain;
+        if (!psSwapChain || psSwapChain->bFlushCommands)
+                goto ExitUnlock;
+
+        psFlipItem = &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+        /* Synchronize with the display */
+        OMAPLFBWaitForSync(psDevInfo);
+
+        /* Iterate through the flip items and flip them if necessary */
+        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
+                        {
+                                /*
+                                 * Here the swap interval is not zero yet
+                                 * we need to schedule another work until
+                                 * it reaches zero
+                                 */
+                                queue_work(psDevInfo->sync_display_wq,
+                                        &psDevInfo->sync_display_work);
+                                goto ExitUnlock;
+                        }
+                }
+                else
+                {
+                        OMAPLFBFlip(psSwapChain,
+                                (unsigned long)psFlipItem->sSysAddr);
+                        psFlipItem->bFlipped = OMAP_TRUE;
+                        /*
+                         * If the flip has been presented here then we need
+                         * in the next sync execute the command complete,
+                         * schedule another work
+                         */
+                        queue_work(psDevInfo->sync_display_wq,
+                                &psDevInfo->sync_display_work);
+                        goto ExitUnlock;
+                }
+                psFlipItem =
+                        &psSwapChain->psFlipItems[psSwapChain->ulRemoveIndex];
+        }
+                
+ExitUnlock:
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+}
+
+/*
+ * Performs a flip. This function takes the necessary steps to present
+ * the buffer to be flipped in the display.
+ * in: hCmdCookie, ui32DataSize, pvData
+ */
+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_FLIP_ITEM* psFlipItem;
+#endif
+
+        if(!hCmdCookie || !pvData)
+        {
+                WARNING_PRINTK("Ignoring call with NULL parameters");
+                return IMG_FALSE;
+        }
+        
+        psFlipCmd = (DISPLAYCLASS_FLIP_COMMAND*)pvData;
+
+        if (psFlipCmd == IMG_NULL ||
+                sizeof(DISPLAYCLASS_FLIP_COMMAND) != ui32DataSize)
+        {
+                WARNING_PRINTK("NULL command or command data size is wrong");
+                return IMG_FALSE;
+        }
+        
+        psDevInfo = (OMAPLFB_DEVINFO*)psFlipCmd->hExtDevice;
+        psBuffer = (OMAPLFB_BUFFER*)psFlipCmd->hExtBuffer;
+        psSwapChain = (OMAPLFB_SWAPCHAIN*) psFlipCmd->hExtSwapChain;
+
+        mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+        if (psDevInfo->bDeviceSuspended)
+        {
+                /* If is suspended then assume the commands are completed */
+                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->psFlipItems[psSwapChain->ulInsertIndex];
+
+        if(psFlipItem->bValid == OMAP_FALSE)
+        {
+                unsigned long ulMaxIndex = psSwapChain->ulBufferCount - 1;
+
+                /*
+                 * If both indexes are equal the queue is empty,
+                 * present immediatly
+                 */
+                if(psSwapChain->ulInsertIndex == psSwapChain->ulRemoveIndex)
+                {
+                        OMAPLFBFlip(psSwapChain,
+                                (unsigned long)psBuffer->sSysAddr.uiAddr);
+                        psFlipItem->bFlipped = OMAP_TRUE;
+                }
+                else
+                        psFlipItem->bFlipped = OMAP_FALSE;
+
+                /*
+                 * The buffer is queued here, must be consumed by the workqueue
+                 */
+                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;
+
+                /* Give work to the workqueue to sync with the display */
+                queue_work(psDevInfo->sync_display_wq, &psDevInfo->sync_display_work);
+
+                goto ExitTrueUnlock;
+        }
+
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        return IMG_FALSE;
+#endif
+
+ExitTrueUnlock:
+        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        return IMG_TRUE;
+}
+
+#if defined(LDM_PLATFORM)
+
+/*
+ *  Function called when the driver must suspend
+ */
+void OMAPLFBDriverSuspend(void)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        int i;
+
+        if(!pDisplayDevices)
+                return;
+
+        for(i = 0; i < FRAMEBUFFER_COUNT; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+
+                mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+                if (psDevInfo->bDeviceSuspended)
+                {
+                        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+                        continue;
+                }
+
+                psDevInfo->bDeviceSuspended = OMAP_TRUE;
+                SetFlushStateInternalNoLock(psDevInfo, OMAP_TRUE);
+
+                mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        }
+}
+
+/*
+ *  Function called when the driver must resume
+ */
+void OMAPLFBDriverResume(void)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        int i;
+
+        if(!pDisplayDevices)
+                return;
+
+        for(i = 0; i < FRAMEBUFFER_COUNT; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+
+                mutex_lock(&psDevInfo->sSwapChainLockMutex);
+
+                if (!psDevInfo->bDeviceSuspended)
+                {
+                        mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+                        continue;
+                }
+
+                SetFlushStateInternalNoLock(psDevInfo, OMAP_FALSE);
+                psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+                mutex_unlock(&psDevInfo->sSwapChainLockMutex);
+        }
+}
+#endif /* defined(LDM_PLATFORM) */
+
+/*
+ * Frees the kernel framebuffer
+ * in: psDevInfo
+ */
+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();
+}
+
+/*
+ *  Deinitialization routine for the 3rd party display driver
+ */
+OMAP_ERROR OMAPLFBDeinit(void)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        PVRSRV_DC_DISP2SRV_KMJTABLE *psJTable;
+        int i;
+
+        DEBUG_PRINTK("Deinitializing 3rd party display driver");
+
+        if(!pDisplayDevices)
+                return OMAP_OK;
+
+        for(i = 0; i < FRAMEBUFFER_COUNT; i++)
+        {
+                psDevInfo = &pDisplayDevices[i];
+
+                /* Remove the ProcessFlip command callback */
+                psJTable = &psDevInfo->sPVRJTable;
+                if (psDevInfo->sPVRJTable.pfnPVRSRVRemoveCmdProcList(
+                        psDevInfo->uDeviceID,
+                        OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to remove callback for "
+                                "ProcessFlip command for display %u",
+                                psDevInfo->uDeviceID);
+                        return OMAP_ERROR_GENERIC;
+                }
+
+                /* Remove the display device from services */
+                if (psJTable->pfnPVRSRVRemoveDCDevice(
+                        psDevInfo->uDeviceID) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to remove the display %u "
+                                "from services", psDevInfo->uDeviceID);
+                        return OMAP_ERROR_GENERIC;
+                }
+
+                DeInitDev(psDevInfo);
+        }
+
+        OMAPLFBFreeKernelMem(pDisplayDevices);
+
+        return OMAP_OK;
+}
+
+/*
+ * Extracts the framebuffer data from the kernel driver
+ * in: psDevInfo
+ */
+static OMAP_ERROR InitDev(OMAPLFB_DEVINFO *psDevInfo, int fb_idx)
+{
+        struct fb_info *psLINFBInfo;
+        struct module *psLINFBOwner;
+        OMAPLFB_FBINFO *psPVRFBInfo = &psDevInfo->sFBInfo;
+        unsigned long FBSize;
+        int buffers_available;
+
+        /* Check if the framebuffer index to use is valid */
+        if (fb_idx < 0 || fb_idx >= num_registered_fb)
+        {
+                ERROR_PRINTK("Framebuffer index %i out of range, "
+                        "only %i available", fb_idx, num_registered_fb);
+                return OMAP_ERROR_INVALID_DEVICE;
+        }
+
+        /* Get the framebuffer from the kernel */
+        if (!registered_fb[fb_idx])
+        {
+                ERROR_PRINTK("Framebuffer index %i is null", fb_idx);
+                return OMAP_ERROR_INVALID_DEVICE;
+        }
+
+        psLINFBInfo = registered_fb[fb_idx];
+
+        /* Check the framebuffer width and height are valid */
+        if(psLINFBInfo->var.xres <= 0 || psLINFBInfo->var.yres <= 0)
+        {
+                ERROR_PRINTK("Framebuffer %i has an invalid state, "
+                        "width and height are %u,%u", fb_idx,
+                        psLINFBInfo->var.xres, psLINFBInfo->var.yres);
+                return OMAP_ERROR_INVALID_DEVICE;
+        }
+
+        /* Configure framebuffer for flipping and desired bpp */
+        psLINFBInfo->var.yres_virtual = psLINFBInfo->var.yres *
+                MAX_BUFFERS_FLIPPING;
+
+        if(DESIRED_BPP != 0){
+                psLINFBInfo->var.bits_per_pixel = DESIRED_BPP;
+                if(DESIRED_BPP == 16){
+                        psLINFBInfo->var.red.offset     = 11;
+                        psLINFBInfo->var.red.length     = 5;
+                        psLINFBInfo->var.green.offset   = 5;
+                        psLINFBInfo->var.green.length   = 6;
+                        psLINFBInfo->var.blue.offset    = 0;
+                        psLINFBInfo->var.blue.length    = 5;
+                        psLINFBInfo->var.transp.offset  = 0;
+                        psLINFBInfo->var.transp.length  = 0;
+                }
+                else if(DESIRED_BPP == 32)
+                {
+                        psLINFBInfo->var.red.offset     = 16;
+                        psLINFBInfo->var.red.length     = 8;
+                        psLINFBInfo->var.green.offset   = 8;
+                        psLINFBInfo->var.green.length   = 8;
+                        psLINFBInfo->var.blue.offset    = 0;
+                        psLINFBInfo->var.blue.length    = 8;
+                        psLINFBInfo->var.transp.offset  = 0;
+                        psLINFBInfo->var.transp.length  = 0;
+                }
+                else
+                        WARNING_PRINTK("Unknown bits per pixel format %i",
+                                DESIRED_BPP);
+        }
+        acquire_console_sem();
+        psLINFBInfo->var.activate = FB_ACTIVATE_FORCE;
+        fb_set_var(psLINFBInfo, &psLINFBInfo->var);
+        buffers_available =
+                psLINFBInfo->var.yres_virtual / psLINFBInfo->var.yres;
+
+        if(buffers_available <= 1)
+        {
+                /*
+                 * Flipping is not supported, return the framebuffer to
+                 * its original state
+                 */
+                psLINFBInfo->var.yres_virtual = psLINFBInfo->var.yres;
+                psLINFBInfo->var.activate = FB_ACTIVATE_FORCE;
+                fb_set_var(psLINFBInfo, &psLINFBInfo->var);
+                buffers_available = 1;
+        }
+        psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers = buffers_available;
+
+        psLINFBOwner = psLINFBInfo->fbops->owner;
+        if (!try_module_get(psLINFBOwner))
+        {
+                ERROR_PRINTK("Couldn't get framebuffer module");
+                release_console_sem();
+                return OMAP_ERROR_GENERIC;
+        }
+
+        if (psLINFBInfo->fbops->fb_open != NULL)
+        {
+                if (psLINFBInfo->fbops->fb_open(psLINFBInfo, 0))
+                {
+                        ERROR_PRINTK("Couldn't open framebuffer with"
+                                " index %d", fb_idx);
+                        module_put(psLINFBOwner);
+                        release_console_sem();
+                        return OMAP_ERROR_GENERIC;
+                }
+        }
+        psDevInfo->psLINFBInfo = psLINFBInfo;
+
+        /* Extract the needed data from the framebuffer structures */
+        FBSize = (psLINFBInfo->screen_size) != 0 ?
+                psLINFBInfo->screen_size : psLINFBInfo->fix.smem_len;
+        DEBUG_PRINTK("Framebuffer index %d information:", fb_idx);
+        DEBUG_PRINTK("*Physical address: 0x%lx",
+                psLINFBInfo->fix.smem_start);
+        DEBUG_PRINTK("*Virtual address: 0x%lx",
+                (unsigned long)psLINFBInfo->screen_base);
+        DEBUG_PRINTK("*Size (bytes): %lu",FBSize);
+        DEBUG_PRINTK("*Width, height: %u,%u",
+                psLINFBInfo->var.xres, psLINFBInfo->var.yres);
+        DEBUG_PRINTK("*Virtual width, height: %u,%u",
+                psLINFBInfo->var.xres_virtual, psLINFBInfo->var.yres_virtual);
+        DEBUG_PRINTK("*Rotation: %u", psLINFBInfo->var.rotate);
+        DEBUG_PRINTK("*Stride (bytes): %u",
+                (unsigned int)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;
+
+        /* XXX: Page aligning with 16bpp causes the
+         * position of framebuffer address to look in the wrong place.
+         */
+        psPVRFBInfo->ulRoundedBufferSize =
+                        OMAPLFB_PAGE_ROUNDUP(psPVRFBInfo->ulBufferSize);
+
+        psDevInfo->sFBInfo.sSysAddr.uiAddr = psPVRFBInfo->sSysAddr.uiAddr;
+        psDevInfo->sFBInfo.sCPUVAddr = psPVRFBInfo->sCPUVAddr;
+
+        /* Get the current bits per pixel configured in the framebuffer */
+        DEBUG_PRINTK("*Bits per pixel: %d", psLINFBInfo->var.bits_per_pixel);
+        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))
+                {
+                        DEBUG_PRINTK("*Format: RGB565");
+                        psPVRFBInfo->ePixelFormat = PVRSRV_PIXEL_FORMAT_RGB565;
+                }
+                else
+                        WARNING_PRINTK("*Format: Unknown framebuffer"
+                                " format");
+        }
+        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;
+                        DEBUG_PRINTK("*Format: ARGB8888");
+                }
+                else
+                        WARNING_PRINTK("*Format: Unknown framebuffer"
+                                "format");
+        }       
+        else
+                WARNING_PRINTK("*Format: Unknown framebuffer format");
+
+        release_console_sem();
+        return OMAP_OK;
+}
+
+/*
+ *  Initialization routine for the 3rd party display driver
+ */
+OMAP_ERROR OMAPLFBInit(void)
+{
+        OMAPLFB_DEVINFO *psDevInfo;
+        PFN_CMD_PROC pfnCmdProcList[OMAPLFB_COMMAND_COUNT];
+        IMG_UINT32 aui32SyncCountList[OMAPLFB_COMMAND_COUNT][2];
+        int i;
+
+        DEBUG_PRINTK("Initializing 3rd party display driver");
+        DEBUG_PRINTK("Found %u framebuffers", FRAMEBUFFER_COUNT);
+
+#if defined(REQUIRES_TWO_FRAMEBUFFERS)
+        /*
+         * Fail hard if there isn't at least two framebuffers available
+         */
+        if(FRAMEBUFFER_COUNT < 2)
+        {
+                ERROR_PRINTK("Driver needs at least two framebuffers");
+                return OMAP_ERROR_INIT_FAILURE;
+        }
+#endif
+
+        /*
+         * Obtain the function pointer for the jump table from
+         * services to fill it with the function pointers that we want
+         */
+        if(OMAPLFBGetLibFuncAddr ("PVRGetDisplayClassJTable",
+                &pfnGetPVRJTable) != OMAP_OK)
+        {
+                ERROR_PRINTK("Unable to get the function to get the"
+                        " jump table display->services");
+                return OMAP_ERROR_INIT_FAILURE;
+        }
+
+        /*
+         * Allocate the display device structures, one per framebuffer
+         */
+        pDisplayDevices = (OMAPLFB_DEVINFO *)OMAPLFBAllocKernelMem(
+                        sizeof(OMAPLFB_DEVINFO) * FRAMEBUFFER_COUNT);
+        if(!pDisplayDevices)
+        {
+                pDisplayDevices = NULL;
+                ERROR_PRINTK("Out of memory");
+                return OMAP_ERROR_OUT_OF_MEMORY;
+        }
+        memset(pDisplayDevices, 0, sizeof(OMAPLFB_DEVINFO) *
+                FRAMEBUFFER_COUNT);
+
+        /*
+         * Initialize each display device
+         */
+        for (i = FRAMEBUFFER_COUNT - 1; i >= 0; i--)
+        {
+                DEBUG_PRINTK("-> Initializing display device %i", i);
+                /*
+                 * Here we get the framebuffer data for each display device
+                 * and check for error
+                 */
+                if(InitDev(&pDisplayDevices[i], i) != OMAP_OK)
+                {
+                        ERROR_PRINTK("Unable to initialize display "
+                                "device %i",i);
+                        OMAPLFBFreeKernelMem(pDisplayDevices);
+                        pDisplayDevices = NULL;
+                        return OMAP_ERROR_INIT_FAILURE;
+                }
+
+                /*
+                 * Populate each display device structure
+                */
+                DEBUG_PRINTK("-> Populating display device %i", i);
+                psDevInfo = &pDisplayDevices[i];
+
+                if(!(*pfnGetPVRJTable)(&psDevInfo->sPVRJTable))
+                {
+                        ERROR_PRINTK("Unable to get the jump table"
+                                " display->services");
+                        return OMAP_ERROR_INIT_FAILURE;
+                }
+
+                mutex_init(&psDevInfo->sSwapChainLockMutex);
+
+                psDevInfo->psSwapChain = 0;
+                psDevInfo->bFlushCommands = OMAP_FALSE;
+                psDevInfo->bDeviceSuspended = OMAP_FALSE;
+
+                if(psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers > 1)
+                {
+                        if(MAX_BUFFERS_FLIPPING == 1)
+                        {
+                                DEBUG_PRINTK("Flipping support is possible"
+                                        " but you decided not to use it, "
+                                        "no swap chain will be created");
+                        }
+
+                        DEBUG_PRINTK("Flipping support");
+                        if(psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers >
+                                MAX_BUFFERS_FLIPPING)
+                        psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers =
+                                MAX_BUFFERS_FLIPPING;
+                }
+                else
+                {
+                        DEBUG_PRINTK("Flipping not supported, no swap chain"
+                                " will be created");
+                }
+
+                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;
+
+                /* Get the display and framebuffer needed info */
+                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;
+                psDevInfo->sSystemBuffer.sSysAddr =
+                        psDevInfo->sFBInfo.sSysAddr;
+                psDevInfo->sSystemBuffer.sCPUVAddr =
+                        psDevInfo->sFBInfo.sCPUVAddr;
+                psDevInfo->sSystemBuffer.ulBufferSize =
+                        psDevInfo->sFBInfo.ulRoundedBufferSize;
+                DEBUG_PRINTK("Buffers available: %u (%lu bytes per buffer)",
+                        psDevInfo->sDisplayInfo.ui32MaxSwapChainBuffers,
+                        psDevInfo->sFBInfo.ulBufferSize);
+
+                /* Populate the function table that services will use */
+                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;
+
+                /* Register the display device */
+                if(psDevInfo->sPVRJTable.pfnPVRSRVRegisterDCDevice(
+                        &psDevInfo->sDCJTable,
+                        &psDevInfo->uDeviceID) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to register the jump table"
+                                " services->display");
+                        return OMAP_ERROR_DEVICE_REGISTER_FAILED;
+                }
+
+                DEBUG_PRINTK("Display device %i registered with id %u",
+                        i, psDevInfo->uDeviceID);
+
+                /*
+                 * Register the ProcessFlip function to notify when a frame is
+                 * ready to be flipped
+                 */
+                pfnCmdProcList[DC_FLIP_COMMAND] = ProcessFlip;
+                aui32SyncCountList[DC_FLIP_COMMAND][0] = 0;
+                aui32SyncCountList[DC_FLIP_COMMAND][1] = 2;
+                if (psDevInfo->sPVRJTable.pfnPVRSRVRegisterCmdProcList(
+                        psDevInfo->uDeviceID, &pfnCmdProcList[0],
+                        aui32SyncCountList, OMAPLFB_COMMAND_COUNT) != PVRSRV_OK)
+                {
+                        ERROR_PRINTK("Unable to register callback for "
+                                "ProcessFlip command");
+                        return OMAP_ERROR_CANT_REGISTER_CALLBACK;
+                }
+
+        }
+        return OMAP_OK;
+}
+
diff --git a/drivers/gpu/pvr/omaplfb/omaplfb_linux.c b/drivers/gpu/pvr/omaplfb/omaplfb_linux.c
new file mode 100644
index 00000000000..4f1ac9b0da5
--- /dev/null
+++ b/drivers/gpu/pvr/omaplfb/omaplfb_linux.c
@@ -0,0 +1,437 @@
+/**********************************************************************
+ *
+ * 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 <asm/io.h>
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
+#include <plat/vrfb.h>
+#include <plat/display.h>
+#else
+#include <mach/vrfb.h>
+#include <mach/display.h>
+#endif
+
+#ifdef RELEASE
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#undef DEBUG
+#else
+#undef DEBUG
+#include <../drivers/video/omap2/omapfb/omapfb.h>
+#endif
+
+#if defined(CONFIG_OUTER_CACHE)  /* Kernel config option */
+#include <asm/cacheflush.h>
+#define HOST_PAGESIZE                   (4096)
+#define HOST_PAGEMASK                   (~(HOST_PAGESIZE-1))
+#define HOST_PAGEALIGN(addr)    (((addr)+HOST_PAGESIZE-1)&HOST_PAGEMASK)
+#endif
+
+#if defined(LDM_PLATFORM)
+#include <linux/platform_device.h>
+#if defined(SGX_EARLYSUSPEND)
+#include <linux/earlysuspend.h>
+#endif
+#endif
+
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "kerneldisplay.h"
+#include "omaplfb.h"
+#include "pvrmodule.h"
+
+MODULE_SUPPORTED_DEVICE(DEVNAME);
+
+#if defined(CONFIG_OUTER_CACHE)  /* Kernel config option */
+#if defined(__arm__)
+static void per_cpu_cache_flush_arm(void *arg)
+{
+    PVR_UNREFERENCED_PARAMETER(arg);
+    flush_cache_all();
+}
+#endif
+#endif
+
+/*
+ * Kernel malloc
+ * in: ui32ByteSize
+ */
+void *OMAPLFBAllocKernelMem(unsigned long ui32ByteSize)
+{
+        void *p;
+
+#if defined(CONFIG_OUTER_CACHE)  /* Kernel config option */
+        IMG_VOID *pvPageAlignedCPUPAddr;
+        IMG_VOID *pvPageAlignedCPUVAddr;
+        IMG_UINT32 ui32PageOffset;
+        IMG_UINT32 ui32PageCount;
+#endif
+        p = kmalloc(ui32ByteSize, GFP_KERNEL);
+
+        if(!p)
+                return 0;
+
+#if defined(CONFIG_OUTER_CACHE)  /* Kernel config option */
+        ui32PageOffset = (IMG_UINT32) p & (HOST_PAGESIZE - 1);
+        ui32PageCount = HOST_PAGEALIGN(ui32ByteSize + ui32PageOffset) / HOST_PAGESIZE;
+
+        pvPageAlignedCPUVAddr = (IMG_VOID *)((IMG_UINT8 *)p - ui32PageOffset);
+        pvPageAlignedCPUPAddr = (IMG_VOID*) __pa(pvPageAlignedCPUVAddr);
+
+#if defined(__arm__)
+      on_each_cpu(per_cpu_cache_flush_arm, NULL, 1);
+#endif
+        outer_cache.flush_range((unsigned long) pvPageAlignedCPUPAddr, (unsigned long) ((pvPageAlignedCPUPAddr + HOST_PAGESIZE*ui32PageCount) - 1));
+#endif
+        return p;
+}
+
+/*
+ * Kernel free
+ * in: pvMem
+ */
+void OMAPLFBFreeKernelMem(void *pvMem)
+{
+        kfree(pvMem);
+}
+
+/*
+ * Here we get the function pointer to get jump table from
+ * services using an external function.
+ * in: szFunctionName
+ * out: ppfnFuncTable
+ */
+OMAP_ERROR OMAPLFBGetLibFuncAddr (char *szFunctionName,
+        PFN_DC_GET_PVRJTABLE *ppfnFuncTable)
+{
+        if(strcmp("PVRGetDisplayClassJTable", szFunctionName) != 0)
+        {
+                ERROR_PRINTK("Unable to get function pointer for %s"
+                        " from services", szFunctionName);
+                return OMAP_ERROR_INVALID_PARAMS;
+        }
+        *ppfnFuncTable = PVRGetDisplayClassJTable;
+
+        return OMAP_OK;
+}
+
+
+#if defined(FLIP_TECHNIQUE_FRAMEBUFFER)
+/*
+ * Presents the flip in the display with the framebuffer API
+ * in: psSwapChain, aPhyAddr
+ */
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr)
+{
+        OMAPLFB_DEVINFO *psDevInfo = (OMAPLFB_DEVINFO *)psSwapChain->pvDevInfo;
+        struct fb_info * framebuffer = psDevInfo->psLINFBInfo;
+        struct omapfb_info *ofbi = FB2OFB(framebuffer);
+        struct omapfb2_device *fbdev = ofbi->fbdev;
+        /* Get the framebuffer physical address base */
+        unsigned long fb_base_phyaddr =
+                psDevInfo->sSystemBuffer.sSysAddr.uiAddr;
+
+        omapfb_lock(fbdev);
+
+        /* Calculate the virtual Y to move in the framebuffer */
+        framebuffer->var.yoffset =
+                (aPhyAddr - fb_base_phyaddr) / framebuffer->fix.line_length;
+        framebuffer->var.activate = FB_ACTIVATE_FORCE;
+        fb_set_var(framebuffer, &framebuffer->var);
+
+        omapfb_unlock(fbdev);
+}
+
+#elif defined(FLIP_TECHNIQUE_OVERLAY)
+/*
+ * Presents the flip in the display with the DSS2 overlay API
+ * in: psSwapChain, aPhyAddr
+ */
+void OMAPLFBFlip(OMAPLFB_SWAPCHAIN *psSwapChain, unsigned long aPhyAddr)
+{
+        OMAPLFB_DEVINFO *psDevInfo = (OMAPLFB_DEVINFO *)psSwapChain->pvDevInfo;
+        struct fb_info * framebuffer = psDevInfo->psLINFBInfo;
+        struct omapfb_info *ofbi = FB2OFB(framebuffer);
+        struct omapfb2_device *fbdev = ofbi->fbdev;
+        unsigned long fb_offset =
+                aPhyAddr - psDevInfo->sSystemBuffer.sSysAddr.uiAddr;
+        struct omap_overlay* overlay;
+        struct omap_overlay_info overlay_info;
+        int i;
+
+        fb_offset = aPhyAddr - psDevInfo->sSystemBuffer.sSysAddr.uiAddr;
+
+        omapfb_lock(fbdev);
+
+        for(i = 0; i < ofbi->num_overlays ; i++)
+        {
+                overlay = ofbi->overlays[i];
+                overlay->get_overlay_info( overlay, &overlay_info );
+
+                /* If the overlay is not enabled don't update it */
+                if(!overlay_info.enabled)
+                        continue;
+
+                overlay_info.paddr = framebuffer->fix.smem_start + fb_offset;
+                overlay_info.vaddr = framebuffer->screen_base + fb_offset;
+                overlay->set_overlay_info(overlay, &overlay_info);
+                overlay->manager->apply(overlay->manager);
+
+#if 0
+                /* FIXME: Update call takes a long time in 2.6.35.
+                 *        Needs to be resolved in the display driver
+                 *        before we can enable this.
+                 */
+                if(overlay->manager->device->driver->update)
+                {
+                        overlay->manager->device->driver->update(
+                                overlay->manager->device, 0, 0,
+                                overlay_info.width,
+                                overlay_info.height);
+                }
+#endif
+
+        }
+
+        omapfb_unlock(fbdev);
+}
+
+#else
+#error No flipping technique selected, please define \
+        FLIP_TECHNIQUE_FRAMEBUFFER or FLIP_TECHNIQUE_OVERLAY
+#endif
+
+/*
+ * Synchronize with the display to prevent tearing
+ * On DSI panels the display->sync function is used to handle FRAMEDONE IRQ
+ * On DPI panels the display->wait_vsync is used to handle VSYNC IRQ
+ * in: psDevInfo
+ */
+void OMAPLFBWaitForSync(OMAPLFB_DEVINFO *psDevInfo)
+{
+        struct fb_info * framebuffer = psDevInfo->psLINFBInfo;
+        struct omap_dss_device *display = fb2display(framebuffer);
+        if (display)
+        {
+                display->manager->wait_for_vsync(display->manager);
+        }
+}
+
+#if defined(LDM_PLATFORM)
+
+static volatile OMAP_BOOL bDeviceSuspended;
+
+/*
+ * Common suspend driver function
+ * in: psSwapChain, aPhyAddr
+ */
+static void OMAPLFBCommonSuspend(void)
+{
+        if (bDeviceSuspended)
+        {
+                DEBUG_PRINTK("Driver is already suspended");
+                return;
+        }
+
+        OMAPLFBDriverSuspend();
+        bDeviceSuspended = OMAP_TRUE;
+}
+
+#if 0
+/*
+ * Function called when the driver is requested to release
+ * in: pDevice
+ */
+static void OMAPLFBDeviceRelease_Entry(struct device unref__ *pDevice)
+{
+        DEBUG_PRINTK("Requested driver release");
+        OMAPLFBCommonSuspend();
+}
+
+static struct platform_device omaplfb_device = {
+        .name = DEVNAME,
+        .id = -1,
+        .dev = {
+                .release = OMAPLFBDeviceRelease_Entry
+        }
+};
+#endif
+
+#if defined(SGX_EARLYSUSPEND)
+
+static struct early_suspend omaplfb_early_suspend;
+
+/*
+ * Android specific, driver is requested to be suspended
+ * in: ea_event
+ */
+static void OMAPLFBDriverSuspend_Entry(struct early_suspend *ea_event)
+{
+        DEBUG_PRINTK("Requested driver suspend");
+        OMAPLFBCommonSuspend();
+}
+
+/*
+ * Android specific, driver is requested to be suspended
+ * in: ea_event
+ */
+static void OMAPLFBDriverResume_Entry(struct early_suspend *ea_event)
+{
+        DEBUG_PRINTK("Requested driver resume");
+        OMAPLFBDriverResume();
+        bDeviceSuspended = OMAP_FALSE;
+}
+
+static struct platform_driver omaplfb_driver = {
+        .driver = {
+                .name = DRVNAME,
+        }
+};
+
+#else /* defined(SGX_EARLYSUSPEND) */
+
+/*
+ * Function called when the driver is requested to be suspended
+ * in: pDevice, state
+ */
+static int OMAPLFBDriverSuspend_Entry(struct platform_device unref__ *pDevice,
+        pm_message_t unref__ state)
+{
+        DEBUG_PRINTK("Requested driver suspend");
+        OMAPLFBCommonSuspend();
+        return 0;
+}
+
+/*
+ * Function called when the driver is requested to resume
+ * in: pDevice
+ */
+static int OMAPLFBDriverResume_Entry(struct platform_device unref__ *pDevice)
+{
+        DEBUG_PRINTK("Requested driver resume");
+        OMAPLFBDriverResume();
+        bDeviceSuspended = OMAP_FALSE;
+        return 0;
+}
+
+/*
+ * Function called when the driver is requested to shutdown
+ * in: pDevice
+ */
+static IMG_VOID OMAPLFBDriverShutdown_Entry(
+        struct platform_device unref__ *pDevice)
+{
+        DEBUG_PRINTK("Requested driver shutdown");
+        OMAPLFBCommonSuspend();
+}
+
+static struct platform_driver omaplfb_driver = {
+        .driver = {
+                .name = DRVNAME,
+        },
+        .suspend = OMAPLFBDriverSuspend_Entry,
+        .resume = OMAPLFBDriverResume_Entry,
+        .shutdown = OMAPLFBDriverShutdown_Entry,
+};
+
+#endif /* defined(SGX_EARLYSUSPEND) */
+
+#endif /* defined(LDM_PLATFORM) */
+
+/*
+ * Driver init function
+ */
+static int __init OMAPLFB_Init(void)
+{
+        if(OMAPLFBInit() != OMAP_OK)
+        {
+                WARNING_PRINTK("Driver init failed");
+                return -ENODEV;
+        }
+
+#if defined(LDM_PLATFORM)
+        DEBUG_PRINTK("Registering platform driver");
+        if (platform_driver_register(&omaplfb_driver))
+        {
+                WARNING_PRINTK("Unable to register platform driver");
+                if(OMAPLFBDeinit() != OMAP_OK)
+                        WARNING_PRINTK("Driver cleanup failed\n");
+                return -ENODEV;
+        }
+#if 0
+        DEBUG_PRINTK("Registering device driver");
+        if (platform_device_register(&omaplfb_device))
+        {
+                WARNING_PRINTK("Unable to register platform device");
+                platform_driver_unregister(&omaplfb_driver);
+                if(OMAPLFBDeinit() != OMAP_OK)
+                        WARNING_PRINTK("Driver cleanup failed\n");
+                return -ENODEV;
+        }
+#endif
+
+#if defined(SGX_EARLYSUSPEND)
+        omaplfb_early_suspend.suspend = OMAPLFBDriverSuspend_Entry;
+        omaplfb_early_suspend.resume = OMAPLFBDriverResume_Entry;
+        omaplfb_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
+        register_early_suspend(&omaplfb_early_suspend);
+        DEBUG_PRINTK("Registered early suspend support");
+#endif
+
+#endif
+        return 0;
+}
+
+/*
+ * Driver exit function
+ */
+static IMG_VOID __exit OMAPLFB_Cleanup(IMG_VOID)
+{    
+#if defined(LDM_PLATFORM)
+#if 0
+        DEBUG_PRINTK(format,...)("Removing platform device");
+        platform_device_unregister(&omaplfb_device);
+#endif
+        DEBUG_PRINTK("Removing platform driver");
+        platform_driver_unregister(&omaplfb_driver);
+#if defined(SGX_EARLYSUSPEND)
+        unregister_early_suspend(&omaplfb_early_suspend);
+#endif
+#endif
+        if(OMAPLFBDeinit() != OMAP_OK)
+                WARNING_PRINTK("Driver cleanup failed");
+}
+
+late_initcall(OMAPLFB_Init);
+module_exit(OMAPLFB_Cleanup);
+
diff --git a/drivers/gpu/pvr/osfunc.c b/drivers/gpu/pvr/osfunc.c
new file mode 100644
index 00000000000..e465228de64
--- /dev/null
+++ b/drivers/gpu/pvr/osfunc.c
@@ -0,0 +1,2906 @@
+/**********************************************************************
+ *
+ * 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 <asm/io.h>
+#include <asm/page.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#include <asm/system.h>
+#endif
+#include <asm/cacheflush.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/hugetlb.h> 
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <asm/hardirq.h>
+#include <linux/timer.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) || \
+        defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || \
+        defined(PVR_LINUX_USING_WORKQUEUES)
+#include <linux/workqueue.h>
+#endif
+
+#include "img_types.h"
+#include "services_headers.h"
+#include "mm.h"
+#include "pvrmmap.h"
+#include "mmap.h"
+#include "env_data.h"
+#include "proc.h"
+#include "mutex.h"
+#include "event.h"
+#include "linkage.h"
+#include "pvr_uaccess.h"
+
+#define EVENT_OBJECT_TIMEOUT_MS         (100)
+
+#define HOST_ALLOC_MEM_USING_KMALLOC ((IMG_HANDLE)0)
+#define HOST_ALLOC_MEM_USING_VMALLOC ((IMG_HANDLE)1)
+
+#if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc)
+#else
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+#endif
+{
+    PVR_UNREFERENCED_PARAMETER(ui32Flags);
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    *ppvCpuVAddr = _KMallocWrapper(ui32Size, pszFilename, ui32Line);
+#else
+    *ppvCpuVAddr = KMallocWrapper(ui32Size);
+#endif
+    if(*ppvCpuVAddr)
+    {
+    if (phBlockAlloc)
+    {
+        
+        *phBlockAlloc = HOST_ALLOC_MEM_USING_KMALLOC;
+    }
+    }
+    else
+    {
+    if (!phBlockAlloc)
+    {
+        return PVRSRV_ERROR_OUT_OF_MEMORY;
+    }
+
+    
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    *ppvCpuVAddr = _VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED, pszFilename, ui32Line);
+#else
+    *ppvCpuVAddr = VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED);
+#endif
+    if (!*ppvCpuVAddr)
+    {
+         return PVRSRV_ERROR_OUT_OF_MEMORY;
+    }
+
+    
+    *phBlockAlloc = HOST_ALLOC_MEM_USING_VMALLOC;
+    }
+
+    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 OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+#endif
+{       
+    PVR_UNREFERENCED_PARAMETER(ui32Flags);
+    PVR_UNREFERENCED_PARAMETER(ui32Size);
+
+    if (hBlockAlloc == HOST_ALLOC_MEM_USING_VMALLOC)
+    {
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    _VFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
+#else
+    VFreeWrapper(pvCpuVAddr);
+#endif
+    }
+    else
+    {
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    _KFreeWrapper(pvCpuVAddr, pszFilename, ui32Line);
+#else
+        KFreeWrapper(pvCpuVAddr);
+#endif
+    }
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR
+OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
+                                  IMG_UINT32 ui32Size,
+                                  IMG_UINT32 ui32PageSize,
+                                  IMG_VOID **ppvCpuVAddr,
+                                  IMG_HANDLE *phOSMemHandle)
+{
+    LinuxMemArea *psLinuxMemArea;
+
+    PVR_UNREFERENCED_PARAMETER(ui32PageSize);
+
+#if 0
+    
+    if(ui32AllocFlags & PVRSRV_HAP_SINGLE_PROCESS)
+    {
+        ui32AllocFlags &= ~PVRSRV_HAP_SINGLE_PROCESS;
+        ui32AllocFlags |= PVRSRV_HAP_MULTI_PROCESS;
+    }
+#endif
+
+    switch(ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+        {
+            psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+            }
+            break;
+        }
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        {
+            
+            
+            psLinuxMemArea = NewAllocPagesLinuxMemArea(ui32Size, ui32AllocFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+            }
+            PVRMMapRegisterArea(psLinuxMemArea);
+            break;
+        }
+
+        case PVRSRV_HAP_MULTI_PROCESS:
+        {
+            
+#if defined(VIVT_CACHE) || defined(__sh__)
+            
+            ui32AllocFlags &= ~PVRSRV_HAP_CACHED;
+#endif
+            psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+            }
+            PVRMMapRegisterArea(psLinuxMemArea);
+            break;
+        }
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "OSAllocPages: invalid flags 0x%x\n", ui32AllocFlags));
+            *ppvCpuVAddr = NULL;
+            *phOSMemHandle = (IMG_HANDLE)0;
+            return PVRSRV_ERROR_INVALID_PARAMS;
+    }
+
+    *ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
+    *phOSMemHandle = psLinuxMemArea;
+    
+    LinuxMemAreaRegister(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR
+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);
+    
+    psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+    switch(ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+            break;
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        case PVRSRV_HAP_MULTI_PROCESS:
+            eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+            if (eError != PVRSRV_OK)
+            {
+                PVR_DPF((PVR_DBG_ERROR,
+                         "OSFreePages(ui32AllocFlags=0x%08X, ui32Bytes=%d, "
+                                        "pvCpuVAddr=%p, hOSMemHandle=%p) FAILED!",
+                         ui32AllocFlags, ui32Bytes, pvCpuVAddr, hOSMemHandle));
+                return eError;
+            }
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR,"%s: invalid flags 0x%x\n",
+                    __FUNCTION__, ui32AllocFlags));
+            return PVRSRV_ERROR_INVALID_PARAMS;
+    }
+
+    LinuxMemAreaDeepFree(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR
+OSGetSubMemHandle(IMG_HANDLE hOSMemHandle,
+                  IMG_UINT32 ui32ByteOffset,
+                  IMG_UINT32 ui32Bytes,
+                  IMG_UINT32 ui32Flags,
+                  IMG_HANDLE *phOSMemHandleRet)
+{
+    LinuxMemArea *psParentLinuxMemArea, *psLinuxMemArea;
+    PVRSRV_ERROR eError;
+
+    psParentLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+    
+    psLinuxMemArea = NewSubLinuxMemArea(psParentLinuxMemArea, ui32ByteOffset, ui32Bytes);
+    if(!psLinuxMemArea)
+    {
+        *phOSMemHandleRet = NULL;
+        return PVRSRV_ERROR_OUT_OF_MEMORY;
+    }
+    *phOSMemHandleRet = psLinuxMemArea;
+
+    
+    if(ui32Flags & PVRSRV_HAP_KERNEL_ONLY)
+    {
+        return PVRSRV_OK;
+    }
+
+    eError = PVRMMapRegisterArea(psLinuxMemArea);
+    if(eError != PVRSRV_OK)
+     {
+        goto failed_register_area;
+    }
+
+    return PVRSRV_OK;
+
+failed_register_area:
+    *phOSMemHandleRet = NULL;
+    LinuxMemAreaDeepFree(psLinuxMemArea);
+    return eError;
+}
+
+PVRSRV_ERROR
+OSReleaseSubMemHandle(IMG_VOID *hOSMemHandle, IMG_UINT32 ui32Flags)
+{
+    LinuxMemArea *psLinuxMemArea;
+    PVRSRV_ERROR eError;
+    
+    psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+    PVR_ASSERT(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC);
+    
+    if((ui32Flags & PVRSRV_HAP_KERNEL_ONLY) == 0)
+    {
+        eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
+        if(eError != PVRSRV_OK)
+        {
+            return eError;
+        }
+    }
+    LinuxMemAreaDeepFree(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+
+IMG_CPU_PHYADDR
+OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_UINT32 ui32ByteOffset)
+{
+    PVR_ASSERT(hOSMemHandle);
+
+    return LinuxMemAreaToCpuPAddr(hOSMemHandle, ui32ByteOffset);
+}
+
+
+
+IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_UINT32 ui32Size)
+{
+#if defined(USE_UNOPTIMISED_MEMCPY)
+    IMG_UINT8 *Src,*Dst;
+    IMG_INT i;
+
+    Src=(IMG_UINT8 *)pvSrc;
+    Dst=(IMG_UINT8 *)pvDst;
+    for(i=0;i<ui32Size;i++)
+    {
+        Dst[i]=Src[i];
+    }
+#else
+    memcpy(pvDst, pvSrc, ui32Size);
+#endif
+}
+
+
+IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_UINT32 ui32Size)
+{
+#if defined(USE_UNOPTIMISED_MEMSET)
+    IMG_UINT8 *Buff;
+    IMG_INT i;
+
+    Buff=(IMG_UINT8 *)pvDest;
+    for(i=0;i<ui32Size;i++)
+    {
+        Buff[i]=ui8Value;
+    }
+#else
+    memset(pvDest, (IMG_INT) ui8Value, (size_t) ui32Size);
+#endif
+}
+
+
+IMG_CHAR *OSStringCopy(IMG_CHAR *pszDest, const IMG_CHAR *pszSrc)
+{
+    return (strcpy(pszDest, pszSrc));
+}
+
+IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_UINT32 ui32Size, const IMG_CHAR *pszFormat, ...)
+{
+    va_list argList;
+    IMG_INT32 iCount;
+
+    va_start(argList, pszFormat);
+    iCount = vsnprintf(pStr, (size_t)ui32Size, pszFormat, argList);
+    va_end(argList);
+
+    return iCount;
+}
+
+IMG_VOID OSBreakResourceLock (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+{
+    volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+
+    if(*pui32Access)
+    {
+        if(psResource->ui32ID == ui32ID)
+        {
+            psResource->ui32ID = 0;
+            *pui32Access = 0;
+        }
+        else
+        {
+            PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked for this process.")); 
+        }
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_MESSAGE,"OSBreakResourceLock: Resource is not locked"));
+    }
+}
+
+
+PVRSRV_ERROR OSCreateResource(PVRSRV_RESOURCE *psResource)
+{
+    psResource->ui32ID = 0;
+    psResource->ui32Lock = 0;
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSDestroyResource (PVRSRV_RESOURCE *psResource)
+{
+    OSBreakResourceLock (psResource, psResource->ui32ID);
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSInitEnvData(IMG_PVOID *ppvEnvSpecificData)
+{
+    ENV_DATA            *psEnvData;
+    PVRSRV_ERROR        eError;
+    
+    
+    eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), (IMG_VOID **)&psEnvData, IMG_NULL,
+        "Environment Data");
+    if (eError != PVRSRV_OK)
+    {
+        return eError;
+    }
+
+    eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE, 
+                    &psEnvData->pvBridgeData, IMG_NULL,
+                    "Bridge Data");
+    if (eError != PVRSRV_OK)
+    {
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), psEnvData, IMG_NULL);
+                
+        return eError;
+    }
+
+
+    
+    psEnvData->bMISRInstalled = IMG_FALSE;
+    psEnvData->bLISRInstalled = IMG_FALSE;
+
+    
+    *ppvEnvSpecificData = psEnvData;
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSDeInitEnvData(IMG_PVOID pvEnvSpecificData)
+{
+    ENV_DATA            *psEnvData = (ENV_DATA*)pvEnvSpecificData;
+
+    PVR_ASSERT(!psEnvData->bMISRInstalled);
+    PVR_ASSERT(!psEnvData->bLISRInstalled);
+
+    OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, PVRSRV_MAX_BRIDGE_IN_SIZE + PVRSRV_MAX_BRIDGE_OUT_SIZE, psEnvData->pvBridgeData, IMG_NULL);
+    psEnvData->pvBridgeData = IMG_NULL;
+
+    OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(ENV_DATA), pvEnvSpecificData, IMG_NULL);
+        
+
+    return PVRSRV_OK;
+}
+
+
+ 
+IMG_VOID OSReleaseThreadQuanta(IMG_VOID)
+{
+    schedule();
+}
+
+
+ 
+IMG_UINT32 OSClockus(IMG_VOID)
+{
+    IMG_UINT32 time, j = jiffies;
+
+    time = j * (1000000 / HZ);
+
+    return time;
+}
+
+
+ 
+IMG_VOID OSWaitus(IMG_UINT32 ui32Timeus)
+{
+    udelay(ui32Timeus);
+}
+
+
+IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID)
+{
+    if (in_interrupt())
+    {
+        return KERNEL_ID;
+    }
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+    return (IMG_UINT32)current->pgrp;
+#else
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
+    return (IMG_UINT32)task_tgid_nr(current);
+#else
+    return (IMG_UINT32)current->tgid;
+#endif
+#endif
+}
+
+
+IMG_UINT32 OSGetPageSize(IMG_VOID)
+{
+#if defined(__sh__)
+    IMG_UINT32 ui32ReturnValue = PAGE_SIZE;
+
+    return (ui32ReturnValue);
+#else
+    return PAGE_SIZE;
+#endif
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
+static irqreturn_t DeviceISRWrapper(int irq, void *dev_id
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+        , struct pt_regs *regs
+#endif
+        )
+{
+    PVRSRV_DEVICE_NODE *psDeviceNode;
+    IMG_BOOL bStatus = IMG_FALSE;
+
+    PVR_UNREFERENCED_PARAMETER(irq);
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+    PVR_UNREFERENCED_PARAMETER(regs);
+#endif  
+    psDeviceNode = (PVRSRV_DEVICE_NODE*)dev_id;
+    if(!psDeviceNode)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "DeviceISRWrapper: invalid params\n"));
+        goto out;
+    }
+
+    bStatus = PVRSRVDeviceLISR(psDeviceNode);
+
+    if (bStatus)
+    {
+                OSScheduleMISR((IMG_VOID *)psDeviceNode->psSysData);
+    }
+
+out:
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+    return bStatus ? IRQ_HANDLED : IRQ_NONE;
+#endif
+}
+
+
+
+static irqreturn_t SystemISRWrapper(int irq, void *dev_id
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+        , struct pt_regs *regs
+#endif
+        )
+{
+    SYS_DATA *psSysData;
+    IMG_BOOL bStatus = IMG_FALSE;
+
+    PVR_UNREFERENCED_PARAMETER(irq);
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+    PVR_UNREFERENCED_PARAMETER(regs);
+#endif
+    psSysData = (SYS_DATA *)dev_id;
+    if(!psSysData)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "SystemISRWrapper: invalid params\n"));
+        goto out;
+    }
+
+    bStatus = PVRSRVSystemLISR(psSysData);
+
+    if (bStatus)
+    {
+        OSScheduleMISR((IMG_VOID *)psSysData);
+    }
+
+out:
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+    return bStatus ? IRQ_HANDLED : IRQ_NONE;
+#endif
+}
+PVRSRV_ERROR OSInstallDeviceLISR(IMG_VOID *pvSysData,
+                                    IMG_UINT32 ui32Irq,
+                                    IMG_CHAR *pszISRName,
+                                    IMG_VOID *pvDeviceNode)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (psEnvData->bLISRInstalled)
+    {
+        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 %p", pszISRName, ui32Irq, pvDeviceNode));
+
+    if(request_irq(ui32Irq, DeviceISRWrapper,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
+        SA_SHIRQ
+#else
+        IRQF_SHARED
+#endif
+        , pszISRName, pvDeviceNode))
+    {
+        PVR_DPF((PVR_DBG_ERROR,"OSInstallDeviceLISR: Couldn't install device LISR on IRQ %d", ui32Irq));
+
+        return PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
+    }
+
+    psEnvData->ui32IRQ = ui32Irq;
+    psEnvData->pvISRCookie = pvDeviceNode;
+    psEnvData->bLISRInstalled = IMG_TRUE;
+
+    return PVRSRV_OK;   
+}
+
+PVRSRV_ERROR OSUninstallDeviceLISR(IMG_VOID *pvSysData)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (!psEnvData->bLISRInstalled)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSUninstallDeviceLISR: No LISR has been installed"));
+        return PVRSRV_ERROR_ISR_NOT_INSTALLED;
+    }
+        
+    PVR_TRACE(("Uninstalling device LISR on IRQ %d with cookie %p", psEnvData->ui32IRQ,  psEnvData->pvISRCookie));
+
+    free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
+
+    psEnvData->bLISRInstalled = IMG_FALSE;
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSInstallSystemLISR(IMG_VOID *pvSysData, IMG_UINT32 ui32Irq)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (psEnvData->bLISRInstalled)
+    {
+        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 %p", ui32Irq, pvSysData));
+
+    if(request_irq(ui32Irq, SystemISRWrapper,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
+        SA_SHIRQ
+#else
+        IRQF_SHARED
+#endif
+        , PVRSRV_MODNAME, pvSysData))
+    {
+        PVR_DPF((PVR_DBG_ERROR,"OSInstallSystemLISR: Couldn't install system LISR on IRQ %d", ui32Irq));
+
+        return PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR;
+    }
+
+    psEnvData->ui32IRQ = ui32Irq;
+    psEnvData->pvISRCookie = pvSysData;
+    psEnvData->bLISRInstalled = IMG_TRUE;
+
+    return PVRSRV_OK;   
+}
+
+
+PVRSRV_ERROR OSUninstallSystemLISR(IMG_VOID *pvSysData)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (!psEnvData->bLISRInstalled)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSUninstallSystemLISR: No LISR has been installed"));
+        return PVRSRV_ERROR_ISR_NOT_INSTALLED;
+    }
+
+    PVR_TRACE(("Uninstalling system LISR on IRQ %d with cookie %p", psEnvData->ui32IRQ, psEnvData->pvISRCookie));
+
+    free_irq(psEnvData->ui32IRQ, psEnvData->pvISRCookie);
+
+    psEnvData->bLISRInstalled = IMG_FALSE;
+
+    return PVRSRV_OK;
+}
+
+#if defined(PVR_LINUX_MISR_USING_PRIVATE_WORKQUEUE)
+static void MISRWrapper(
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+                        void *data
+#else
+                        struct work_struct *data
+#endif
+)
+{
+        ENV_DATA *psEnvData = container_of(data, ENV_DATA, sMISRWork);
+        SYS_DATA *psSysData  = (SYS_DATA *)psEnvData->pvMISRData;
+
+        PVRSRVMISR(psSysData);
+}
+
+
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+        if (psEnvData->bMISRInstalled)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
+                return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
+        }
+
+        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_UNABLE_TO_CREATE_THREAD;
+        }
+
+        INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+                , (void *)&psEnvData->sMISRWork
+#endif
+                                );
+
+        psEnvData->pvMISRData = pvSysData;
+        psEnvData->bMISRInstalled = IMG_TRUE;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+        if (!psEnvData->bMISRInstalled)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
+                return PVRSRV_ERROR_ISR_NOT_INSTALLED;
+        }
+
+        PVR_TRACE(("Uninstalling MISR"));
+
+        destroy_workqueue(psEnvData->psWorkQueue);
+
+        psEnvData->bMISRInstalled = IMG_FALSE;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA*)psSysData->pvEnvSpecificData;
+
+        if (psEnvData->bMISRInstalled)
+        {
+                queue_work(psEnvData->psWorkQueue, &psEnvData->sMISRWork);
+        }
+
+        return PVRSRV_OK;       
+}
+#else   
+#if defined(PVR_LINUX_MISR_USING_WORKQUEUE)
+static void MISRWrapper(
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+                        void *data
+#else
+                        struct work_struct *data
+#endif
+)
+{
+        ENV_DATA *psEnvData = container_of(data, ENV_DATA, sMISRWork);
+        SYS_DATA *psSysData  = (SYS_DATA *)psEnvData->pvMISRData;
+
+        PVRSRVMISR(psSysData);
+}
+
+
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+        if (psEnvData->bMISRInstalled)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
+                return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
+        }
+
+        PVR_TRACE(("Installing MISR with cookie %p", pvSysData));
+
+        INIT_WORK(&psEnvData->sMISRWork, MISRWrapper
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+                , (void *)&psEnvData->sMISRWork
+#endif
+                                );
+
+        psEnvData->pvMISRData = pvSysData;
+        psEnvData->bMISRInstalled = IMG_TRUE;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+        if (!psEnvData->bMISRInstalled)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
+                return PVRSRV_ERROR_ISR_NOT_INSTALLED;
+        }
+
+        PVR_TRACE(("Uninstalling MISR"));
+
+        flush_scheduled_work();
+
+        psEnvData->bMISRInstalled = IMG_FALSE;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+        ENV_DATA *psEnvData = (ENV_DATA*)psSysData->pvEnvSpecificData;
+
+        if (psEnvData->bMISRInstalled)
+        {
+                schedule_work(&psEnvData->sMISRWork);
+        }
+
+        return PVRSRV_OK;       
+}
+
+#else   
+
+
+static void MISRWrapper(unsigned long data)
+{
+    SYS_DATA *psSysData;
+
+    psSysData = (SYS_DATA *)data;
+    
+    PVRSRVMISR(psSysData);
+}
+
+
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (psEnvData->bMISRInstalled)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSInstallMISR: An MISR has already been installed"));
+        return PVRSRV_ERROR_ISR_ALREADY_INSTALLED;
+    }
+
+    PVR_TRACE(("Installing MISR with cookie %p", pvSysData));
+
+    tasklet_init(&psEnvData->sMISRTasklet, MISRWrapper, (unsigned long)pvSysData);
+
+    psEnvData->bMISRInstalled = IMG_TRUE;
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA *)psSysData->pvEnvSpecificData;
+
+    if (!psEnvData->bMISRInstalled)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSUninstallMISR: No MISR has been installed"));
+        return PVRSRV_ERROR_ISR_NOT_INSTALLED;
+    }
+
+    PVR_TRACE(("Uninstalling MISR"));
+
+    tasklet_kill(&psEnvData->sMISRTasklet);
+
+    psEnvData->bMISRInstalled = IMG_FALSE;
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData)
+{
+    SYS_DATA *psSysData = (SYS_DATA*)pvSysData;
+    ENV_DATA *psEnvData = (ENV_DATA*)psSysData->pvEnvSpecificData;
+
+    if (psEnvData->bMISRInstalled)
+    {
+        tasklet_schedule(&psEnvData->sMISRTasklet);
+    }
+
+    return PVRSRV_OK;   
+}
+
+#endif 
+#endif 
+
+#endif 
+
+IMG_VOID OSPanic(IMG_VOID)
+{
+        BUG();
+}
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#define OS_TAS(p)       xchg((p), 1)
+#else
+#define OS_TAS(p)       tas(p)
+#endif
+PVRSRV_ERROR OSLockResource ( PVRSRV_RESOURCE   *psResource,
+                                IMG_UINT32                      ui32ID)
+
+{
+    PVRSRV_ERROR eError = PVRSRV_OK;
+
+    if(!OS_TAS(&psResource->ui32Lock))
+        psResource->ui32ID = ui32ID;
+    else
+        eError = PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE;
+
+    return eError;
+}
+
+
+PVRSRV_ERROR OSUnlockResource (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+{
+    volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+    PVRSRV_ERROR eError = PVRSRV_OK;
+
+    if(*pui32Access)
+    {
+        if(psResource->ui32ID == ui32ID)
+        {
+            psResource->ui32ID = 0;
+            *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_INVALID_LOCK_ID;
+        }
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR,"OSUnlockResource: Resource %p is not locked", psResource));
+        eError = PVRSRV_ERROR_RESOURCE_NOT_LOCKED;
+    }
+    
+    return eError;
+}
+
+
+IMG_BOOL OSIsResourceLocked (PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID)
+{
+    volatile IMG_UINT32 *pui32Access = (volatile IMG_UINT32 *)&psResource->ui32Lock;
+
+    return      (*(volatile IMG_UINT32 *)pui32Access == 1) && (psResource->ui32ID == ui32ID)
+            ?   IMG_TRUE
+            :   IMG_FALSE;
+}
+
+
+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 = LinuxMemAreaToCpuPAddr(hOSMemHandle, ui32ByteOffset);
+
+        return CpuPAddr;
+}
+
+
+IMG_VOID *
+OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
+               IMG_UINT32 ui32Bytes,
+               IMG_UINT32 ui32MappingFlags,
+               IMG_HANDLE *phOSMemHandle)
+{
+    if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
+    {
+        
+        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 hOSMemHandle)
+{
+    PVR_TRACE(("%s: unmapping %d bytes from %p", __FUNCTION__, ui32Bytes, pvLinAddr));
+
+    PVR_UNREFERENCED_PARAMETER(ui32Bytes);      
+
+    if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
+    {
+        if (hOSMemHandle == IMG_NULL)
+        {
+                IOUnmapWrapper(pvLinAddr);
+        }
+        else
+        {
+                LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+
+                PVR_ASSERT(LinuxMemAreaToCpuVAddr(psLinuxMemArea) == pvLinAddr);
+                
+                FreeIORemapLinuxMemArea(psLinuxMemArea);
+        }
+
+        return IMG_TRUE;
+    }
+
+    PVR_DPF((PVR_DBG_ERROR,
+                 "OSUnMapPhysToLin should only be used with PVRSRV_HAP_KERNEL_ONLY "
+                 " (Use OSUnReservePhys otherwise)"));
+    return IMG_FALSE;
+}
+
+static PVRSRV_ERROR
+RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr,
+          IMG_VOID *pvCPUVAddr,
+              IMG_UINT32 ui32Bytes,
+          IMG_BOOL bPhysContig,
+              IMG_UINT32 ui32MappingFlags,
+              IMG_HANDLE *phOSMemHandle)
+{
+    LinuxMemArea *psLinuxMemArea;
+
+    switch(ui32MappingFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+        {
+        psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+        
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_BAD_MAPPING;
+            }
+            break;
+        }
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        {
+        psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_BAD_MAPPING;
+            }
+            PVRMMapRegisterArea(psLinuxMemArea);
+            break;
+        }
+        case PVRSRV_HAP_MULTI_PROCESS:
+        {
+            
+#if defined(VIVT_CACHE) || defined(__sh__)
+            
+            ui32MappingFlags &= ~PVRSRV_HAP_CACHED;
+#endif
+        psLinuxMemArea = NewExternalKVLinuxMemArea(pBasePAddr, pvCPUVAddr, ui32Bytes, bPhysContig, ui32MappingFlags);
+
+            if(!psLinuxMemArea)
+            {
+                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_INVALID_FLAGS;
+    }
+    
+    *phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
+
+    LinuxMemAreaRegister(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR
+OSRegisterMem(IMG_CPU_PHYADDR BasePAddr,
+              IMG_VOID *pvCPUVAddr,
+              IMG_UINT32 ui32Bytes,
+              IMG_UINT32 ui32MappingFlags,
+              IMG_HANDLE *phOSMemHandle)
+{
+    IMG_SYS_PHYADDR SysPAddr = SysCpuPAddrToSysPAddr(BasePAddr);
+
+    return RegisterExternalMem(&SysPAddr, pvCPUVAddr, ui32Bytes, IMG_TRUE, ui32MappingFlags, phOSMemHandle);
+}
+
+
+PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE *phOSMemHandle)
+{
+    return RegisterExternalMem(pBasePAddr, pvCPUVAddr, ui32Bytes, IMG_FALSE, ui32MappingFlags, phOSMemHandle);
+}
+
+
+PVRSRV_ERROR
+OSUnRegisterMem (IMG_VOID *pvCpuVAddr,
+                IMG_UINT32 ui32Bytes,
+                IMG_UINT32 ui32MappingFlags,
+                IMG_HANDLE hOSMemHandle)
+{
+    LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+    PVRSRV_ERROR eError;
+
+    PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
+    PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+
+    switch(ui32MappingFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+            break;
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        case PVRSRV_HAP_MULTI_PROCESS:
+        {
+            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 eError;
+            }
+            break;
+        }
+        default:
+        {
+            PVR_DPF((PVR_DBG_ERROR, "OSUnRegisterMem : invalid flags 0x%x", ui32MappingFlags));
+            return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+    }
+
+    LinuxMemAreaDeepFree(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
+{
+    return OSUnRegisterMem(pvCpuVAddr, ui32Bytes, ui32Flags, hOSMemHandle);
+}
+
+PVRSRV_ERROR
+OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
+              IMG_UINT32 ui32Bytes,
+              IMG_UINT32 ui32MappingFlags,
+              IMG_VOID **ppvCpuVAddr,
+              IMG_HANDLE *phOSMemHandle)
+{
+    LinuxMemArea *psLinuxMemArea;
+
+#if 0
+    
+    if(ui32MappingFlags & PVRSRV_HAP_SINGLE_PROCESS)
+    {
+        ui32MappingFlags &= ~PVRSRV_HAP_SINGLE_PROCESS;
+        ui32MappingFlags |= PVRSRV_HAP_MULTI_PROCESS;
+    }
+#endif
+
+    switch(ui32MappingFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+        {
+            
+            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_BAD_MAPPING;
+            }
+            break;
+        }
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        {
+            
+            psLinuxMemArea = NewIOLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_BAD_MAPPING;
+            }
+            PVRMMapRegisterArea(psLinuxMemArea);
+            break;
+        }
+        case PVRSRV_HAP_MULTI_PROCESS:
+        {
+            
+#if defined(VIVT_CACHE) || defined(__sh__)
+            
+            ui32MappingFlags &= ~PVRSRV_HAP_CACHED;
+#endif
+            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            if(!psLinuxMemArea)
+            {
+                return PVRSRV_ERROR_BAD_MAPPING;
+            }
+            PVRMMapRegisterArea(psLinuxMemArea);
+            break;
+        }
+        default:
+            PVR_DPF((PVR_DBG_ERROR,"OSMapPhysToLin : invalid flags 0x%x\n", ui32MappingFlags));
+            *ppvCpuVAddr = NULL;
+            *phOSMemHandle = (IMG_HANDLE)0;
+            return PVRSRV_ERROR_INVALID_FLAGS;
+    }
+
+    *phOSMemHandle = (IMG_HANDLE)psLinuxMemArea;
+    *ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
+
+    LinuxMemAreaRegister(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR
+OSUnReservePhys(IMG_VOID *pvCpuVAddr,
+                IMG_UINT32 ui32Bytes,
+                IMG_UINT32 ui32MappingFlags,
+                IMG_HANDLE hOSMemHandle)
+{
+    LinuxMemArea *psLinuxMemArea;
+    PVRSRV_ERROR eError;
+
+    PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
+    PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+
+    psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+    
+    switch(ui32MappingFlags & PVRSRV_HAP_MAPTYPE_MASK)
+    {
+        case PVRSRV_HAP_KERNEL_ONLY:
+            break;
+        case PVRSRV_HAP_SINGLE_PROCESS:
+        case PVRSRV_HAP_MULTI_PROCESS:
+        {
+            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 eError;
+            }
+            break;
+        }
+        default:
+        {
+            PVR_DPF((PVR_DBG_ERROR, "OSUnMapPhysToLin : invalid flags 0x%x", ui32MappingFlags));
+            return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+    }
+    
+    LinuxMemAreaDeepFree(psLinuxMemArea);
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSBaseAllocContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR *pvLinAddr, IMG_CPU_PHYADDR *psPhysAddr)
+{
+#if !defined(NO_HARDWARE)
+    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(pvLinAddr);
+    PVR_UNREFERENCED_PARAMETER(psPhysAddr);
+    PVR_DPF((PVR_DBG_ERROR, "%s: Not available", __FUNCTION__));
+
+    return PVRSRV_ERROR_OUT_OF_MEMORY;
+#else
+    IMG_VOID *pvKernLinAddr;
+
+#if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+    pvKernLinAddr = _KMallocWrapper(ui32Size, __FILE__, __LINE__);
+#else
+    pvKernLinAddr = KMallocWrapper(ui32Size);
+#endif
+    if (!pvKernLinAddr)
+    {
+    return PVRSRV_ERROR_OUT_OF_MEMORY;
+    }
+
+    *pvLinAddr = pvKernLinAddr;
+
+    psPhysAddr->uiAddr = virt_to_phys(pvKernLinAddr);
+
+    return PVRSRV_OK;
+#endif  
+}
+
+
+PVRSRV_ERROR OSBaseFreeContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR pvLinAddr, IMG_CPU_PHYADDR psPhysAddr)
+{
+#if !defined(NO_HARDWARE)
+    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(pvLinAddr);
+    PVR_UNREFERENCED_PARAMETER(psPhysAddr.uiAddr);
+
+    PVR_DPF((PVR_DBG_WARNING, "%s: Not available", __FUNCTION__));
+#else
+    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(psPhysAddr.uiAddr);
+
+    KFreeWrapper(pvLinAddr);
+#endif
+    return PVRSRV_OK;
+}
+
+IMG_UINT32 OSReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset)
+{
+#if !defined(NO_HARDWARE)
+    return (IMG_UINT32) readl((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+#else
+    return *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+#endif
+}
+
+IMG_VOID OSWriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value)
+{
+#if !defined(NO_HARDWARE)
+    writel(ui32Value, (IMG_PBYTE)pvLinRegBaseAddr+ui32Offset);
+#else
+    *(IMG_UINT32 *)((IMG_PBYTE)pvLinRegBaseAddr+ui32Offset) = ui32Value;
+#endif
+}
+
+#if defined(CONFIG_PCI) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
+
+PVRSRV_PCI_DEV_HANDLE OSPCISetDev(IMG_VOID *pvPCICookie, HOST_PCI_INIT_FLAGS eFlags)
+{
+    int err;
+    IMG_UINT32 i;
+    PVR_PCI_DEV *psPVRPCI;
+
+    PVR_TRACE(("OSPCISetDev"));
+
+    if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID **)&psPVRPCI, IMG_NULL,
+        "PCI Device") != PVRSRV_OK)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't allocate PVR PCI structure"));
+        return IMG_NULL;
+    }
+
+    psPVRPCI->psPCIDev = (struct pci_dev *)pvPCICookie;
+    psPVRPCI->ePCIFlags = eFlags;
+
+    err = pci_enable_device(psPVRPCI->psPCIDev);
+    if (err != 0)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSPCISetDev: Couldn't enable device (%d)", err));
+        return IMG_NULL;
+    }
+
+    if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)     
+    {
+        pci_set_master(psPVRPCI->psPCIDev);
+    }
+
+    if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)            
+    {
+#if defined(CONFIG_PCI_MSI)
+        err = pci_enable_msi(psPVRPCI->psPCIDev);
+        if (err != 0)
+        {
+            PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: Couldn't enable MSI (%d)", err));
+            psPVRPCI->ePCIFlags &= ~HOST_PCI_INIT_FLAG_MSI;      
+        }
+#else
+        PVR_DPF((PVR_DBG_WARNING, "OSPCISetDev: MSI support not enabled in the kernel"));
+#endif
+    }
+
+    
+    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+    {
+        psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
+    }
+
+    return (PVRSRV_PCI_DEV_HANDLE)psPVRPCI;
+}
+
+PVRSRV_PCI_DEV_HANDLE OSPCIAcquireDev(IMG_UINT16 ui16VendorID, IMG_UINT16 ui16DeviceID, HOST_PCI_INIT_FLAGS eFlags)
+{
+    struct pci_dev *psPCIDev;
+
+    psPCIDev = pci_get_device(ui16VendorID, ui16DeviceID, NULL);
+    if (psPCIDev == NULL)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSPCIAcquireDev: Couldn't acquire device"));
+        return IMG_NULL;
+    }
+
+    return OSPCISetDev((IMG_VOID *)psPCIDev, eFlags);
+}
+
+PVRSRV_ERROR OSPCIIRQ(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 *pui32IRQ)
+{
+    PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+
+    *pui32IRQ = psPVRPCI->psPCIDev->irq;
+
+    return PVRSRV_OK;
+}
+
+enum HOST_PCI_ADDR_RANGE_FUNC
+{
+    HOST_PCI_ADDR_RANGE_FUNC_LEN,
+    HOST_PCI_ADDR_RANGE_FUNC_START,
+    HOST_PCI_ADDR_RANGE_FUNC_END,
+    HOST_PCI_ADDR_RANGE_FUNC_REQUEST,
+    HOST_PCI_ADDR_RANGE_FUNC_RELEASE
+};
+
+static IMG_UINT32 OSPCIAddrRangeFunc(enum HOST_PCI_ADDR_RANGE_FUNC eFunc,
+                                     PVRSRV_PCI_DEV_HANDLE hPVRPCI,
+                                     IMG_UINT32 ui32Index)
+{
+    PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+
+    if (ui32Index >= DEVICE_COUNT_RESOURCE)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Index out of range"));
+        return 0;
+
+    }
+
+    switch (eFunc)
+    {
+        case HOST_PCI_ADDR_RANGE_FUNC_LEN:
+            return pci_resource_len(psPVRPCI->psPCIDev, ui32Index);
+        case HOST_PCI_ADDR_RANGE_FUNC_START:
+            return pci_resource_start(psPVRPCI->psPCIDev, ui32Index);
+        case HOST_PCI_ADDR_RANGE_FUNC_END:
+            return pci_resource_end(psPVRPCI->psPCIDev, ui32Index);
+        case HOST_PCI_ADDR_RANGE_FUNC_REQUEST:
+        {
+            int err;
+
+            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));
+                return 0;
+            }
+            psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_TRUE;
+            return 1;
+        }
+        case HOST_PCI_ADDR_RANGE_FUNC_RELEASE:
+            if (psPVRPCI->abPCIResourceInUse[ui32Index])
+            {
+                pci_release_region(psPVRPCI->psPCIDev, (IMG_INT)ui32Index);
+                psPVRPCI->abPCIResourceInUse[ui32Index] = IMG_FALSE;
+            }
+            return 1;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "OSPCIAddrRangeFunc: Unknown function"));
+            break;
+    }
+
+    return 0;
+}
+
+IMG_UINT32 OSPCIAddrRangeLen(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
+{
+    return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_LEN, hPVRPCI, ui32Index); 
+}
+
+IMG_UINT32 OSPCIAddrRangeStart(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
+{
+    return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_START, hPVRPCI, ui32Index); 
+}
+
+IMG_UINT32 OSPCIAddrRangeEnd(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index)
+{
+    return OSPCIAddrRangeFunc(HOST_PCI_ADDR_RANGE_FUNC_END, hPVRPCI, ui32Index); 
+}
+
+PVRSRV_ERROR OSPCIRequestAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI,
+                                   IMG_UINT32 ui32Index)
+{
+    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_PCI_CALL_FAILED : PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSPCIReleaseDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
+{
+    PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+    int i;
+
+    PVR_TRACE(("OSPCIReleaseDev"));
+
+    
+    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+    {
+        if (psPVRPCI->abPCIResourceInUse[i])
+        {
+            PVR_TRACE(("OSPCIReleaseDev: Releasing Address range %d", i));
+            pci_release_region(psPVRPCI->psPCIDev, i);
+            psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE;
+        }
+    }
+
+#if defined(CONFIG_PCI_MSI)
+    if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI)            
+    {
+        pci_disable_msi(psPVRPCI->psPCIDev);
+    }
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29))
+    if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)     
+    {
+        pci_clear_master(psPVRPCI->psPCIDev);
+    }
+#endif
+    pci_disable_device(psPVRPCI->psPCIDev);
+
+    OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psPVRPCI), (IMG_VOID *)psPVRPCI, IMG_NULL);
+        
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSPCISuspendDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
+{
+    PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+    int i;
+    int err;
+
+    PVR_TRACE(("OSPCISuspendDev"));
+
+    
+    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+    {
+        if (psPVRPCI->abPCIResourceInUse[i])
+        {
+            pci_release_region(psPVRPCI->psPCIDev, i);
+        }
+    }
+
+    err = pci_save_state(psPVRPCI->psPCIDev);
+    if (err != 0)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_save_state_failed (%d)", err));
+        return PVRSRV_ERROR_PCI_CALL_FAILED;
+    }
+
+    pci_disable_device(psPVRPCI->psPCIDev);
+
+    err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_SUSPEND));
+    switch(err)
+    {
+        case 0:
+            break;
+        case -EIO:
+            PVR_DPF((PVR_DBG_WARNING, "OSPCISuspendDev: device doesn't support PCI PM"));
+            break;
+        case -EINVAL:
+            PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: can't enter requested power state"));
+            break;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "OSPCISuspendDev: pci_set_power_state failed (%d)", err));
+            break;
+    }
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSPCIResumeDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI)
+{
+    PVR_PCI_DEV *psPVRPCI = (PVR_PCI_DEV *)hPVRPCI;
+    int err;
+    int i;
+
+    PVR_TRACE(("OSPCIResumeDev"));
+
+    err = pci_set_power_state(psPVRPCI->psPCIDev, pci_choose_state(psPVRPCI->psPCIDev, PMSG_ON));
+    switch(err)
+    {
+        case 0:
+            break;
+        case -EIO:
+            PVR_DPF((PVR_DBG_WARNING, "OSPCIResumeDev: device doesn't support PCI PM"));
+            break;
+        case -EINVAL:
+            PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: can't enter requested power state"));
+            return PVRSRV_ERROR_UNKNOWN_POWER_STATE;
+        default:
+            PVR_DPF((PVR_DBG_ERROR, "OSPCIResumeDev: pci_set_power_state failed (%d)", err));
+            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_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_PCI_CALL_FAILED;
+    }
+
+    if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER)     
+        pci_set_master(psPVRPCI->psPCIDev);
+
+    
+    for (i = 0; i < DEVICE_COUNT_RESOURCE; i++)
+    {
+        if (psPVRPCI->abPCIResourceInUse[i])
+        {
+            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));
+            }
+        }
+
+    }
+
+    return PVRSRV_OK;
+}
+
+#endif 
+
+#define OS_MAX_TIMERS   8
+
+typedef struct TIMER_CALLBACK_DATA_TAG
+{
+    IMG_BOOL                    bInUse;
+    PFN_TIMER_FUNC              pfnTimerFunc;
+    IMG_VOID                    *pvData;        
+    struct timer_list           sTimer;
+    IMG_UINT32                  ui32Delay;
+    IMG_BOOL                    bActive;
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    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];
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+DEFINE_MUTEX(sTimerStructLock);
+#else
+ 
+static spinlock_t sTimerStructLock = SPIN_LOCK_UNLOCKED;
+#endif
+
+static void OSTimerCallbackBody(TIMER_CALLBACK_DATA *psTimerCBData)
+{
+    if (!psTimerCBData->bActive)
+        return;
+
+    
+    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)
+    int res;
+
+    res = queue_work(psTimerWorkQueue, &psTimerCBData->sWork);
+    if (res == 0)
+    {
+        PVR_DPF((PVR_DBG_WARNING, "OSTimerCallbackWrapper: work already queued"));              
+    }
+#else
+    OSTimerCallbackBody(psTimerCBData);
+#endif
+}
+
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+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)
+    unsigned long               ulLockFlags;
+#endif
+
+    
+    if(!pfnTimerFunc)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: passed invalid callback"));                
+        return IMG_NULL;                
+    }
+    
+    
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    mutex_lock(&sTimerStructLock);
+#else
+    spin_lock_irqsave(&sTimerStructLock, ulLockFlags);
+#endif
+    for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
+    {
+        psTimerCBData = &sTimers[ui32i];
+        if (!psTimerCBData->bInUse)
+        {
+            psTimerCBData->bInUse = IMG_TRUE;
+            break;
+        }
+    }
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    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"));          
+        return IMG_NULL;        
+    }
+
+    psTimerCBData->pfnTimerFunc = pfnTimerFunc;
+    psTimerCBData->pvData = pvData;
+    psTimerCBData->bActive = IMG_FALSE;
+    
+    
+
+
+    psTimerCBData->ui32Delay = ((HZ * ui32MsTimeout) < 1000)
+                                ?       1
+                                :       ((HZ * ui32MsTimeout) / 1000);
+    
+    init_timer(&psTimerCBData->sTimer);
+    
+    
+     
+    psTimerCBData->sTimer.function = (IMG_VOID *)OSTimerCallbackWrapper;
+    psTimerCBData->sTimer.data = (IMG_UINT32)psTimerCBData;
+    
+    return (IMG_HANDLE)(ui32i + 1);
+}
+
+
+static inline TIMER_CALLBACK_DATA *GetTimerStructure(IMG_HANDLE hTimer)
+{
+    IMG_UINT32 ui32i = ((IMG_UINT32)hTimer) - 1;
+
+    PVR_ASSERT(ui32i < OS_MAX_TIMERS);
+
+    return &sTimers[ui32i];
+}
+
+PVRSRV_ERROR OSRemoveTimer (IMG_HANDLE hTimer)
+{
+    TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+
+    PVR_ASSERT(psTimerCBData->bInUse);
+    PVR_ASSERT(!psTimerCBData->bActive);
+
+    
+    psTimerCBData->bInUse = IMG_FALSE;
+    
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSEnableTimer (IMG_HANDLE hTimer)
+{
+    TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+
+    PVR_ASSERT(psTimerCBData->bInUse);
+    PVR_ASSERT(!psTimerCBData->bActive);
+
+    
+    psTimerCBData->bActive = IMG_TRUE;
+
+    
+    psTimerCBData->sTimer.expires = psTimerCBData->ui32Delay + jiffies;
+
+    
+    add_timer(&psTimerCBData->sTimer);
+    
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSDisableTimer (IMG_HANDLE hTimer)
+{
+    TIMER_CALLBACK_DATA *psTimerCBData = GetTimerStructure(hTimer);
+
+    PVR_ASSERT(psTimerCBData->bInUse);
+    PVR_ASSERT(psTimerCBData->bActive);
+
+    
+    psTimerCBData->bActive = IMG_FALSE;
+    smp_mb();
+
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    flush_workqueue(psTimerWorkQueue);
+#endif
+
+    
+    del_timer_sync(&psTimerCBData->sTimer);     
+    
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    
+    flush_workqueue(psTimerWorkQueue);
+#endif
+
+    return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR OSEventObjectCreate(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT *psEventObject)
+{
+
+    PVRSRV_ERROR eError = PVRSRV_OK;
+    
+    if(psEventObject)
+    {
+        if(pszName)
+        {
+            
+            strncpy(psEventObject->szName, pszName, EVENTOBJNAME_MAXLENGTH);
+        }
+        else
+        {
+                
+            static IMG_UINT16 ui16NameIndex = 0;                        
+            snprintf(psEventObject->szName, EVENTOBJNAME_MAXLENGTH, "PVRSRV_EVENTOBJECT_%d", ui16NameIndex++);
+        }
+        
+        if(LinuxEventObjectListCreate(&psEventObject->hOSEventKM) != PVRSRV_OK)
+        {
+             eError = PVRSRV_ERROR_OUT_OF_MEMORY;       
+        }
+
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectCreate: psEventObject is not a valid pointer"));
+        eError = PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT;   
+    }
+    
+    return eError;
+
+}
+
+
+PVRSRV_ERROR OSEventObjectDestroy(PVRSRV_EVENTOBJECT *psEventObject)
+{
+    PVRSRV_ERROR eError = PVRSRV_OK;
+
+    if(psEventObject)
+    {
+        if(psEventObject->hOSEventKM)
+        {
+            LinuxEventObjectListDestroy(psEventObject->hOSEventKM);
+        }
+        else
+        {
+            PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: hOSEventKM is not a valid pointer"));
+            eError = PVRSRV_ERROR_INVALID_PARAMS;
+        }
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: psEventObject is not a valid pointer"));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+    }
+    
+    return eError;
+}
+
+PVRSRV_ERROR OSEventObjectWait(IMG_HANDLE hOSEventKM)
+{
+    PVRSRV_ERROR eError;
+    
+    if(hOSEventKM)
+    {
+        eError = LinuxEventObjectWait(hOSEventKM, EVENT_OBJECT_TIMEOUT_MS);
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectWait: hOSEventKM is not a valid handle"));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+    }
+    
+    return eError;
+}
+
+PVRSRV_ERROR OSEventObjectOpen(PVRSRV_EVENTOBJECT *psEventObject,
+                                            IMG_HANDLE *phOSEvent)
+{
+    PVRSRV_ERROR eError = PVRSRV_OK;
+    
+    if(psEventObject)
+    {
+        if(LinuxEventObjectAdd(psEventObject->hOSEventKM, phOSEvent) != PVRSRV_OK)
+        {
+            PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectAdd: failed"));
+            eError = PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectCreate: psEventObject is not a valid pointer"));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+    }
+    
+    return eError;
+}
+
+PVRSRV_ERROR OSEventObjectClose(PVRSRV_EVENTOBJECT *psEventObject,
+                                            IMG_HANDLE hOSEventKM)
+{
+    PVRSRV_ERROR eError = PVRSRV_OK;
+
+    if(psEventObject)
+    {
+        if(LinuxEventObjectDelete(psEventObject->hOSEventKM, hOSEventKM) != PVRSRV_OK)
+        {
+            PVR_DPF((PVR_DBG_ERROR, "LinuxEventObjectDelete: failed"));
+            eError = PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectDestroy: psEventObject is not a valid pointer"));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+    }
+    
+    return eError;
+    
+}
+
+PVRSRV_ERROR OSEventObjectSignal(IMG_HANDLE hOSEventKM)
+{
+    PVRSRV_ERROR eError;
+    
+    if(hOSEventKM)
+    {
+        eError = LinuxEventObjectSignal(hOSEventKM);
+    }
+    else
+    {
+        PVR_DPF((PVR_DBG_ERROR, "OSEventObjectSignal: hOSEventKM is not a valid handle"));
+        eError = PVRSRV_ERROR_INVALID_PARAMS;
+    }
+    
+    return eError;
+}
+
+IMG_BOOL OSProcHasPrivSrvInit(IMG_VOID)
+{
+    return (capable(CAP_SYS_MODULE) != 0) ? IMG_TRUE : IMG_FALSE;
+}
+
+PVRSRV_ERROR OSCopyToUser(IMG_PVOID pvProcess, 
+                          IMG_VOID *pvDest, 
+                          IMG_VOID *pvSrc, 
+                          IMG_UINT32 ui32Bytes)
+{
+    PVR_UNREFERENCED_PARAMETER(pvProcess);
+
+    if(pvr_copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
+        return PVRSRV_OK;
+    else
+        return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
+}
+
+PVRSRV_ERROR OSCopyFromUser( IMG_PVOID pvProcess, 
+                             IMG_VOID *pvDest, 
+                             IMG_VOID *pvSrc, 
+                             IMG_UINT32 ui32Bytes)
+{
+    PVR_UNREFERENCED_PARAMETER(pvProcess);
+
+    if(pvr_copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
+        return PVRSRV_OK;
+    else
+        return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
+}
+
+IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_UINT32 ui32Bytes)
+{
+    IMG_INT linuxType;
+
+    if (eVerification == PVR_VERIFY_READ)
+    {
+        linuxType = VERIFY_READ;
+    }
+    else
+    {
+        PVR_ASSERT(eVerification == PVR_VERIFY_WRITE);
+        linuxType = VERIFY_WRITE;
+    }
+
+    return access_ok(linuxType, pvUserPtr, ui32Bytes);
+}
+
+typedef enum _eWrapMemType_
+{
+    WRAP_TYPE_NULL = 0,
+    WRAP_TYPE_GET_USER_PAGES,
+    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;
+#if defined(DEBUG)
+    IMG_UINT32 ulStartAddr;
+    IMG_UINT32 ulBeyondEndAddr;
+    struct vm_area_struct *psVMArea;
+#endif
+} sWrapMemInfo;
+
+
+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;
+    pud_t *psPUD;
+    pmd_t *psPMD;
+    pte_t *psPTE;
+    struct mm_struct *psMM = psVMArea->vm_mm;
+    spinlock_t *psPTLock;
+    IMG_BOOL bRet = IMG_FALSE;
+
+    *pulPFN = 0;
+    *ppsPage = NULL;
+
+    psPGD = pgd_offset(psMM, ulCPUVAddr);
+    if (pgd_none(*psPGD) || pgd_bad(*psPGD))
+        return bRet;
+
+    psPUD = pud_offset(psPGD, ulCPUVAddr);
+    if (pud_none(*psPUD) || pud_bad(*psPUD))
+        return bRet;
+
+    psPMD = pmd_offset(psPUD, ulCPUVAddr);
+    if (pmd_none(*psPMD) || pmd_bad(*psPMD))
+        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))
+    {
+        *pulPFN = pte_pfn(*psPTE);
+        bRet = IMG_TRUE;
+
+        if (pfn_valid(*pulPFN))
+        {
+            *ppsPage = pfn_to_page(*pulPFN);
+
+            get_page(*ppsPage);
+        }
+    }
+
+    pte_unmap_unlock(psPTE, psPTLock);
+
+    return bRet;
+#else
+    return IMG_FALSE;
+#endif
+}
+
+PVRSRV_ERROR OSReleasePhysPageAddr(IMG_HANDLE hOSWrapMem)
+{
+    sWrapMemInfo *psInfo = (sWrapMemInfo *)hOSWrapMem;
+    IMG_INT i;
+
+    if (psInfo == IMG_NULL)
+    {
+        PVR_DPF((PVR_DBG_WARNING,
+            "OSReleasePhysPageAddr: called with null wrap handle"));
+        return PVRSRV_OK;
+    }
+
+    switch (psInfo->eType)
+    {
+        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->iNumPagesMapped; i++)
+            {
+                struct page *psPage = psInfo->ppsPages[i];
+
+                PVR_ASSERT(psPage != NULL);
+
+                
+                if (psInfo->iNumPagesMapped == psInfo->iNumPages)
+                {
+                    if (!PageReserved(psPage))
+                    {
+                        SetPageDirty(psPage);
+                    }
+                }
+                page_cache_release(psPage);
+            }
+            break;
+        }
+        case WRAP_TYPE_FIND_VMA:
+        {
+            for (i = 0; i < psInfo->iNumPages; i++)
+            {
+                if (psInfo->ppsPages[i] != IMG_NULL)
+                {
+                    put_page(psInfo->ppsPages[i]);
+                }
+            }
+            break;
+        }
+        default:
+        {
+            PVR_DPF((PVR_DBG_ERROR,
+                "OSReleasePhysPageAddr: Unknown wrap type (%d)", psInfo->eType));
+            return PVRSRV_ERROR_INVALID_WRAP_TYPE;
+        }
+    }
+
+    if (psInfo->ppsPages != IMG_NULL)
+    {
+        kfree(psInfo->ppsPages);
+    }
+
+    if (psInfo->psPhysAddr != IMG_NULL)
+    {
+        kfree(psInfo->psPhysAddr);
+    }
+
+    kfree(psInfo);
+
+    return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr, 
+                                    IMG_UINT32 ui32Bytes, 
+                                    IMG_SYS_PHYADDR *psSysPAddr,
+                                    IMG_HANDLE *phOSWrapMem)
+{
+    IMG_UINT32 ulStartAddrOrig = (IMG_UINT32) pvCPUVAddr;
+    IMG_UINT32 ulAddrRangeOrig = (IMG_UINT32) ui32Bytes;
+    IMG_UINT32 ulBeyondEndAddrOrig = ulStartAddrOrig + ulAddrRangeOrig;
+    IMG_UINT32 ulStartAddr;
+    IMG_UINT32 ulAddrRange;
+    IMG_UINT32 ulBeyondEndAddr;
+    IMG_UINT32 ulAddr;
+    IMG_INT i;
+    struct vm_area_struct *psVMArea;
+    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;
+    ulBeyondEndAddr = PAGE_ALIGN(ulBeyondEndAddrOrig);
+    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"));
+        goto error;
+    }
+    memset(psInfo, 0, sizeof(*psInfo));
+
+#if defined(DEBUG)
+    psInfo->ulStartAddr = ulStartAddrOrig;
+    psInfo->ulBeyondEndAddr = ulBeyondEndAddrOrig;
+#endif
+
+    psInfo->iNumPages = (IMG_INT)(ulAddrRange >> PAGE_SHIFT);
+    psInfo->iPageOffset = (IMG_INT)(ulStartAddrOrig & ~PAGE_MASK);
+
+    
+    psInfo->psPhysAddr = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->psPhysAddr), GFP_KERNEL);
+    if (psInfo->psPhysAddr == NULL)
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: Couldn't allocate page array"));            
+        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);
+    if (psInfo->ppsPages == NULL)
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: Couldn't allocate page array"));            
+        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(&current->mm->mmap_sem);
+    bMMapSemHeld = IMG_TRUE;
+
+    
+    psInfo->iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
+
+    if (psInfo->iNumPagesMapped >= 0)
+    {
+        
+        if (psInfo->iNumPagesMapped != psInfo->iNumPages)
+        {
+            PVR_TRACE(("OSAcquirePhysPageAddr: Couldn't map all the pages needed (wanted: %d, got %d)", psInfo->iNumPages, psInfo->iNumPagesMapped));
+
+            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));
+
+                    goto error;
+            }
+            psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+            psSysPAddr[i] = psInfo->psPhysAddr[i];
+            
+        }
+
+        goto exit;
+    }
+
+    PVR_DPF((PVR_DBG_MESSAGE, "OSAcquirePhysPageAddr: get_user_pages failed (%d), using CPU page table", psInfo->iNumPagesMapped));
+    
+    
+    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 %x", ulStartAddrOrig));
+        
+        goto error;
+    }
+#if defined(DEBUG)
+    psInfo->psVMArea = psVMArea;
+#endif
+
+    
+    if (ulStartAddrOrig < psVMArea->vm_start)
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "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 %x is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
+        goto error;
+    }
+
+    
+    if ((psVMArea->vm_flags & (VM_IO | VM_RESERVED)) != (VM_IO | VM_RESERVED))
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: Memory region does not represent memory mapped I/O (VMA flags: 0x%lx)", psVMArea->vm_flags));
+        goto error;
+    }
+
+    
+    if ((psVMArea->vm_flags & (VM_READ | VM_WRITE)) != (VM_READ | VM_WRITE))
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: No read/write access to memory region (VMA flags: 0x%lx)", psVMArea->vm_flags));
+        goto error;
+    }
+
+    for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
+    {
+        IMG_CPU_PHYADDR CPUPhysAddr;
+        IMG_UINT32 ulPFN = 0;
+
+        PVR_ASSERT(i < psInfo->iNumPages);
+
+        if (!CPUVAddrToPFN(psVMArea, ulAddr, &ulPFN, &psInfo->ppsPages[i]))
+        {
+            PVR_DPF((PVR_DBG_ERROR,
+               "OSAcquirePhysPageAddr: Invalid CPU virtual address"));
+
+            goto error;
+        }
+        if (psInfo->ppsPages[i] == NULL)
+        {
+
+            bHaveNoPageStructs = IMG_TRUE;
+
+#if defined(VM_PFNMAP)
+            if ((psVMArea->vm_flags & VM_PFNMAP) != 0)
+            {
+                IMG_UINT32 ulPFNRaw = ((ulAddr - psVMArea->vm_start) >> PAGE_SHIFT) + psVMArea->vm_pgoff;
+
+                if (ulPFNRaw != ulPFN)
+                {
+                        bPFNMismatch = IMG_TRUE;
+                }
+            }
+#endif
+        }
+        else
+        {
+            bHavePageStructs = IMG_TRUE;
+
+            psInfo->iNumPagesMapped++;
+
+            PVR_ASSERT(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));
+
+                    goto error;
+        }
+
+        psInfo->psPhysAddr[i] = SysCpuPAddrToSysPAddr(CPUPhysAddr);
+        psSysPAddr[i] = psInfo->psPhysAddr[i];
+    }
+    PVR_ASSERT(i ==  psInfo->iNumPages);
+
+#if defined(VM_MIXEDMAP)
+    if ((psVMArea->vm_flags & VM_MIXEDMAP) != 0)
+    {
+        goto exit;
+    }
+#endif
+
+    if (bHavePageStructs && bHaveNoPageStructs)
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: Region is VM_MIXEDMAP, but isn't marked as such"));
+        goto error;
+    }
+
+    if (!bHaveNoPageStructs)
+    {
+        
+        goto exit;
+    }
+
+#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;
+    }
+
+    if (bPFNMismatch)
+    {
+        PVR_DPF((PVR_DBG_ERROR,
+            "OSAcquirePhysPageAddr: PFN calculation mismatch for VM_PFNMAP region"));
+        goto error;
+    }
+
+exit:
+    PVR_ASSERT(bMMapSemHeld);
+    up_read(&current->mm->mmap_sem);
+
+    
+    *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
+    
+    
+    OSCleanCPUCacheRangeKM(pvCPUVAddr, (IMG_VOID *)((IMG_CHAR *)pvCPUVAddr + ui32Bytes));
+#endif
+
+    return PVRSRV_OK;
+
+error:
+    if (bMMapSemHeld)
+    {
+        up_read(&current->mm->mmap_sem);
+    }
+    OSReleasePhysPageAddr((IMG_HANDLE)psInfo);
+
+    PVR_ASSERT(eError != PVRSRV_OK);
+
+    return eError;
+}
+
+typedef void (*InnerCacheOp_t)(const void *pvStart, const void *pvEnd);
+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 
+
+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;
+}
+
+static
+IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
+                                                         IMG_VOID *pvRangeAddrStart,
+                                                         IMG_UINT32 ui32Length,
+                                                         InnerCacheOp_t pfnInnerCacheOp,
+                                                         OuterCacheOp_t pfnOuterCacheOp)
+{
+        LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
+        IMG_UINT32 ui32AreaLength, ui32AreaOffset = 0;
+        struct list_head *psMMapOffsetStructList;
+        IMG_VOID *pvMinVAddr;
+
+#if defined(CONFIG_OUTER_CACHE)
+        MemAreaToPhys_t pfnMemAreaToPhys;
+        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:
+                {
+                        
+                        PVR_ASSERT(psLinuxMemArea->uData.sExternalKV.bPhysContig != IMG_TRUE);
+
+                        
+                        PVR_ASSERT(psLinuxMemArea->uData.sExternalKV.pvExternalKV == IMG_NULL);
+
+                        
+
+                        pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
+                                                                                   pvRangeAddrStart, ui32Length);
+                        if(!pvMinVAddr)
+                                goto err_blocked;
+
+#if defined(CONFIG_OUTER_CACHE)
+                        ui32PageNumOffset = (ui32AreaOffset + (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 + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
+                        pfnMemAreaToPhys = AllocPagesAreaToPhys;
+#endif
+                        break;
+                }
+
+                default:
+                        PVR_DBG_BREAK;
+        }
+
+        
+        pfnInnerCacheOp(pvRangeAddrStart, pvRangeAddrStart + ui32Length);
+
+#if defined(CONFIG_OUTER_CACHE)
+        
+        {
+                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(i == ui32NumPages - 1 && ulEndOffset != 0)
+                                ulEnd = ulStart + ulEndOffset;
+
+                        if(i == 0)
+                                ulStart += ulStartOffset;
+
+                        pfnOuterCacheOp(ulStart, ulEnd);
+                }
+        }
+#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;
+}
+
+#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();
+}
+
+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);
+
+        mb();
+        for(pbBase = pbStart; pbBase < pbEnd; pbBase += boot_cpu_data.x86_clflush_size)
+                clflush(pbBase);
+        mb();
+}
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID)
+{
+        
+        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)
+{
+        
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           x86_flush_cache_range, IMG_NULL);
+}
+
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+                                                                IMG_VOID *pvRangeAddrStart,
+                                                                IMG_UINT32 ui32Length)
+{
+        
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           x86_flush_cache_range, IMG_NULL);
+}
+
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+                                                                         IMG_VOID *pvRangeAddrStart,
+                                                                         IMG_UINT32 ui32Length)
+{
+        
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           x86_flush_cache_range, IMG_NULL);
+}
+
+#else 
+
+#if defined(__arm__)
+
+IMG_VOID OSCleanCPUCacheKM(IMG_VOID)
+{
+    
+        flush_cache_all();
+}
+
+IMG_VOID OSFlushCPUCacheKM(IMG_VOID)
+{
+        flush_cache_all();
+}
+
+IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+                                                                IMG_VOID *pvRangeAddrStart,
+                                                                IMG_UINT32 ui32Length)
+{
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           dmac_flush_range, outer_flush_range);
+}
+
+IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+                                                                IMG_VOID *pvRangeAddrStart,
+                                                                IMG_UINT32 ui32Length)
+{
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           dmac_clean_range, outer_clean_range);
+}
+
+IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
+                                                                         IMG_VOID *pvRangeAddrStart,
+                                                                         IMG_UINT32 ui32Length)
+{
+        return CheckExecuteCacheOp(hOSMemHandle, pvRangeAddrStart, ui32Length,
+                                                           dmac_inv_range, outer_inv_range);
+}
+
+#else 
+
+#error "Implement CPU cache flush/clean/invalidate primitives for this CPU!"
+
+#endif 
+
+#endif 
+
+PVRSRV_ERROR PVROSFuncInit(IMG_VOID)
+{
+#if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES)
+    {
+        IMG_UINT32 ui32i;
+
+        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;
+
+        }
+
+        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
+}
diff --git a/drivers/gpu/pvr/osfunc.h b/drivers/gpu/pvr/osfunc.h
new file mode 100644
index 00000000000..8ffbea60aeb
--- /dev/null
+++ b/drivers/gpu/pvr/osfunc.h
@@ -0,0 +1,576 @@
+/**********************************************************************
+ *
+ * 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 
+ *
+ ******************************************************************************/
+
+#ifdef DEBUG_RELEASE_BUILD
+#pragma optimize( "", off )
+#define DEBUG           1
+#endif
+
+#ifndef __OSFUNC_H__
+#define __OSFUNC_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#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 PVRSRV_PAGEABLE_SELECT          PVRSRV_OS_PAGEABLE_HEAP
+
+#define KERNEL_ID                       0xffffffffL
+#define POWER_MANAGER_ID        0xfffffffeL
+#define ISR_ID                          0xfffffffdL
+#define TIMER_ID                        0xfffffffcL
+
+
+#define HOST_PAGESIZE                   OSGetPageSize
+#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 
+#define PVRSRV_OS_NON_PAGEABLE_HEAP     0x2 
+
+
+IMG_UINT32 OSClockus(IMG_VOID);
+IMG_SIZE_T OSGetPageSize(IMG_VOID);
+PVRSRV_ERROR OSInstallDeviceLISR(IMG_VOID *pvSysData,
+                                                                 IMG_UINT32 ui32Irq,
+                                                                 IMG_CHAR *pszISRName,
+                                                                 IMG_VOID *pvDeviceNode);
+PVRSRV_ERROR OSUninstallDeviceLISR(IMG_VOID *pvSysData);
+PVRSRV_ERROR OSInstallSystemLISR(IMG_VOID *pvSysData, IMG_UINT32 ui32Irq);
+PVRSRV_ERROR OSUninstallSystemLISR(IMG_VOID *pvSysData);
+PVRSRV_ERROR OSInstallMISR(IMG_VOID *pvSysData);
+PVRSRV_ERROR OSUninstallMISR(IMG_VOID *pvSysData);
+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(__linux__) && defined(__KERNEL__)
+
+IMG_VOID OSFlushCPUCacheKM(IMG_VOID);
+
+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,
+                                                                        IMG_VOID *pvCpuVAddr, 
+                                                                        IMG_SIZE_T ui32Bytes,
+                                                                        IMG_UINT32 ui32Flags, 
+                                                                        IMG_HANDLE *phOSMemHandle);
+PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr,
+                                                                        IMG_SIZE_T ui32Bytes,
+                                                                        IMG_UINT32 ui32Flags,
+                                                                        IMG_HANDLE hOSMemHandle);
+#else   
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSRegisterDiscontigMem)
+#endif
+static INLINE PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr,
+                                                                                                        IMG_VOID *pvCpuVAddr,
+                                                                                                        IMG_SIZE_T ui32Bytes,
+                                                                                                        IMG_UINT32 ui32Flags,
+                                                                                                        IMG_HANDLE *phOSMemHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(pBasePAddr);
+        PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        PVR_UNREFERENCED_PARAMETER(phOSMemHandle);
+
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSUnRegisterDiscontigMem)
+#endif
+static INLINE PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr,
+                                                                                                        IMG_SIZE_T ui32Bytes,
+                                                                                                        IMG_UINT32 ui32Flags,
+                                                                                                        IMG_HANDLE hOSMemHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+#endif  
+
+
+#if defined(__linux__)
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSReserveDiscontigPhys)
+#endif
+static INLINE PVRSRV_ERROR OSReserveDiscontigPhys(IMG_SYS_PHYADDR *pBasePAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_VOID **ppvCpuVAddr, IMG_HANDLE *phOSMemHandle)
+{
+#if defined(__linux__)  
+        *ppvCpuVAddr = IMG_NULL;
+        return OSRegisterDiscontigMem(pBasePAddr, *ppvCpuVAddr, ui32Bytes, ui32Flags, phOSMemHandle);   
+#else
+        extern IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr(IMG_SYS_PHYADDR SysPAddr);
+
+        
+        return OSReservePhys(SysSysPAddrToCpuPAddr(pBasePAddr[0]), ui32Bytes, ui32Flags, ppvCpuVAddr, phOSMemHandle);
+#endif  
+}
+
+static INLINE PVRSRV_ERROR OSUnReserveDiscontigPhys(IMG_VOID *pvCpuVAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
+{
+#if defined(__linux__)
+        OSUnRegisterDiscontigMem(pvCpuVAddr, ui32Bytes, ui32Flags, hOSMemHandle);
+#endif
+        
+        return PVRSRV_OK;
+}
+#else   
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSReserveDiscontigPhys)
+#endif
+static INLINE PVRSRV_ERROR OSReserveDiscontigPhys(IMG_SYS_PHYADDR *pBasePAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_VOID **ppvCpuVAddr, IMG_HANDLE *phOSMemHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(pBasePAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        PVR_UNREFERENCED_PARAMETER(ppvCpuVAddr);
+        PVR_UNREFERENCED_PARAMETER(phOSMemHandle);
+
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSUnReserveDiscontigPhys)
+#endif
+static INLINE PVRSRV_ERROR OSUnReserveDiscontigPhys(IMG_VOID *pvCpuVAddr, IMG_SIZE_T ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
+{
+        PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+
+        return PVRSRV_ERROR_NOT_SUPPORTED;
+}
+#endif  
+
+PVRSRV_ERROR OSRegisterMem(IMG_CPU_PHYADDR BasePAddr,
+                                                        IMG_VOID *pvCpuVAddr,
+                                                        IMG_SIZE_T ui32Bytes,
+                                                        IMG_UINT32 ui32Flags,
+                                                        IMG_HANDLE *phOSMemHandle);
+PVRSRV_ERROR OSUnRegisterMem(IMG_VOID *pvCpuVAddr,
+                                                        IMG_SIZE_T ui32Bytes,
+                                                        IMG_UINT32 ui32Flags,
+                                                        IMG_HANDLE hOSMemHandle);
+
+
+
+#if defined(__linux__)
+PVRSRV_ERROR OSGetSubMemHandle(IMG_HANDLE hOSMemHandle,
+                                                           IMG_UINTPTR_T ui32ByteOffset,
+                                                           IMG_SIZE_T ui32Bytes,
+                                                           IMG_UINT32 ui32Flags,
+                                                           IMG_HANDLE *phOSMemHandleRet);
+PVRSRV_ERROR OSReleaseSubMemHandle(IMG_HANDLE hOSMemHandle, IMG_UINT32 ui32Flags);
+#else
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSGetSubMemHandle)
+#endif
+static INLINE PVRSRV_ERROR OSGetSubMemHandle(IMG_HANDLE hOSMemHandle,
+                                                                                         IMG_UINTPTR_T ui32ByteOffset,
+                                                                                         IMG_SIZE_T ui32Bytes,
+                                                                                         IMG_UINT32 ui32Flags,
+                                                                                         IMG_HANDLE *phOSMemHandleRet)
+{
+        PVR_UNREFERENCED_PARAMETER(ui32ByteOffset);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+
+        *phOSMemHandleRet = hOSMemHandle;
+        return PVRSRV_OK;
+}
+
+static INLINE PVRSRV_ERROR OSReleaseSubMemHandle(IMG_HANDLE hOSMemHandle, IMG_UINT32 ui32Flags)
+{
+        PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+        return PVRSRV_OK;
+}
+#endif
+
+IMG_UINT32 OSGetCurrentProcessIDKM(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);
+PVRSRV_ERROR OSFreePages(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hPageAlloc);
+
+
+#ifdef PVRSRV_LOG_MEMORY_ALLOCS
+        #define OSAllocMem(flags, size, linAddr, blockAlloc, logStr) \
+                (PVR_TRACE(("OSAllocMem(" #flags ", " #size ", " #linAddr ", " #blockAlloc "): " logStr " (size = 0x%lx)", size)), \
+                        OSAllocMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__))
+
+        #define OSAllocPages(flags, size, pageSize, linAddr, pageAlloc) \
+                (PVR_TRACE(("OSAllocPages(" #flags ", " #size ", " #pageSize ", " #linAddr ", " #pageAlloc "): (size = 0x%lx)", size)), \
+                        OSAllocPages_Impl(flags, size, pageSize, linAddr, pageAlloc))
+                
+        #define OSFreeMem(flags, size, linAddr, blockAlloc) \
+                (PVR_TRACE(("OSFreeMem(" #flags ", " #size ", " #linAddr ", " #blockAlloc "): (pointer = 0x%X)", linAddr)), \
+                        OSFreeMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__))
+#else
+        #define OSAllocMem(flags, size, linAddr, blockAlloc, logString) \
+                OSAllocMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__)
+        
+        #define OSAllocPages OSAllocPages_Impl
+        
+        #define OSFreeMem(flags, size, linAddr, blockAlloc) \
+                        OSFreeMem_Debug_Wrapper(flags, size, linAddr, blockAlloc, __FILE__, __LINE__)
+#endif
+ 
+#ifdef PVRSRV_DEBUG_OS_MEMORY
+
+        PVRSRV_ERROR OSAllocMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+                                                                                IMG_UINT32 ui32Size,
+                                                                                IMG_PVOID *ppvCpuVAddr,
+                                                                                IMG_HANDLE *phBlockAlloc,
+                                                                                IMG_CHAR *pszFilename,
+                                                                                IMG_UINT32 ui32Line);
+        
+        PVRSRV_ERROR OSFreeMem_Debug_Wrapper(IMG_UINT32 ui32Flags,
+                                                                         IMG_UINT32 ui32Size,
+                                                                         IMG_PVOID pvCpuVAddr,
+                                                                         IMG_HANDLE hBlockAlloc,
+                                                                         IMG_CHAR *pszFilename,
+                                                                         IMG_UINT32 ui32Line);
+
+
+        typedef struct
+        {       
+                IMG_UINT8 sGuardRegionBefore[8];
+                IMG_CHAR sFileName[128];
+                IMG_UINT32 uLineNo;
+                IMG_SIZE_T uSize;
+                IMG_SIZE_T uSizeParityCheck;
+                enum valid_tag
+                {       isFree = 0x277260FF,
+                        isAllocated = 0x260511AA
+                } eValid;
+        } OSMEM_DEBUG_INFO;
+        
+        #define TEST_BUFFER_PADDING_STATUS (sizeof(OSMEM_DEBUG_INFO)) 
+        #define TEST_BUFFER_PADDING_AFTER  (8) 
+        #define TEST_BUFFER_PADDING (TEST_BUFFER_PADDING_STATUS + TEST_BUFFER_PADDING_AFTER)
+#else
+        #define OSAllocMem_Debug_Wrapper OSAllocMem_Debug_Linux_Memory_Allocations
+        #define OSFreeMem_Debug_Wrapper OSFreeMem_Debug_Linux_Memory_Allocations
+#endif
+ 
+#if defined(__linux__) && defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
+        PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
+        PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line);
+        
+        #define OSAllocMem_Debug_Linux_Memory_Allocations OSAllocMem_Impl
+        #define OSFreeMem_Debug_Linux_Memory_Allocations OSFreeMem_Impl
+#else
+        PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID *ppvLinAddr, IMG_HANDLE *phBlockAlloc);
+        PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T ui32Size, IMG_PVOID pvLinAddr, IMG_HANDLE hBlockAlloc);
+        
+        #define OSAllocMem_Debug_Linux_Memory_Allocations(flags, size, addr, blockAlloc, file, line) \
+                OSAllocMem_Impl(flags, size, addr, blockAlloc)
+        #define OSFreeMem_Debug_Linux_Memory_Allocations(flags, size, addr, blockAlloc, file, line) \
+                OSFreeMem_Impl(flags, size, addr, blockAlloc)
+#endif
+
+
+#if defined(__linux__)
+IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_SIZE_T ui32ByteOffset);
+#else
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSMemHandleToCpuPAddr)
+#endif
+static INLINE IMG_CPU_PHYADDR OSMemHandleToCpuPAddr(IMG_HANDLE hOSMemHandle, IMG_SIZE_T ui32ByteOffset)
+{
+        IMG_CPU_PHYADDR sCpuPAddr;
+        PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+        PVR_UNREFERENCED_PARAMETER(ui32ByteOffset);
+        sCpuPAddr.uiAddr = 0;
+        return sCpuPAddr;
+}
+#endif
+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_FORMAT_PRINTF(3, 4);
+#define OSStringLength(pszString) strlen(pszString)
+
+PVRSRV_ERROR OSEventObjectCreate(const IMG_CHAR *pszName,
+                                                                 PVRSRV_EVENTOBJECT *psEventObject);
+PVRSRV_ERROR OSEventObjectDestroy(PVRSRV_EVENTOBJECT *psEventObject);
+PVRSRV_ERROR OSEventObjectSignal(IMG_HANDLE hOSEventKM);
+PVRSRV_ERROR OSEventObjectWait(IMG_HANDLE hOSEventKM);
+PVRSRV_ERROR OSEventObjectOpen(PVRSRV_EVENTOBJECT *psEventObject,
+                                                                                        IMG_HANDLE *phOSEvent);
+PVRSRV_ERROR OSEventObjectClose(PVRSRV_EVENTOBJECT *psEventObject,
+                                                                                        IMG_HANDLE hOSEventKM);
+
+
+PVRSRV_ERROR OSBaseAllocContigMemory(IMG_SIZE_T ui32Size, IMG_CPU_VIRTADDR *pLinAddr, IMG_CPU_PHYADDR *pPhysAddr);
+PVRSRV_ERROR OSBaseFreeContigMemory(IMG_SIZE_T ui32Size, IMG_CPU_VIRTADDR LinAddr, IMG_CPU_PHYADDR PhysAddr);
+
+IMG_PVOID MapUserFromKernel(IMG_PVOID pvLinAddrKM,IMG_SIZE_T ui32Size,IMG_HANDLE *phMemBlock);
+IMG_PVOID OSMapHWRegsIntoUserSpace(IMG_HANDLE hDevCookie, IMG_SYS_PHYADDR sRegAddr, IMG_UINT32 ulSize, IMG_PVOID *ppvProcess);
+IMG_VOID  OSUnmapHWRegsFromUserSpace(IMG_HANDLE hDevCookie, IMG_PVOID pvUserAddr, IMG_PVOID pvProcess);
+
+IMG_VOID  UnmapUserFromKernel(IMG_PVOID pvLinAddrUM, IMG_SIZE_T ui32Size, IMG_HANDLE hMemBlock);
+
+PVRSRV_ERROR OSMapPhysToUserSpace(IMG_HANDLE hDevCookie,
+                                                                  IMG_SYS_PHYADDR sCPUPhysAddr,
+                                                                  IMG_SIZE_T uiSizeInBytes,
+                                                                  IMG_UINT32 ui32CacheFlags,
+                                                                  IMG_PVOID *ppvUserAddr,
+                                                                  IMG_SIZE_T *puiActualSize,
+                                                                  IMG_HANDLE hMappingHandle);
+
+PVRSRV_ERROR OSUnmapPhysToUserSpace(IMG_HANDLE hDevCookie,
+                                                                        IMG_PVOID pvUserAddr,
+                                                                        IMG_PVOID pvProcess);
+
+PVRSRV_ERROR OSLockResource(PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID);
+PVRSRV_ERROR OSUnlockResource(PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID);
+IMG_BOOL OSIsResourceLocked(PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID);
+PVRSRV_ERROR OSCreateResource(PVRSRV_RESOURCE *psResource);
+PVRSRV_ERROR OSDestroyResource(PVRSRV_RESOURCE *psResource);
+IMG_VOID OSBreakResourceLock(PVRSRV_RESOURCE *psResource, IMG_UINT32 ui32ID);
+IMG_VOID OSWaitus(IMG_UINT32 ui32Timeus);
+IMG_VOID OSReleaseThreadQuanta(IMG_VOID);
+IMG_UINT32 OSPCIReadDword(IMG_UINT32 ui32Bus, IMG_UINT32 ui32Dev, IMG_UINT32 ui32Func, IMG_UINT32 ui32Reg);
+IMG_VOID OSPCIWriteDword(IMG_UINT32 ui32Bus, IMG_UINT32 ui32Dev, IMG_UINT32 ui32Func, IMG_UINT32 ui32Reg, IMG_UINT32 ui32Value);
+
+#ifndef OSReadHWReg
+IMG_UINT32 OSReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset);
+#endif
+#ifndef OSWriteHWReg
+IMG_VOID OSWriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value);
+#endif
+
+typedef IMG_VOID (*PFN_TIMER_FUNC)(IMG_VOID*);
+IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32 ui32MsTimeout);
+PVRSRV_ERROR OSRemoveTimer (IMG_HANDLE hTimer);
+PVRSRV_ERROR OSEnableTimer (IMG_HANDLE hTimer);
+PVRSRV_ERROR OSDisableTimer (IMG_HANDLE hTimer);
+
+PVRSRV_ERROR OSGetSysMemSize(IMG_SIZE_T *pui32Bytes);
+
+typedef enum _HOST_PCI_INIT_FLAGS_
+{
+        HOST_PCI_INIT_FLAG_BUS_MASTER   = 0x00000001,
+        HOST_PCI_INIT_FLAG_MSI          = 0x00000002,
+        HOST_PCI_INIT_FLAG_FORCE_I32    = 0x7fffffff
+} HOST_PCI_INIT_FLAGS;
+
+struct _PVRSRV_PCI_DEV_OPAQUE_STRUCT_;
+typedef struct _PVRSRV_PCI_DEV_OPAQUE_STRUCT_ *PVRSRV_PCI_DEV_HANDLE;
+
+PVRSRV_PCI_DEV_HANDLE OSPCIAcquireDev(IMG_UINT16 ui16VendorID, IMG_UINT16 ui16DeviceID, HOST_PCI_INIT_FLAGS eFlags);
+PVRSRV_PCI_DEV_HANDLE OSPCISetDev(IMG_VOID *pvPCICookie, HOST_PCI_INIT_FLAGS eFlags);
+PVRSRV_ERROR OSPCIReleaseDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI);
+PVRSRV_ERROR OSPCIIRQ(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 *pui32IRQ);
+IMG_UINT32 OSPCIAddrRangeLen(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index);
+IMG_UINT32 OSPCIAddrRangeStart(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index);
+IMG_UINT32 OSPCIAddrRangeEnd(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index);
+PVRSRV_ERROR OSPCIRequestAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index);
+PVRSRV_ERROR OSPCIReleaseAddrRange(PVRSRV_PCI_DEV_HANDLE hPVRPCI, IMG_UINT32 ui32Index);
+PVRSRV_ERROR OSPCISuspendDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI);
+PVRSRV_ERROR OSPCIResumeDev(PVRSRV_PCI_DEV_HANDLE hPVRPCI);
+
+PVRSRV_ERROR OSScheduleMISR(IMG_VOID *pvSysData);
+
+IMG_VOID OSPanic(IMG_VOID);
+
+IMG_BOOL OSProcHasPrivSrvInit(IMG_VOID);
+
+typedef enum _img_verify_test
+{
+        PVR_VERIFY_WRITE = 0,
+        PVR_VERIFY_READ
+} IMG_VERIFY_TEST;
+
+IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_SIZE_T ui32Bytes);
+
+PVRSRV_ERROR OSCopyToUser(IMG_PVOID pvProcess, IMG_VOID *pvDest, IMG_VOID *pvSrc, IMG_SIZE_T ui32Bytes);
+PVRSRV_ERROR OSCopyFromUser(IMG_PVOID pvProcess, IMG_VOID *pvDest, IMG_VOID *pvSrc, IMG_SIZE_T ui32Bytes);
+
+#if defined(__linux__)
+PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID* pvCPUVAddr, 
+                                                                        IMG_SIZE_T ui32Bytes, 
+                                                                        IMG_SYS_PHYADDR *psSysPAddr,
+                                                                        IMG_HANDLE *phOSWrapMem);
+PVRSRV_ERROR OSReleasePhysPageAddr(IMG_HANDLE hOSWrapMem);
+#else
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSAcquirePhysPageAddr)
+#endif
+static INLINE PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID* pvCPUVAddr, 
+                                                                                                IMG_SIZE_T ui32Bytes, 
+                                                                                                IMG_SYS_PHYADDR *psSysPAddr,
+                                                                                                IMG_HANDLE *phOSWrapMem)
+{
+        PVR_UNREFERENCED_PARAMETER(pvCPUVAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+        PVR_UNREFERENCED_PARAMETER(psSysPAddr);
+        PVR_UNREFERENCED_PARAMETER(phOSWrapMem);
+        return PVRSRV_OK;       
+}
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSReleasePhysPageAddr)
+#endif
+static INLINE PVRSRV_ERROR OSReleasePhysPageAddr(IMG_HANDLE hOSWrapMem)
+{
+        PVR_UNREFERENCED_PARAMETER(hOSWrapMem);
+        return PVRSRV_OK;       
+}
+#endif
+                                                                        
+#if defined(__linux__) && defined(__KERNEL__)
+
+#define OS_SUPPORTS_IN_LISR
+
+static inline IMG_BOOL OSInLISR(IMG_VOID unref__ *pvSysData)
+{
+        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)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/osfunc_common.c b/drivers/gpu/pvr/osfunc_common.c
new file mode 100644
index 00000000000..25ac6677fbc
--- /dev/null
+++ b/drivers/gpu/pvr/osfunc_common.c
@@ -0,0 +1,31 @@
+/**********************************************************************
+ *
+ * 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"
+
+
diff --git a/drivers/gpu/pvr/osperproc.c b/drivers/gpu/pvr/osperproc.c
new file mode 100644
index 00000000000..882234f5df5
--- /dev/null
+++ b/drivers/gpu/pvr/osperproc.c
@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * 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 "osperproc.h"
+
+#include "env_perproc.h"
+#include "proc.h"
+
+extern IMG_UINT32 gui32ReleasePID;
+
+PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData)
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hBlockAlloc;
+        PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
+
+        eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
+                                phOsPrivateData,
+                                &hBlockAlloc,
+                                "Environment per Process Data");
+
+        if (eError != PVRSRV_OK)
+        {
+                *phOsPrivateData = IMG_NULL;
+
+                PVR_DPF((PVR_DBG_ERROR, "%s: OSAllocMem failed (%d)", __FUNCTION__, eError));
+                return eError;
+        }
+
+        psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)*phOsPrivateData;
+        OSMemSet(psEnvPerProc, 0, sizeof(*psEnvPerProc));
+
+        psEnvPerProc->hBlockAlloc = hBlockAlloc;
+
+
+        LinuxMMapPerProcessConnect(psEnvPerProc);
+
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+
+        INIT_LIST_HEAD(&psEnvPerProc->sDRMAuthListHead);
+#endif
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSPerProcessPrivateDataDeInit(IMG_HANDLE hOsPrivateData)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;
+
+        if (hOsPrivateData == IMG_NULL)
+        {
+                return PVRSRV_OK;
+        }
+
+        psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)hOsPrivateData;
+
+
+        LinuxMMapPerProcessDisconnect(psEnvPerProc);
+
+
+        RemovePerProcessProcDir(psEnvPerProc);
+
+        eError = OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                sizeof(PVRSRV_ENV_PER_PROCESS_DATA),
+                                hOsPrivateData,
+                                psEnvPerProc->hBlockAlloc);
+
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: OSFreeMem failed (%d)", __FUNCTION__, eError));
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR OSPerProcessSetHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase)
+{
+        return LinuxMMapPerProcessHandleOptions(psHandleBase);
+}
+
+IMG_HANDLE LinuxTerminatingProcessPrivateData(IMG_VOID)
+{
+        if(!gui32ReleasePID)
+                return NULL;
+        return PVRSRVPerProcessPrivateData(gui32ReleasePID);
+}
diff --git a/drivers/gpu/pvr/osperproc.h b/drivers/gpu/pvr/osperproc.h
new file mode 100644
index 00000000000..80a912f2488
--- /dev/null
+++ b/drivers/gpu/pvr/osperproc.h
@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * 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 __OSPERPROC_H__
+#define __OSPERPROC_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#if defined(__linux__)
+PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData);
+PVRSRV_ERROR OSPerProcessPrivateDataDeInit(IMG_HANDLE hOsPrivateData);
+
+PVRSRV_ERROR OSPerProcessSetHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase);
+#else   
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSPerProcessPrivateDataInit)
+#endif
+static INLINE PVRSRV_ERROR OSPerProcessPrivateDataInit(IMG_HANDLE *phOsPrivateData)
+{
+        PVR_UNREFERENCED_PARAMETER(phOsPrivateData);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSPerProcessPrivateDataDeInit)
+#endif
+static INLINE PVRSRV_ERROR OSPerProcessPrivateDataDeInit(IMG_HANDLE hOsPrivateData)
+{
+        PVR_UNREFERENCED_PARAMETER(hOsPrivateData);
+
+        return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(OSPerProcessSetHandleOptions)
+#endif
+static INLINE PVRSRV_ERROR OSPerProcessSetHandleOptions(PVRSRV_HANDLE_BASE *psHandleBase)
+{
+        PVR_UNREFERENCED_PARAMETER(psHandleBase);
+
+        return PVRSRV_OK;
+}
+#endif  
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pdump.c b/drivers/gpu/pvr/pdump.c
new file mode 100644
index 00000000000..0cae749cd46
--- /dev/null
+++ b/drivers/gpu/pvr/pdump.c
@@ -0,0 +1,627 @@
+/**********************************************************************
+ *
+ * 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_SGX) || defined (SUPPORT_VGX)
+#if defined (PDUMP)
+
+#include <asm/atomic.h>
+#include <stdarg.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/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_VOID DbgSetMarker                    (PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
+
+#define PDUMP_DATAMASTER_PIXEL          (1)
+#define PDUMP_DATAMASTER_EDM            (3)
+
+#define MAX_FILE_SIZE   0x40000000
+
+static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
+
+static PDBGKM_SERVICE_TABLE gpfnDbgDrv = IMG_NULL;
+
+
+
+IMG_CHAR *pszStreamName[PDUMP_NUM_STREAMS] = {  "ParamStream2",
+                                                                                                "ScriptStream2",
+                                                                                                "DriverInfoStream"};
+typedef struct PDBG_PDUMP_STATE_TAG
+{
+        PDBG_STREAM psStream[PDUMP_NUM_STREAMS];
+        IMG_UINT32 ui32ParamFileNum;
+
+        IMG_CHAR *pszMsg;
+        IMG_CHAR *pszScript;
+        IMG_CHAR *pszFile;
+
+} PDBG_PDUMP_STATE;
+
+static PDBG_PDUMP_STATE gsDBGPdumpState = {{IMG_NULL}, 0, IMG_NULL, IMG_NULL, IMG_NULL};
+
+#define SZ_MSG_SIZE_MAX                 PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
+#define SZ_SCRIPT_SIZE_MAX              PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
+#define SZ_FILENAME_SIZE_MAX    PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
+
+
+
+
+IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table);
+
+static inline IMG_BOOL PDumpSuspended(IMG_VOID)
+{
+        return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
+}
+
+PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
+                                                                        IMG_UINT32 *pui32MaxLen)
+{
+        *phScript = (IMG_HANDLE)gsDBGPdumpState.pszScript;
+        *pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
+        if ((!*phScript) || PDumpSuspended())
+        {
+                return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
+        }
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg,
+                                                                         IMG_UINT32 *pui32MaxLen)
+{
+        *ppszMsg = gsDBGPdumpState.pszMsg;
+        *pui32MaxLen = SZ_MSG_SIZE_MAX;
+        if ((!*ppszMsg) || PDumpSuspended())
+        {
+                return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
+        }
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile,
+                                                                         IMG_UINT32 *pui32MaxLen)
+{
+        *ppszFile = gsDBGPdumpState.pszFile;
+        *pui32MaxLen = SZ_FILENAME_SIZE_MAX;
+        if ((!*ppszFile) || PDumpSuspended())
+        {
+                return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
+        }
+        return PVRSRV_OK;
+}
+
+IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags)
+{
+        return PDumpWriteString2(hScript, ui32Flags);
+}
+
+PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
+{
+        IMG_CHAR* pszBuf = hBuf;
+        IMG_INT32 n;
+        va_list vaArgs;
+
+        va_start(vaArgs, pszFormat);
+
+        n = vsnprintf(pszBuf, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+        va_end(vaArgs);
+
+        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_INT32 n;
+
+        n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+        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;
+        }
+
+        return PVRSRV_OK;
+}
+
+IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
+{
+        PVR_UNREFERENCED_PARAMETER(pszFormat);
+
+        
+}
+
+PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
+{
+        IMG_INT32 n;
+        va_list vaArgs;
+
+        va_start(vaArgs, pszFormat);
+
+        n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
+
+        va_end(vaArgs);
+
+        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;
+        }
+
+        return PVRSRV_OK;
+}
+
+IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
+{
+        IMG_CHAR* pszBuf = hBuffer;
+        IMG_UINT32 ui32Count = 0;
+
+        while ((pszBuf[ui32Count]!=0) && (ui32Count<ui32BufferSizeMax) )
+        {
+                ui32Count++;
+        }
+        return(ui32Count);
+}
+
+IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
+{
+        IMG_UINT32 ui32Count;
+        IMG_CHAR* pszBuf = hBuffer;
+
+        
+        ui32Count = PDumpOSBuflen(hBuffer, ui32BufferSizeMax);
+
+        
+        if ((ui32Count >= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count<ui32BufferSizeMax))
+        {
+                pszBuf[ui32Count] = '\n';
+                ui32Count++;
+                pszBuf[ui32Count] = '\0';
+        }
+        if ((ui32Count >= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32Count<ui32BufferSizeMax))
+        {
+                pszBuf[ui32Count-1] = '\r';
+                pszBuf[ui32Count] = '\n';
+                ui32Count++;
+                pszBuf[ui32Count] = '\0';
+        }
+}
+
+IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream)
+{
+        return (IMG_HANDLE)gsDBGPdumpState.psStream[ePDumpStream];
+}
+
+IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream)
+{
+        PDBG_STREAM psStream = gsDBGPdumpState.psStream[ePDumpStream];
+        return gpfnDbgDrv->pfnGetStreamOffset(psStream);
+}
+
+IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID)
+{
+        return gsDBGPdumpState.ui32ParamFileNum;
+}
+
+IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
+                IMG_UINT8 *psui8Data,
+                IMG_UINT32 ui32Size,
+                IMG_UINT32 ui32Flags)
+{
+        PDBG_STREAM psStream = (PDBG_STREAM)hStream;
+        return PDumpWriteILock(psStream,
+                                        psui8Data,
+                                        ui32Size,
+                                        ui32Flags);
+}
+
+IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags)
+{
+        
+        PVR_UNREFERENCED_PARAMETER(hStream);
+        PVR_UNREFERENCED_PARAMETER(ui32Size);
+        PVR_UNREFERENCED_PARAMETER(ui32Flags);
+}
+
+IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
+{
+        if(gpfnDbgDrv)
+        {
+                return IMG_TRUE;
+        }
+        return IMG_FALSE;
+}
+
+inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
+{
+        return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
+}
+
+IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+        IMG_HANDLE hOSMemHandle,
+                IMG_UINT32 ui32Offset,
+                IMG_UINT8 *pui8LinAddr,
+                IMG_UINT32 ui32PageSize,
+                IMG_DEV_PHYADDR *psDevPAddr)
+{
+        IMG_CPU_PHYADDR sCpuPAddr;
+
+        PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+        PVR_UNREFERENCED_PARAMETER(ui32PageSize);   
+
+        
+           
+        PVR_ASSERT (hOSMemHandle != IMG_NULL);
+        
+        sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
+        PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
+
+        
+        *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
+}
+
+IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
+                IMG_UINT32 ui32Offset,
+                IMG_PUINT8 pui8LinAddr,
+                IMG_UINT32 ui32DataPageMask,
+                IMG_UINT32 *pui32PageOffset)
+{
+        if(hOSMemHandle)
+        {
+                
+                IMG_CPU_PHYADDR     sCpuPAddr;
+
+                PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
+
+                sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
+            *pui32PageOffset = sCpuPAddr.uiAddr & ui32DataPageMask;
+        }
+        else
+        {
+                PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
+                PVR_UNREFERENCED_PARAMETER(ui32Offset);
+
+                *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)
+                {
+                        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0,
+                                "Filename string") != PVRSRV_OK)
+                        {
+                                goto init_failed;
+                        }
+                }
+
+                if(!gsDBGPdumpState.pszMsg)
+                {
+                        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0,
+                                "Message string") != PVRSRV_OK)
+                        {
+                                goto init_failed;
+                        }
+                }
+
+                if(!gsDBGPdumpState.pszScript)
+                {
+                        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0,
+                                "Script string") != PVRSRV_OK)
+                        {
+                                goto init_failed;
+                        }
+                }
+
+                for(i=0; i < PDUMP_NUM_STREAMS; i++)
+                {
+                        gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
+                                                                                                                DEBUG_CAPMODE_FRAMED,
+                                                                                                                DEBUG_OUTMODE_STREAMENABLE,
+                                                                                                                0,
+                                                                                                                10);
+
+                        gpfnDbgDrv->pfnSetCaptureMode(gsDBGPdumpState.psStream[i],DEBUG_CAPMODE_FRAMED,0xFFFFFFFF, 0xFFFFFFFF, 1);
+                        gpfnDbgDrv->pfnSetFrame(gsDBGPdumpState.psStream[i],0);
+                }
+
+                PDUMPCOMMENT("Driver Product Name: %s", VS_PRODUCT_NAME);
+                PDUMPCOMMENT("Driver Product Version: %s (%s)", PVRVERSION_STRING, PVRVERSION_FILE);
+                PDUMPCOMMENT("Start of Init Phase");
+        }
+
+        return;
+
+init_failed:
+
+        if(gsDBGPdumpState.pszFile)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
+                gsDBGPdumpState.pszFile = IMG_NULL;
+        }
+
+        if(gsDBGPdumpState.pszScript)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
+                gsDBGPdumpState.pszScript = IMG_NULL;
+        }
+
+        if(gsDBGPdumpState.pszMsg)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
+                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++)
+        {
+                gpfnDbgDrv->pfnDestroyStream(gsDBGPdumpState.psStream[i]);
+        }
+
+        if(gsDBGPdumpState.pszFile)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
+                gsDBGPdumpState.pszFile = IMG_NULL;
+        }
+
+        if(gsDBGPdumpState.pszScript)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
+                gsDBGPdumpState.pszScript = IMG_NULL;
+        }
+
+        if(gsDBGPdumpState.pszMsg)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
+                gsDBGPdumpState.pszMsg = IMG_NULL;
+        }
+
+        
+        sConnectNotifier.pfnConnectNotifier = 0;
+        gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
+
+        gpfnDbgDrv = IMG_NULL;
+}
+
+PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID)
+{
+        IMG_UINT32 i;
+
+        if (gpfnDbgDrv)
+        {
+                PDUMPCOMMENT("Start Init Phase");
+                for(i=0; i < PDUMP_NUM_STREAMS; i++)
+                {
+                        gpfnDbgDrv->pfnStartInitPhase(gsDBGPdumpState.psStream[i]);
+                }
+        }
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID)
+{
+        IMG_UINT32 i;
+
+        if (gpfnDbgDrv)
+        {
+                PDUMPCOMMENT("Stop Init Phase");
+
+                for(i=0; i < PDUMP_NUM_STREAMS; i++)
+                {
+                        gpfnDbgDrv->pfnStopInitPhase(gsDBGPdumpState.psStream[i]);
+                }
+        }
+        return PVRSRV_OK;
+}
+
+IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID)
+{
+        return gpfnDbgDrv->pfnIsLastCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
+}
+
+
+IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID)
+{
+        if (PDumpSuspended())
+        {
+                return IMG_FALSE;
+        }
+        return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
+}
+
+PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
+{
+        IMG_UINT32      ui32Stream;
+
+        for     (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
+        {
+                if      (gsDBGPdumpState.psStream[ui32Stream])
+                {
+                        DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
+{
+        return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
+}
+
+
+static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
+{
+        IMG_UINT32 ui32Written = 0;
+        if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
+        {
+                return IMG_TRUE;
+        }
+
+
+        
+
+        if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
+        {
+                IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
+
+                if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
+                {
+                        if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
+                        {
+                                DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
+                                gsDBGPdumpState.ui32ParamFileNum++;
+                        }
+                }
+        }
+
+        ui32Written = DbgWrite(psStream, pui8Data, ui32Count, ui32Flags);
+
+        if (ui32Written == 0xFFFFFFFF)
+        {
+                return IMG_FALSE;
+        }
+
+        return IMG_TRUE;
+}
+
+static IMG_VOID DbgSetFrame(PDBG_STREAM psStream, IMG_UINT32 ui32Frame)
+{
+        gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
+}
+
+static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
+{
+        gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
+}
+
+IMG_VOID PDumpSuspendKM(IMG_VOID)
+{
+        atomic_inc(&gsPDumpSuspended);
+}
+
+IMG_VOID PDumpResumeKM(IMG_VOID)
+{
+        atomic_dec(&gsPDumpSuspended);
+}
+
+#endif 
+#endif 
diff --git a/drivers/gpu/pvr/pdump.h b/drivers/gpu/pvr/pdump.h
new file mode 100644
index 00000000000..00d884b4ae6
--- /dev/null
+++ b/drivers/gpu/pvr/pdump.h
@@ -0,0 +1,37 @@
+/**********************************************************************
+ *
+ * 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                       0x08000000UL
+#define PDUMP_FLAGS_LASTFRAME           0x10000000UL
+#define PDUMP_FLAGS_RESETLFBUFFER       0x20000000UL
+#define PDUMP_FLAGS_CONTINUOUS          0x40000000UL
+#define PDUMP_FLAGS_PERSISTENT          0x80000000UL
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pdump_common.c b/drivers/gpu/pvr/pdump_common.c
new file mode 100644
index 00000000000..430efe4eba0
--- /dev/null
+++ b/drivers/gpu/pvr/pdump_common.c
@@ -0,0 +1,2248 @@
+/**********************************************************************
+ *
+ * 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(PDUMP)
+#include <stdarg.h>
+
+#include "services_headers.h"
+#if defined(SUPPORT_SGX)
+#include "sgxdefs.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 * 1024U)
+#endif
+
+#if 1
+#define PDUMP_DBG(a)   PDumpOSDebugPrintf (a)
+#else
+#define PDUMP_DBG(a)
+#endif
+
+#define PDUMP_DATAMASTER_PIXEL          (1)
+#define PDUMP_DATAMASTER_EDM            (3)
+
+#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(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)
+{
+        
+        if (gpvTempBuffer == IMG_NULL)
+        {
+                PVRSRV_ERROR eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                          PDUMP_TEMP_BUFFER_SIZE,
+                                          &gpvTempBuffer,
+                                          &ghTempBufferBlockAlloc,
+                                          "PDUMP Temporary Buffer");
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "GetTempBuffer: OSAllocMem failed: %d", eError));
+                }
+        }
+
+        return gpvTempBuffer;
+}
+
+static IMG_VOID FreeTempBuffer(IMG_VOID)
+{
+
+        if (gpvTempBuffer != IMG_NULL)
+        {
+                PVRSRV_ERROR eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                          PDUMP_TEMP_BUFFER_SIZE,
+                                          gpvTempBuffer,
+                                          ghTempBufferBlockAlloc);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "FreeTempBuffer: OSFreeMem failed: %d", eError));
+                }
+                else
+                {
+                        gpvTempBuffer = IMG_NULL;
+                }
+        }
+}
+
+IMG_VOID PDumpInitCommon(IMG_VOID)
+{
+        
+        (IMG_VOID) GetTempBuffer();
+
+        
+        PDumpInit();
+}
+
+IMG_VOID PDumpDeInitCommon(IMG_VOID)
+{
+        
+        FreeTempBuffer();
+
+        
+        PDumpDeInit();
+}
+
+IMG_BOOL PDumpIsSuspended(IMG_VOID)
+{
+        return PDumpOSIsSuspended();
+}
+
+
+
+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 :%s:0x%08X 0x%08X\r\n",
+                                                                pszPDumpRegName, ui32Reg, ui32Data);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpRegKM(IMG_CHAR *pszPDumpRegName,
+                                                IMG_UINT32 ui32Reg,
+                                                IMG_UINT32 ui32Data)
+{
+        return PDumpRegWithFlagsKM(pszPDumpRegName, ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+                                                                        IMG_UINT32 ui32RegAddr, 
+                                                                        IMG_UINT32 ui32RegValue, 
+                                                                        IMG_UINT32 ui32Mask,
+                                                                        IMG_UINT32 ui32Flags)
+{
+        
+        #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) &&
+                (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK) != 0) ||
+            ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
+                (ui32RegValue & ui32Mask & EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK) != 0))
+        {
+                ui32PollCount = POLL_COUNT_LONG;
+        }
+        else
+#endif
+        {
+                ui32PollCount = POLL_COUNT_LONG;
+        }
+
+        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;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName, IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask)
+{
+        return PDumpRegPolWithFlagsKM(pszPDumpRegName, ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpMallocPages (PVRSRV_DEVICE_IDENTIFIER *psDevID,
+                           IMG_UINT32         ui32DevVAddr,
+                           IMG_CPU_VIRTADDR   pvLinAddr,
+                           IMG_HANDLE         hOSMemHandle,
+                           IMG_UINT32         ui32NumBytes,
+                           IMG_UINT32         ui32PageSize,
+                           IMG_HANDLE         hUniqueTag)
+{
+        PVRSRV_ERROR eErr;
+        IMG_PUINT8              pui8LinAddr;
+    IMG_UINT32      ui32Offset;
+        IMG_UINT32              ui32NumPages;
+        IMG_DEV_PHYADDR sDevPAddr;
+        IMG_UINT32              ui32Page;
+        IMG_UINT32              ui32Flags = PDUMP_FLAGS_CONTINUOUS;
+
+        PDUMP_GET_SCRIPT_STRING();
+        ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+
+        
+#if !defined(LINUX)
+        PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & HOST_PAGEMASK) == 0);
+#endif
+
+        PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & HOST_PAGEMASK) == 0);
+        PVR_ASSERT(((IMG_UINT32) ui32NumBytes & HOST_PAGEMASK) == 0);
+
+        
+
+        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, ui32Flags);
+
+        
+
+        pui8LinAddr = (IMG_PUINT8) pvLinAddr;
+        ui32Offset = 0;
+        ui32NumPages = ui32NumBytes / ui32PageSize;
+        while (ui32NumPages)
+        { 
+                ui32NumPages--;
+
+                
+
+
+
+
+
+
+                
+                
+                
+                PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,
+                                hOSMemHandle,
+                                ui32Offset,
+                                pui8LinAddr,
+                                ui32PageSize,
+                                &sDevPAddr);
+                ui32Page = (IMG_UINT32)(sDevPAddr.uiAddr / ui32PageSize);
+                
+                pui8LinAddr     += ui32PageSize;
+                ui32Offset += ui32PageSize;
+
+                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,
+                                                                                                ui32Page * ui32PageSize);
+                if(eErr != PVRSRV_OK)
+                {
+                        return eErr;
+                }
+                PDumpOSWriteString2(hScript, ui32Flags);
+        }
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpMallocPageTable (PVRSRV_DEVICE_IDENTIFIER     *psDevId,
+                                                                   IMG_HANDLE hOSMemHandle,
+                                                                   IMG_UINT32 ui32Offset,
+                               IMG_CPU_VIRTADDR   pvLinAddr,
+                                                                IMG_UINT32        ui32PTSize,
+                               IMG_HANDLE         hUniqueTag)
+{
+        PVRSRV_ERROR eErr;
+        IMG_DEV_PHYADDR sDevPAddr;
+        IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
+
+        PDUMP_GET_SCRIPT_STRING();
+
+        PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize - 1)) == 0);
+        ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+
+        
+
+        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, 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)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpFreePages     (BM_HEAP                        *psBMHeap,
+                         IMG_DEV_VIRTADDR  sDevVAddr,
+                         IMG_UINT32        ui32NumBytes,
+                         IMG_UINT32        ui32PageSize,
+                         IMG_HANDLE        hUniqueTag,
+                                                 IMG_BOOL                  bInterleaved)
+{
+        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 :%s:VA_%08X\r\n", 
+                                                        psDeviceNode->sDevId.pszPDumpDevName, sDevVAddr.uiAddr);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        
+
+        ui32NumPages = ui32NumBytes / ui32PageSize;
+        for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages; ui32PageCounter++)
+        {
+                if (!bInterleaved || (ui32PageCounter % 2) == 0)
+                {
+                        sDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->pMMUHeap, sDevVAddr);
+                        {
+                                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);
+                        }
+                }
+                else
+                {
+                        
+                }
+
+                sDevVAddr.uiAddr += ui32PageSize;
+        }
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpFreePageTable (PVRSRV_DEVICE_IDENTIFIER *psDevID,
+                                                                 IMG_HANDLE hOSMemHandle,
+                                                                 IMG_CPU_VIRTADDR   pvLinAddr,
+                                                                 IMG_UINT32         ui32PTSize,
+                                                                 IMG_HANDLE         hUniqueTag)
+{
+        PVRSRV_ERROR eErr;
+        IMG_DEV_PHYADDR sDevPAddr;
+        IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;
+
+        PDUMP_GET_SCRIPT_STRING();
+
+        PVR_UNREFERENCED_PARAMETER(ui32PTSize);
+        ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;
+
+        
+        PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize-1UL)) == 0); 
+
+        
+
+        eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:PAGE_TABLE\r\n", psDevID->pszPDumpDevName);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        
+
+        
+        
+        
+        
+
+        PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,
+                                                          hOSMemHandle, 
+                        0,
+                        (IMG_PUINT8) pvLinAddr,
+                        ui32PTSize,
+                        &sDevPAddr);
+
+        {
+                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, ui32Flags);
+        }
+
+        return PVRSRV_OK;
+}
+
+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 :%s:$1 :%s:PA_%08X%08X:0x0\r\n",
+                         psMMUAttrib->sDevId.pszPDumpDevName,
+                         psMMUAttrib->sDevId.pszPDumpDevName,
+                         (IMG_UINT32)hUniqueTag,
+                         (ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+        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 :%s:0x%08X: %s:$1\r\n",
+                         pszRegString,
+                         ui32Reg,
+                         psMMUAttrib->sDevId.pszPDumpDevName);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+#else
+        eErr = PDumpOSBufprintf(hScript,
+                                ui32MaxLen,
+                                "WRW :%s:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",
+                                pszRegString,
+                                ui32Reg,
+                                psMMUAttrib->sDevId.pszPDumpDevName,
+                                (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,
+                                (ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift,
+                                ui32Data & ~psMMUAttrib->ui32PDEMask);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+#endif
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpPDReg (PDUMP_MMU_ATTRIB *psMMUAttrib, 
+                                         IMG_UINT32 ui32Reg,
+                                         IMG_UINT32 ui32Data,
+                                         IMG_HANDLE hUniqueTag)
+{
+        return PDumpPDRegWithFlags(psMMUAttrib, ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS, hUniqueTag);
+}
+
+PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO               *psMemInfo,
+                                                   IMG_UINT32                   ui32Offset,
+                                                   IMG_UINT32                   ui32Value,
+                                                   IMG_UINT32                   ui32Mask,
+                                                   PDUMP_POLL_OPERATOR  eOperator,
+                                                   IMG_UINT32                   ui32Flags,
+                                                   IMG_HANDLE                   hUniqueTag)
+{
+        #define MEMPOLL_DELAY           (1000)
+        #define MEMPOLL_COUNT           (2000000000 / MEMPOLL_DELAY)
+
+        PVRSRV_ERROR eErr;
+        IMG_UINT32                      ui32PageOffset;
+        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 :%s:VA_%08X 0x%08X 0x%08X %d %d %d\r\n",
+                         psMMUAttrib->sDevId.pszPDumpDevName,
+                         psMemInfo->sDevVAddr.uiAddr + ui32Offset,
+                         ui32Value,
+                         ui32Mask,
+                         eOperator,
+                         MEMPOLL_COUNT,
+                         MEMPOLL_DELAY);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+
+        pui8LinAddr = psMemInfo->pvLinAddrKM;
+
+        
+        pui8LinAddr += ui32Offset;
+
+        
+
+
+        PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
+                        ui32Offset,
+                        pui8LinAddr,
+                        psMMUAttrib->ui32DataPageMask,
+                        &ui32PageOffset);
+
+        
+        sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;
+
+        PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);
+
+        
+        BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+
+        
+        sDevPAddr.uiAddr += ui32PageOffset;
+
+        eErr = PDumpOSBufprintf(hScript,
+                         ui32MaxLen,
+                         "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,
+                         MEMPOLL_COUNT,
+                         MEMPOLL_DELAY);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpMemKM(IMG_PVOID pvAltLinAddr,
+                                                PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                IMG_UINT32 ui32Offset,
+                                                IMG_UINT32 ui32Bytes,
+                                                IMG_UINT32 ui32Flags,
+                                                IMG_HANDLE hUniqueTag)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32 ui32NumPages;
+        IMG_UINT32 ui32PageByteOffset;
+        IMG_UINT32 ui32BlockBytes;
+        IMG_UINT8* pui8LinAddr;
+        IMG_UINT8* pui8DataLinAddr = IMG_NULL;
+        IMG_DEV_VIRTADDR sDevVPageAddr;
+        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_PDUMP_NOT_AVAILABLE;
+        }
+
+         
+        if (ui32Bytes == 0 || PDumpOSIsSuspended())
+        {
+                return PVRSRV_OK;
+        }
+
+        
+        if(pvAltLinAddr)
+        {
+                pui8DataLinAddr = pvAltLinAddr;
+        }
+        else if(psMemInfo->pvLinAddrKM)
+        {
+                pui8DataLinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM + ui32Offset;
+        }
+        pui8LinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM;
+        sDevVAddr = psMemInfo->sDevVAddr;
+
+        
+        sDevVAddr.uiAddr += ui32Offset;
+        pui8LinAddr += ui32Offset;
+
+        PVR_ASSERT(pui8DataLinAddr);
+
+        PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);
+
+        ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
+
+        
+
+        if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
+                                                pui8DataLinAddr,
+                                                ui32Bytes,
+                                                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: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,
+                         ui32ParamOutPos,
+                         pszFileName);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        
+
+
+        PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,
+                        ui32Offset,
+                        pui8LinAddr,
+                        psMMUAttrib->ui32DataPageMask,
+                        &ui32PageByteOffset);
+        ui32DataPageSize = psMMUAttrib->ui32DataPageMask + 1;
+        ui32NumPages = (ui32PageByteOffset + ui32Bytes + psMMUAttrib->ui32DataPageMask) / ui32DataPageSize;
+
+        while(ui32NumPages)
+        {
+                ui32NumPages--;
+        
+                
+                sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;
+
+                if (ui32DataPageSize <= PDUMP_TEMP_BUFFER_SIZE)
+                {
+                        
+                        PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);
+                }
+
+                
+                BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
+
+                
+                sDevPAddr.uiAddr += ui32PageByteOffset;
+
+                
+                if (ui32PageByteOffset + ui32Bytes > ui32DataPageSize)
+                {
+                        
+                        ui32BlockBytes = ui32DataPageSize - ui32PageByteOffset;
+                }
+                else
+                {
+                        
+                        ui32BlockBytes = ui32Bytes;
+                }
+
+                eErr = PDumpOSBufprintf(hScript,
+                                         ui32MaxLenScript,
+                                         "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(eErr != PVRSRV_OK)
+                {
+                        return eErr;
+                }
+                PDumpOSWriteString2(hScript, ui32Flags);
+
+                
+
+#if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)
+                
+                ui32PageByteOffset = (ui32PageByteOffset + ui32BlockBytes) % ui32DataPageSize;
+#else
+                
+                ui32PageByteOffset = 0;
+#endif
+                
+                ui32Bytes -= ui32BlockBytes;     
+                
+                sDevVAddr.uiAddr += ui32BlockBytes;
+                
+                pui8LinAddr += ui32BlockBytes;
+                
+                ui32ParamOutPos += ui32BlockBytes;
+        }
+
+        return PVRSRV_OK;
+}
+
+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_UINT32 ui32PageOffset;
+        IMG_UINT32 ui32BlockBytes;
+        IMG_UINT8* pui8LinAddr;
+        IMG_DEV_PHYADDR sDevPAddr;
+        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 (!PDumpOSJTInitialised())
+        {
+                return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;
+        }
+
+        if (!pvLinAddr)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if (PDumpOSIsSuspended())
+        {
+                return PVRSRV_OK;
+        }
+
+        PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);
+
+        ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);
+
+        if (bInitialisePages)
+        {
+                
+
+
+                if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),
+                                                        pvLinAddr,
+                                                        ui32Bytes,
+                                                        ui32Flags | PDUMP_FLAGS_CONTINUOUS))
+                {
+                        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;
+                }
+        }
+
+        
+
+
+
+
+        ui32PageMask = psMMUAttrib->ui32PTSize - 1;
+
+        
+
+        
+        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(hOSMemHandle, pui8LinAddr);
+                sDevPAddr = SysCpuPAddrToDevPAddr(psMMUAttrib->sDevId.eDeviceType, sCpuPAddr);
+
+                
+                if (ui32PageOffset + ui32Bytes > psMMUAttrib->ui32PTSize)
+                {
+                        
+                        ui32BlockBytes = psMMUAttrib->ui32PTSize - ui32PageOffset;
+                }
+                else
+                {
+                        
+                        ui32BlockBytes = ui32Bytes;
+                }
+
+                
+
+                
+                if (bInitialisePages)
+                {
+                        eErr = PDumpOSBufprintf(hScript,
+                                         ui32MaxLenScript,
+                                         "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);
+                        if(eErr != PVRSRV_OK)
+                        {
+                                return eErr;
+                        }
+                        PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
+                }
+                else
+                {
+                        for (ui32Offset = 0; ui32Offset < ui32BlockBytes; ui32Offset += sizeof(IMG_UINT32))
+                        {
+                                IMG_UINT32 ui32PTE = *((IMG_UINT32 *) (pui8LinAddr + ui32Offset));  
+
+                                if ((ui32PTE & psMMUAttrib->ui32PDEMask) != 0)
+                                {
+                                        
+#if defined(SGX_FEATURE_36BIT_MMU)
+                                        eErr = PDumpOSBufprintf(hScript,
+                                                        ui32MaxLenScript,
+                                                         "WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",
+                                                         psMMUAttrib->sDevId.pszPDumpDevName,
+                                                         psMMUAttrib->sDevId.pszPDumpDevName,
+                                                         (IMG_UINT32)hUniqueTag2,
+                                                         (ui32PTE & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PTEAlignShift);
+                                        if(eErr != PVRSRV_OK)
+                                        {
+                                                return eErr;
+                                        }
+                                        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, 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, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
+                                        eErr = PDumpOSBufprintf(hScript,
+                                                        ui32MaxLenScript,
+                                                         "WRW :%s:PA_%08X%08X:0x%08X :%s:$1\r\n",
+                                                         psMMUAttrib->sDevId.pszPDumpDevName,
+                                                         (IMG_UINT32)hUniqueTag1,
+                                                         (sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,
+                                                         (sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,
+                                                         psMMUAttrib->sDevId.pszPDumpDevName);
+                                        if(eErr != PVRSRV_OK)
+                                        {
+                                                return eErr;
+                                        }
+                                        PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);
+#else
+                                        eErr = PDumpOSBufprintf(hScript,
+                                                        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 + 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 & psMMUAttrib->ui32PTEValid) == 0UL);
+                                        eErr = PDumpOSBufprintf(hScript,
+                                                        ui32MaxLenScript,
+                                                         "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);
+                                }
+                        }
+                }
+
+                
+
+                
+                ui32PageOffset = 0;
+                
+                ui32Bytes -= ui32BlockBytes;
+                
+                pui8LinAddr += ui32BlockBytes;
+                
+                ui32ParamOutPos += ui32BlockBytes;
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                           IMG_UINT32 ui32Offset,
+                                                           IMG_DEV_PHYADDR sPDDevPAddr,
+                                                           IMG_HANDLE hUniqueTag1,
+                                                           IMG_HANDLE hUniqueTag2)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32 ui32PageByteOffset;
+        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_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),
+                                                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 eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+
+        
+        sDevVAddr = psMemInfo->sDevVAddr;
+        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 & psMMUAttrib->ui32PDEMask) != 0UL)
+        {
+#if defined(SGX_FEATURE_36BIT_MMU)
+                eErr = PDumpOSBufprintf(hScript,
+                                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, ui32Flags);
+
+                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, ui32Flags);
+
+                eErr = PDumpOSBufprintf(hScript,
+                                ui32MaxLenScript,
+                                 "WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",
+                                 psMMUAttrib->sDevId.pszPDumpDevName,
+                                 (IMG_UINT32)hUniqueTag1,
+                                 (sDevPAddr.uiAddr) & ~(psMMUAttrib->ui32DataPageMask),
+                                 (sDevPAddr.uiAddr) & (psMMUAttrib->ui32DataPageMask),
+                                 psMMUAttrib->sDevId.pszPDumpDevName);
+                if(eErr != PVRSRV_OK)
+                {
+                        return eErr;
+                }
+                PDumpOSWriteString2(hScript, ui32Flags);
+
+                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, ui32Flags);
+
+                eErr = PDumpOSBufprintf(hScript,
+                                ui32MaxLenScript,
+                                 "WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",
+                                 psMMUAttrib->sDevId.pszPDumpDevName,
+                                 (IMG_UINT32)hUniqueTag1,
+                                 (sDevPAddr.uiAddr + 4) & ~(psMMUAttrib->ui32DataPageMask),
+                                 (sDevPAddr.uiAddr + 4) & (psMMUAttrib->ui32DataPageMask),
+                                 psMMUAttrib->sDevId.pszPDumpDevName);
+                if(eErr != PVRSRV_OK)
+                {
+                        return eErr;
+                }
+                PDumpOSWriteString2(hScript, ui32Flags);
+#else
+                eErr = PDumpOSBufprintf(hScript,
+                                 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;
+                }
+#endif
+        }
+        else
+        {
+                PVR_ASSERT(!(sDevPAddr.uiAddr & psMMUAttrib->ui32PTEValid));
+                eErr = PDumpOSBufprintf(hScript,
+                                 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, ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags)
+{
+        PVRSRV_ERROR eErr;
+        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 (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_SCRIPT2),
+                          (IMG_UINT8*)pszCommentPrefix,
+                          ui32LenCommentPrefix,
+                          ui32Flags))
+        {
+                if(ui32Flags & PDUMP_FLAGS_CONTINUOUS)
+                {
+                        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(hScript, ui32MaxLen, "%s",
+                pszTemp);
+#else
+        eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "%s",
+                pszComment);
+#endif
+        if( (eErr != PVRSRV_OK) &&
+                (eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW))
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags, IMG_CHAR * pszFormat, ...)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_va_list ap;
+        PDUMP_GET_MSG_STRING();
+
+        
+        PDUMP_va_start(ap, pszFormat);
+        eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);
+        PDUMP_va_end(ap);
+
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        return PDumpCommentKM(pszMsg, ui32Flags);
+}
+
+PVRSRV_ERROR PDumpComment(IMG_CHAR *pszFormat, ...)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_va_list ap;
+        PDUMP_GET_MSG_STRING();
+
+        
+        PDUMP_va_start(ap, pszFormat);
+        eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);
+        PDUMP_va_end(ap);
+
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        return PDumpCommentKM(pszMsg, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32      ui32MsgLen;
+        PDUMP_GET_MSG_STRING();
+
+        
+        eErr = PDumpOSSprintf(pszMsg, ui32MaxLen, "%s", pszString);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        
+        PDumpOSVerifyLineEnding(pszMsg, ui32MaxLen);
+        ui32MsgLen = PDumpOSBuflen(pszMsg, ui32MaxLen);
+
+        if      (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_DRIVERINFO),
+                                                  (IMG_UINT8*)pszMsg,
+                                                  ui32MsgLen,
+                                                  ui32Flags))
+        {
+                if      (ui32Flags & PDUMP_FLAGS_CONTINUOUS)
+                {
+                        return PVRSRV_ERROR_PDUMP_BUFFER_FULL;
+                }
+                else
+                {
+                        return PVRSRV_ERROR_CMD_NOT_PROCESSED;
+                }
+        }
+        return PVRSRV_OK;
+}
+
+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 :%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,
+                                ui32FileOffset,
+                                ePixelFormat,
+                                ui32Width,
+                                ui32Height,
+                                ui32StrideInBytes,
+                                eMemFormat);
+#else
+        eErr = PDumpOSBufprintf(hScript,
+                                ui32MaxLen,
+                                "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,
+                                ePixelFormat,
+                                ui32Width,
+                                ui32Height,
+                                ui32StrideInBytes,
+                                eMemFormat);
+#endif
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpOSWriteString2( hScript, ui32PDumpFlags);
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpReadRegKM             (       IMG_CHAR *pszPDumpRegName,
+                                                                        IMG_CHAR *pszFileName,
+                                                                        IMG_UINT32 ui32FileOffset,
+                                                                        IMG_UINT32 ui32Address,
+                                                                        IMG_UINT32 ui32Size,
+                                                                        IMG_UINT32 ui32PDumpFlags)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_GET_SCRIPT_STRING();
+
+        PVR_UNREFERENCED_PARAMETER(ui32Size);
+
+        eErr = PDumpOSBufprintf(hScript,
+                        ui32MaxLen,
+                        "SAB :%s:0x%08X 0x%08X %s\r\n",
+                        pszPDumpRegName,
+                        ui32Address,
+                        ui32FileOffset,
+                        pszFileName);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpOSWriteString2( hScript, ui32PDumpFlags);
+
+        return PVRSRV_OK;
+}
+
+IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame)
+{
+        IMG_BOOL        bFrameDumped;
+
+        
+
+        (IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame + 1);
+        bFrameDumped = PDumpIsCaptureFrameKM();
+        (IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame);
+
+        return bFrameDumped;
+}
+
+static PVRSRV_ERROR PDumpSignatureRegister      (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                                                         IMG_CHAR       *pszFileName,
+                                                                         IMG_UINT32             ui32Address,
+                                                                         IMG_UINT32             ui32Size,
+                                                                         IMG_UINT32             *pui32FileOffset,
+                                                                         IMG_UINT32             ui32Flags)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_GET_SCRIPT_STRING();
+
+        eErr = PDumpOSBufprintf(hScript,
+                        ui32MaxLen,
+                        "SAB :%s:0x%08X 0x%08X %s\r\n",
+                        psDevId->pszPDumpRegName,
+                        ui32Address,
+                        *pui32FileOffset,
+                        pszFileName);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpOSWriteString2(hScript, ui32Flags);
+        *pui32FileOffset += ui32Size;
+        return PVRSRV_OK;
+}
+
+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(psDevId, pszFileName, pui32Registers[i], ui32Size, pui32FileOffset, ui32Flags);
+        }
+}
+
+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;
+
+        PDUMP_GET_FILE_STRING();
+
+        ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
+        ui32FileOffset = 0;
+
+        PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump 3D signature registers\r\n");
+        eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_3d.sig", ui32DumpFrameNum);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpRegisterRange(psDevId,
+                                                pszFileName,
+                                                pui32Registers,
+                                                ui32NumRegisters,
+                                                &ui32FileOffset,
+                                                sizeof(IMG_UINT32),
+                                                ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpTASignatureRegisters  (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                         IMG_UINT32 ui32DumpFrameNum,
+                         IMG_UINT32     ui32TAKickCount,
+                         IMG_BOOL       bLastFrame,
+                         IMG_UINT32 *pui32Registers,
+                         IMG_UINT32 ui32NumRegisters)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32      ui32FileOffset, ui32Flags;
+
+        PDUMP_GET_FILE_STRING();
+
+        ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;
+        ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(IMG_UINT32);
+
+        PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump TA signature registers\r\n");
+        eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_ta.sig", ui32DumpFrameNum);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpRegisterRange(psDevId,
+                                                pszFileName, 
+                                                pui32Registers, 
+                                                ui32NumRegisters, 
+                                                &ui32FileOffset, 
+                                                sizeof(IMG_UINT32), 
+                                                ui32Flags);
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCounterRegisters (PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                                                IMG_UINT32 ui32DumpFrameNum,
+                                                                IMG_BOOL        bLastFrame,
+                                                                IMG_UINT32 *pui32Registers,
+                                                                IMG_UINT32 ui32NumRegisters)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32      ui32FileOffset, ui32Flags;
+
+        PDUMP_GET_FILE_STRING();
+
+        ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0UL;
+        ui32FileOffset = 0UL;
+
+        PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump counter registers\r\n");
+        eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u.perf", ui32DumpFrameNum);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+
+        PDumpRegisterRange(psDevId,
+                                                pszFileName,
+                                                pui32Registers,
+                                                ui32NumRegisters,
+                                                &ui32FileOffset,
+                                                sizeof(IMG_UINT32),
+                                                ui32Flags);
+
+        return PVRSRV_OK;
+}
+
+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 :%s:0x%X\r\n",
+                                                        pszPDumpRegName, 
+                                                        ui32RegOffset);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+        return PVRSRV_OK;
+}
+
+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,
+#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, ui32PDumpFlags);
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PDumpCycleCountRegRead(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                                                        const IMG_UINT32 ui32RegOffset,
+                                                                        IMG_BOOL bLastFrame)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_GET_SCRIPT_STRING();
+
+        eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X\r\n", 
+                                                        psDevId->pszPDumpRegName,
+                                                        ui32RegOffset);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        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_UINT32                                    ui32PacketSize,
+                          IMG_UINT32                                    ui32BufferSize,
+                          IMG_UINT32                                    ui32Flags,
+                          IMG_HANDLE                                    hUniqueTag)
+{
+        PVRSRV_ERROR eErr;
+        IMG_UINT32                      ui32PageOffset;
+        IMG_UINT8                       *pui8LinAddr;
+        IMG_DEV_VIRTADDR        sDevVAddr;
+        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);
+
+        pui8LinAddr = psROffMemInfo->pvLinAddrKM;
+        sDevVAddr = psROffMemInfo->sDevVAddr;
+
+        
+        pui8LinAddr += ui32ROffOffset;
+        sDevVAddr.uiAddr += ui32ROffOffset;
+
+        
+
+
+        PDumpOSCPUVAddrToPhysPages(psROffMemInfo->sMemBlk.hOSMemHandle,
+                        ui32ROffOffset,
+                        pui8LinAddr,
+                        psMMUAttrib->ui32DataPageMask,
+                        &ui32PageOffset);
+
+        
+        sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageOffset;
+
+        PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);
+
+        
+        BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);
+
+        
+        sDevPAddr.uiAddr += ui32PageOffset;
+
+        eErr = PDumpOSBufprintf(hScript,
+                         ui32MaxLen,
+                         "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);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags)
+{
+        PVRSRV_ERROR eErr;
+        PDUMP_GET_SCRIPT_STRING();
+        PDUMP_DBG(("PDumpIDLWithFlags"));
+
+        eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %u\r\n", ui32Clocks);
+        if(eErr != PVRSRV_OK)
+        {
+                return eErr;
+        }
+        PDumpOSWriteString2(hScript, ui32Flags);
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks)
+{
+        return PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS);
+}
+
+PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                                IMG_PVOID pvAltLinAddrUM,
+                                                IMG_PVOID pvLinAddrUM,
+                                                PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                IMG_UINT32 ui32Offset,
+                                                IMG_UINT32 ui32Bytes,
+                                                IMG_UINT32 ui32Flags,
+                                                IMG_HANDLE hUniqueTag)
+{
+        IMG_VOID *pvAddrUM;
+        IMG_VOID *pvAddrKM;
+        IMG_UINT32 ui32BytesDumped;
+        IMG_UINT32 ui32CurrentOffset;
+
+        if (psMemInfo->pvLinAddrKM != IMG_NULL && pvAltLinAddrUM == IMG_NULL)
+        {
+                
+                return PDumpMemKM(IMG_NULL,
+                                           psMemInfo,
+                                           ui32Offset,
+                                           ui32Bytes,
+                                           ui32Flags,
+                                           hUniqueTag);
+        }
+
+        pvAddrUM = (pvAltLinAddrUM != IMG_NULL) ? pvAltLinAddrUM : ((pvLinAddrUM != IMG_NULL) ? VPTR_PLUS(pvLinAddrUM, ui32Offset) : IMG_NULL);
+
+        pvAddrKM = GetTempBuffer();
+
+        
+        PVR_ASSERT(pvAddrUM != IMG_NULL && pvAddrKM != IMG_NULL);
+        if (pvAddrUM == IMG_NULL || pvAddrKM == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: Nothing to dump"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        if (ui32Bytes > 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;
+        for (ui32BytesDumped = 0; ui32BytesDumped < ui32Bytes;)
+        {
+                PVRSRV_ERROR eError;
+                IMG_UINT32 ui32BytesToDump = MIN(PDUMP_TEMP_BUFFER_SIZE, ui32Bytes - ui32BytesDumped);
+
+                eError = OSCopyFromUser(psPerProc,
+                                           pvAddrKM,
+                                           pvAddrUM,
+                                           ui32BytesToDump);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: OSCopyFromUser failed (%d)", eError));
+                        return eError;
+                }
+
+                eError = PDumpMemKM(pvAddrKM,
+                                           psMemInfo,
+                                           ui32CurrentOffset,
+                                           ui32BytesToDump,
+                                           ui32Flags,
+                                           hUniqueTag);
+
+                if (eError != PVRSRV_OK)
+                {
+                        
+                        if (ui32BytesDumped != 0)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: PDumpMemKM failed (%d)", eError));
+                        }
+                        PVR_ASSERT(ui32BytesDumped == 0);
+                        return eError;
+                }
+
+                VPTR_INC(pvAddrUM, ui32BytesToDump);
+                ui32CurrentOffset += ui32BytesToDump;
+                ui32BytesDumped += ui32BytesToDump;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID)
+{
+        IMG_UINT32 i;
+
+        
+        for(i=0; i<MAX_PDUMP_MMU_CONTEXTS; i++)
+        {
+                if((gui16MMUContextUsage & (1U << i)) == 0)
+                {
+                        
+                        gui16MMUContextUsage |= 1U << i;
+                        *pui32MMUContextID = i;
+                        return PVRSRV_OK;
+                }
+        }
+
+        PVR_DPF((PVR_DBG_ERROR, "_PdumpAllocMMUContext: no free MMU context ids"));
+
+        return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;
+}
+
+
+static PVRSRV_ERROR _PdumpFreeMMUContext(IMG_UINT32 ui32MMUContextID)
+{
+        if(ui32MMUContextID < MAX_PDUMP_MMU_CONTEXTS)
+        {
+                
+                gui16MMUContextUsage &= ~(1U << ui32MMUContextID);
+                return PVRSRV_OK;
+        }
+
+        PVR_DPF((PVR_DBG_ERROR, "_PdumpFreeMMUContext: MMU context ids invalid"));
+
+        return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;
+}
+
+
+PVRSRV_ERROR PDumpSetMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
+                                                                IMG_CHAR *pszMemSpace,
+                                                                IMG_UINT32 *pui32MMUContextID,
+                                                                IMG_UINT32 ui32MMUType,
+                                                                IMG_HANDLE hUniqueTag1,
+                                                                IMG_HANDLE hOSMemHandle, 
+                                                                IMG_VOID *pvPDCPUAddr)
+{
+        IMG_UINT8 *pui8LinAddr = (IMG_UINT8 *)pvPDCPUAddr;
+        IMG_CPU_PHYADDR sCpuPAddr;
+        IMG_DEV_PHYADDR sDevPAddr;
+        IMG_UINT32 ui32MMUContextID;
+        PVRSRV_ERROR eError;
+
+        eError = _PdumpAllocMMUContext(&ui32MMUContextID);
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpSetMMUContext: _PdumpAllocMMUContext failed: %d", eError));
+                return eError;
+        }
+
+        
+        
+        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_%08X%08X\r\n",
+                                                pszMemSpace,
+                                                ui32MMUContextID,
+                                                ui32MMUType,
+                                                pszMemSpace,
+                                                (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,
+                                                sDevPAddr.uiAddr);
+
+        
+        *pui32MMUContextID = ui32MMUContextID;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PDumpClearMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
+                                                                IMG_CHAR *pszMemSpace,
+                                                                IMG_UINT32 ui32MMUContextID,
+                                                                IMG_UINT32 ui32MMUType)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_UNREFERENCED_PARAMETER(eDeviceType);
+
+        
+        PDumpComment("Clear MMU Context for memory space %s\r\n", pszMemSpace);
+        
+        PDumpComment("MMU :%s:v%d %d\r\n",
+                                                pszMemSpace,
+                                                ui32MMUContextID,
+                                                ui32MMUType);
+
+        eError = _PdumpFreeMMUContext(ui32MMUContextID);
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpClearMMUContext: _PdumpFreeMMUContext failed: %d", eError));
+                return eError;
+        }
+
+        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;
+
+        
+        if ((ui32Flags & PDUMP_FLAGS_NEVER) != 0)
+        {
+                return ui32BCount;
+        }
+
+        while (((IMG_UINT32) ui32BCount > 0) && (ui32BytesWritten != 0xFFFFFFFFU))
+        {
+                if ((ui32Flags & PDUMP_FLAGS_PERSISTENT) != 0)
+                {
+                        
+
+
+                        if (psStream->bInitPhaseComplete)
+                        {
+                                
+                                ui32BytesWritten = PDumpOSDebugDriverWrite(     psStream,
+                                                                                                                        PDUMP_WRITE_MODE_PERSISTENT,
+                                                                                                                        &pui8Data[ui32Off], ui32BCount, 1, 0);
+                        }
+                }
+
+                if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)
+                {
+                        
+
+                        if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
+                                (psStream->ui32Start == 0xFFFFFFFFU) &&
+                                (psStream->ui32End == 0xFFFFFFFFU) &&
+                                psStream->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 != 0xFFFFFFFF)
+                {
+                        ui32Off += ui32BytesWritten;
+                        ui32BCount -= ui32BytesWritten;
+                }
+
+                
+        }
+
+
+        
+        return ui32BytesWritten;
+}
+
+
+
+#else   
+#endif  
diff --git a/drivers/gpu/pvr/pdump_int.h b/drivers/gpu/pvr/pdump_int.h
new file mode 100644
index 00000000000..3c038883a2b
--- /dev/null
+++ b/drivers/gpu/pvr/pdump_int.h
@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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 
+
diff --git a/drivers/gpu/pvr/pdump_km.h b/drivers/gpu/pvr/pdump_km.h
new file mode 100644
index 00000000000..782f883608e
--- /dev/null
+++ b/drivers/gpu/pvr/pdump_km.h
@@ -0,0 +1,403 @@
+/**********************************************************************
+ *
+ * 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_KM_H_
+#define _PDUMP_KM_H_
+
+
+#include "pdump_osfunc.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "pdump.h"
+
+#define PDUMP_PD_UNIQUETAG                      (IMG_HANDLE)0
+#define PDUMP_PT_UNIQUETAG                      (IMG_HANDLE)0
+
+#define PDUMP_STREAM_PARAM2                     0
+#define PDUMP_STREAM_SCRIPT2            1
+#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)
+#endif
+
+#ifdef PDUMP
+
+#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                    ui32Value,
+                                                                                  IMG_UINT32                    ui32Mask,
+                                                                                  PDUMP_POLL_OPERATOR   eOperator,
+                                                                                  IMG_UINT32                    ui32Flags,
+                                                                                  IMG_HANDLE                    hUniqueTag);
+
+        IMG_IMPORT PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psProcData,
+                                                                           IMG_PVOID                    pvAltLinAddr,
+                                                                           IMG_PVOID                    pvLinAddr,
+                                                                           PVRSRV_KERNEL_MEM_INFO       *psMemInfo,
+                                                                           IMG_UINT32                   ui32Offset,
+                                                                           IMG_UINT32                   ui32Bytes,
+                                                                           IMG_UINT32                   ui32Flags,
+                                                                           IMG_HANDLE                   hUniqueTag);
+
+        IMG_IMPORT PVRSRV_ERROR PDumpMemKM(IMG_PVOID                    pvAltLinAddr,
+                                                                           PVRSRV_KERNEL_MEM_INFO       *psMemInfo,
+                                                                           IMG_UINT32                   ui32Offset,
+                                                                           IMG_UINT32                   ui32Bytes,
+                                                                           IMG_UINT32                   ui32Flags,
+                                                                           IMG_HANDLE                   hUniqueTag);
+        PVRSRV_ERROR PDumpMemPagesKM(PVRSRV_DEVICE_TYPE eDeviceType,
+                                                                 IMG_DEV_PHYADDR                *pPages,
+                                                                 IMG_UINT32                     ui32NumPages,
+                                                                 IMG_DEV_VIRTADDR       sDevAddr,
+                                                                 IMG_UINT32                     ui32Start,
+                                                                 IMG_UINT32                     ui32Length,
+                                                                 IMG_UINT32                     ui32Flags,
+                                                                 IMG_HANDLE                     hUniqueTag);
+
+        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_CHAR *pszPDumpRegName,
+                                                                         IMG_UINT32 ui32RegAddr,
+                                                                         IMG_UINT32 ui32RegValue,
+                                                                         IMG_UINT32 ui32Flags);
+        PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_CHAR *pszPDumpRegName,
+                                                                                IMG_UINT32 ui32RegAddr,
+                                                                                IMG_UINT32 ui32RegValue,
+                                                                                IMG_UINT32 ui32Mask,
+                                                                                IMG_UINT32 ui32Flags);
+        PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName,
+                                                                IMG_UINT32 ui32RegAddr,
+                                                                IMG_UINT32 ui32RegValue,
+                                                                IMG_UINT32 ui32Mask);
+
+        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 *pszPDumpRegName,
+                                                                                   IMG_CHAR *pszFileName,
+                                                                                   IMG_UINT32 ui32FileOffset,
+                                                                                   IMG_UINT32 ui32Address,
+                                                                                   IMG_UINT32 ui32Size,
+                                                                                   IMG_UINT32 ui32PDumpFlags);
+
+        PVRSRV_ERROR PDumpRegKM(IMG_CHAR* pszPDumpRegName,
+                                                        IMG_UINT32 dwReg,
+                                                        IMG_UINT32 dwData);
+
+        PVRSRV_ERROR PDumpComment(IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(1, 2);
+        PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32   ui32Flags,
+                                                                           IMG_CHAR*    pszFormat,
+                                                                           ...) IMG_FORMAT_PRINTF(2, 3);
+
+        PVRSRV_ERROR PDumpPDReg(PDUMP_MMU_ATTRIB *psMMUAttrib,
+                                                        IMG_UINT32      ui32Reg,
+                                                        IMG_UINT32      ui32dwData,
+                                                        IMG_HANDLE      hUniqueTag);
+        PVRSRV_ERROR PDumpPDRegWithFlags(PDUMP_MMU_ATTRIB *psMMUAttrib,
+                                                                         IMG_UINT32             ui32Reg,
+                                                                         IMG_UINT32             ui32Data,
+                                                                         IMG_UINT32             ui32Flags,
+                                                                         IMG_HANDLE             hUniqueTag);
+
+        IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID);
+        IMG_IMPORT IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID);
+
+        IMG_VOID PDumpMallocPagesPhys(PVRSRV_DEVICE_TYPE        eDeviceType,
+                                                                  IMG_UINT32                    ui32DevVAddr,
+                                                                  IMG_PUINT32                   pui32PhysPages,
+                                                                  IMG_UINT32                    ui32NumPages,
+                                                                  IMG_HANDLE                    hUniqueTag);
+        PVRSRV_ERROR PDumpSetMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
+                                                                        IMG_CHAR *pszMemSpace,
+                                                                        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_UINT32 ui32MMUContextID,
+                                                                        IMG_UINT32 ui32MMUType);
+
+        PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                                   IMG_UINT32 ui32Offset,
+                                                                   IMG_DEV_PHYADDR sPDDevPAddr,
+                                                                   IMG_HANDLE hUniqueTag1,
+                                                                   IMG_HANDLE hUniqueTag2);
+
+        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);
+
+        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(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                                                                        IMG_UINT32 ui32DumpFrameNum,
+                                                                                        IMG_BOOL bLastFrame,
+                                                                                        IMG_UINT32 *pui32Registers,
+                                                                                        IMG_UINT32 ui32NumRegisters);
+
+        PVRSRV_ERROR PDumpCounterRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                        IMG_UINT32 ui32DumpFrameNum,
+                                        IMG_BOOL                bLastFrame,
+                                        IMG_UINT32 *pui32Registers,
+                                        IMG_UINT32 ui32NumRegisters);
+
+        PVRSRV_ERROR PDumpRegRead(IMG_CHAR *pszPDumpRegName,
+                                                                const IMG_UINT32 dwRegOffset,
+                                                                IMG_UINT32      ui32Flags);
+
+        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_IDENTIFIER  *psDevID,
+                                                                  IMG_UINT32                            ui32DevVAddr,
+                                                                  IMG_CPU_VIRTADDR                      pvLinAddr,
+                                                                  IMG_HANDLE                            hOSMemHandle,
+                                                                  IMG_UINT32                            ui32NumBytes,
+                                                                  IMG_UINT32                            ui32PageSize,
+                                                                  IMG_HANDLE                            hUniqueTag);
+        PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_IDENTIFIER      *psDevId,
+                                                                          IMG_HANDLE            hOSMemHandle,
+                                                                          IMG_UINT32            ui32Offset,
+                                                                          IMG_CPU_VIRTADDR              pvLinAddr,
+                                                                          IMG_UINT32                    ui32NumBytes,
+                                                                          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_IDENTIFIER *psDevID,
+                                                                        IMG_HANDLE          hOSMemHandle,
+                                                                        IMG_CPU_VIRTADDR        pvLinAddr,
+                                                                        IMG_UINT32                      ui32NumBytes,
+                                                                        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 PDumpSignatureBuffer(PVRSRV_DEVICE_IDENTIFIER *psDevId,
+                                                                          IMG_CHAR                      *pszFileName,
+                                                                          IMG_CHAR                      *pszBufferType,
+                                                                          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 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, 
+                                                           PVRSRV_KERNEL_MEM_INFO *psMemInfo,
+                                                           IMG_UINT32 uiAddr, 
+                                                           IMG_UINT32 ui32Size,
+                                                           IMG_UINT32 ui32PDumpFlags,
+                                                           IMG_HANDLE hUniqueTag);
+
+        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 PDUMPMEMPTENTRIES               PDumpMemPTEntriesKM
+        #define PDUMPPDENTRIES                  PDumpMemPDEntriesKM
+        #define PDUMPMEMUM                              PDumpMemUM
+        #define PDUMPINIT                               PDumpInitCommon
+        #define PDUMPDEINIT                             PDumpDeInitCommon
+        #define PDUMPISLASTFRAME                PDumpIsLastCaptureFrameKM
+        #define PDUMPTESTFRAME                  PDumpIsCaptureFrameKM
+        #define PDUMPTESTNEXTFRAME              PDumpTestNextFrame
+        #define PDUMPREGWITHFLAGS               PDumpRegWithFlagsKM
+        #define PDUMPREG                                PDumpRegKM
+        #define PDUMPCOMMENT                    PDumpComment
+        #define PDUMPCOMMENTWITHFLAGS   PDumpCommentWithFlags
+        #define PDUMPREGPOL                             PDumpRegPolKM
+        #define PDUMPREGPOLWITHFLAGS    PDumpRegPolWithFlagsKM
+        #define PDUMPMALLOCPAGES                PDumpMallocPages
+        #define PDUMPMALLOCPAGETABLE    PDumpMallocPageTable
+        #define PDUMPSETMMUCONTEXT              PDumpSetMMUContext
+        #define PDUMPCLEARMMUCONTEXT    PDumpClearMMUContext
+        #define PDUMPFREEPAGES                  PDumpFreePages
+        #define PDUMPFREEPAGETABLE              PDumpFreePageTable
+        #define PDUMPPDREG                              PDumpPDReg
+        #define PDUMPPDREGWITHFLAGS             PDumpPDRegWithFlags
+        #define PDUMPCBP                                PDumpCBP
+        #define PDUMPREGBASEDCBP                PDumpRegBasedCBP
+        #define PDUMPMALLOCPAGESPHYS    PDumpMallocPagesPhys
+        #define PDUMPENDINITPHASE               PDumpStopInitPhaseKM
+        #define PDUMPBITMAPKM                   PDumpBitmapKM
+        #define PDUMPDRIVERINFO                 PDumpDriverInfoKM
+        #define PDUMPIDLWITHFLAGS               PDumpIDLWithFlags
+        #define PDUMPIDL                                PDumpIDL
+        #define PDUMPSUSPEND                    PDumpSuspendKM
+        #define PDUMPRESUME                             PDumpResumeKM
+
+#else
+                #if ((defined(LINUX) || defined(GCC_IA32)) || defined(GCC_ARM))
+                        #define PDUMPMEMPOL(args...)
+                        #define PDUMPMEM(args...)
+                        #define PDUMPMEMPTENTRIES(args...)
+                        #define PDUMPPDENTRIES(args...)
+                        #define PDUMPMEMUM(args...)
+                        #define PDUMPINIT(args...)
+                        #define PDUMPDEINIT(args...)
+                        #define PDUMPISLASTFRAME(args...)
+                        #define PDUMPTESTFRAME(args...)
+                        #define PDUMPTESTNEXTFRAME(args...)
+                        #define PDUMPREGWITHFLAGS(args...)
+                        #define PDUMPREG(args...)
+                        #define PDUMPCOMMENT(args...)
+                        #define PDUMPREGPOL(args...)
+                        #define PDUMPREGPOLWITHFLAGS(args...)
+                        #define PDUMPMALLOCPAGES(args...)
+                        #define PDUMPMALLOCPAGETABLE(args...)
+                        #define PDUMPSETMMUCONTEXT(args...)
+                        #define PDUMPCLEARMMUCONTEXT(args...)
+                        #define PDUMPFREEPAGES(args...)
+                        #define PDUMPFREEPAGETABLE(args...)
+                        #define PDUMPPDREG(args...)
+                        #define PDUMPPDREGWITHFLAGS(args...)
+                        #define PDUMPSYNC(args...)
+                        #define PDUMPCOPYTOMEM(args...)
+                        #define PDUMPWRITE(args...)
+                        #define PDUMPCBP(args...)
+                        #define PDUMPREGBASEDCBP(args...)
+                        #define PDUMPCOMMENTWITHFLAGS(args...)
+                        #define PDUMPMALLOCPAGESPHYS(args...)
+                        #define PDUMPENDINITPHASE(args...)
+                        #define PDUMPMSVDXREG(args...)
+                        #define PDUMPMSVDXREGWRITE(args...)
+                        #define PDUMPMSVDXREGREAD(args...)
+                        #define PDUMPMSVDXPOLEQ(args...)
+                        #define PDUMPMSVDXPOL(args...)
+                        #define PDUMPBITMAPKM(args...)
+                        #define PDUMPDRIVERINFO(args...)
+                        #define PDUMPIDLWITHFLAGS(args...)
+                        #define PDUMPIDL(args...)
+                        #define PDUMPSUSPEND(args...)
+                        #define PDUMPRESUME(args...)
+                        #define PDUMPMSVDXWRITEREF(args...)
+                #else
+                        #error Compiler not specified
+                #endif
+#endif
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pdump_osfunc.h b/drivers/gpu/pvr/pdump_osfunc.h
new file mode 100644
index 00000000000..334c98da3ad
--- /dev/null
+++ b/drivers/gpu/pvr/pdump_osfunc.h
@@ -0,0 +1,135 @@
+/**********************************************************************
+ *
+ * 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 <stdarg.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#define MAX_PDUMP_STRING_LENGTH (256)
+
+
+#define PDUMP_GET_SCRIPT_STRING()                               \
+        IMG_HANDLE hScript;                                                     \
+        IMG_UINT32      ui32MaxLen;                                             \
+        PVRSRV_ERROR eError;                                            \
+        eError = PDumpOSGetScriptString(&hScript, &ui32MaxLen);\
+        if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_MSG_STRING()                                  \
+        IMG_CHAR *pszMsg;                                                       \
+        IMG_UINT32      ui32MaxLen;                                             \
+        PVRSRV_ERROR eError;                                            \
+        eError = PDumpOSGetMessageString(&pszMsg, &ui32MaxLen);\
+        if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_FILE_STRING()                         \
+        IMG_CHAR *pszFileName;                                  \
+        IMG_UINT32      ui32MaxLen;                                     \
+        PVRSRV_ERROR eError;                                    \
+        eError = PDumpOSGetFilenameString(&pszFileName, &ui32MaxLen);\
+        if(eError != PVRSRV_OK) return eError;
+
+#define PDUMP_GET_SCRIPT_AND_FILE_STRING()              \
+        IMG_HANDLE hScript;                                                     \
+        IMG_CHAR *pszFileName;                                          \
+        IMG_UINT32      ui32MaxLenScript;                               \
+        IMG_UINT32      ui32MaxLenFileName;                             \
+        PVRSRV_ERROR eError;                                            \
+        eError = PDumpOSGetScriptString(&hScript, &ui32MaxLenScript);\
+        if(eError != PVRSRV_OK) return eError;          \
+        eError = PDumpOSGetFilenameString(&pszFileName, &ui32MaxLenFileName);\
+        if(eError != PVRSRV_OK) return eError;
+
+        
+        PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript, IMG_UINT32 *pui32MaxLen);
+
+        
+        PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg, IMG_UINT32 *pui32MaxLen);
+
+        
+        PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile, IMG_UINT32 *pui32MaxLen);
+
+
+
+
+#define PDUMP_va_list   va_list
+#define PDUMP_va_start  va_start
+#define PDUMP_va_end    va_end
+
+
+
+IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream);
+
+IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream);
+
+IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID);
+
+IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags);
+
+IMG_BOOL PDumpOSIsSuspended(IMG_VOID);
+
+IMG_BOOL PDumpOSJTInitialised(IMG_VOID);
+
+IMG_BOOL PDumpOSWriteString(IMG_HANDLE hDbgStream,
+                IMG_UINT8 *psui8Data,
+                IMG_UINT32 ui32Size,
+                IMG_UINT32 ui32Flags);
+
+IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags);
+
+PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(3, 4);
+
+IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...) IMG_FORMAT_PRINTF(1, 2);
+
+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) IMG_FORMAT_PRINTF(3, 0);
+
+IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax);
+
+IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax);
+
+IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
+        IMG_HANDLE hOSMemHandle,
+                IMG_UINT32 ui32Offset,
+                IMG_UINT8 *pui8LinAddr,
+                IMG_UINT32 ui32PageSize,
+                IMG_DEV_PHYADDR *psDevPAddr);
+
+IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
+                IMG_UINT32 ui32Offset,
+                IMG_PUINT8 pui8LinAddr,
+                IMG_UINT32 ui32DataPageMask,
+                IMG_UINT32 *pui32PageOffset);
+
+IMG_VOID PDumpOSReleaseExecution(IMG_VOID);
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/drivers/gpu/pvr/pdumpdefs.h b/drivers/gpu/pvr/pdumpdefs.h
new file mode 100644
index 00000000000..83ccbb2c80c
--- /dev/null
+++ b/drivers/gpu/pvr/pdumpdefs.h
@@ -0,0 +1,99 @@
+/**********************************************************************
+ *
+ * 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 (__PDUMPDEFS_H__)
+#define __PDUMPDEFS_H__
+
+typedef enum _PDUMP_PIXEL_FORMAT_
+{
+        PVRSRV_PDUMP_PIXEL_FORMAT_UNSUPPORTED = 0,
+        PVRSRV_PDUMP_PIXEL_FORMAT_RGB8 = 1,
+        PVRSRV_PDUMP_PIXEL_FORMAT_RGB332 = 2,
+        PVRSRV_PDUMP_PIXEL_FORMAT_KRGB555 = 3,
+        PVRSRV_PDUMP_PIXEL_FORMAT_RGB565 = 4,
+        PVRSRV_PDUMP_PIXEL_FORMAT_ARGB4444 = 5,
+        PVRSRV_PDUMP_PIXEL_FORMAT_ARGB1555 = 6,
+        PVRSRV_PDUMP_PIXEL_FORMAT_RGB888 = 7,
+        PVRSRV_PDUMP_PIXEL_FORMAT_ARGB8888 = 8,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV8 = 9,
+        PVRSRV_PDUMP_PIXEL_FORMAT_AYUV4444 = 10,
+        PVRSRV_PDUMP_PIXEL_FORMAT_VY0UY1_8888 = 11,
+        PVRSRV_PDUMP_PIXEL_FORMAT_UY0VY1_8888 = 12,
+        PVRSRV_PDUMP_PIXEL_FORMAT_Y0UY1V_8888 = 13,
+        PVRSRV_PDUMP_PIXEL_FORMAT_Y0VY1U_8888 = 14,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV888 = 15,
+        PVRSRV_PDUMP_PIXEL_FORMAT_UYVY10101010 = 16,
+        PVRSRV_PDUMP_PIXEL_FORMAT_VYAUYA8888 = 17,
+        PVRSRV_PDUMP_PIXEL_FORMAT_AYUV8888 = 18,
+        PVRSRV_PDUMP_PIXEL_FORMAT_AYUV2101010 = 19,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV101010 = 20,
+        PVRSRV_PDUMP_PIXEL_FORMAT_PL12Y8 = 21,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV_IMC2 = 22,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV_YV12 = 23,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV_PL8 = 24,
+        PVRSRV_PDUMP_PIXEL_FORMAT_YUV_PL12 = 25,
+        PVRSRV_PDUMP_PIXEL_FORMAT_422PL12YUV8 = 26,
+        PVRSRV_PDUMP_PIXEL_FORMAT_420PL12YUV8 = 27,
+        PVRSRV_PDUMP_PIXEL_FORMAT_PL12Y10 = 28,
+        PVRSRV_PDUMP_PIXEL_FORMAT_422PL12YUV10 = 29,
+        PVRSRV_PDUMP_PIXEL_FORMAT_420PL12YUV10 = 30,
+        PVRSRV_PDUMP_PIXEL_FORMAT_ABGR8888 = 31,
+        PVRSRV_PDUMP_PIXEL_FORMAT_BGRA8888 = 32,
+        PVRSRV_PDUMP_PIXEL_FORMAT_ARGB8332 = 33,
+        PVRSRV_PDUMP_PIXEL_FORMAT_RGB555 = 34,
+        PVRSRV_PDUMP_PIXEL_FORMAT_F16 = 35,
+        PVRSRV_PDUMP_PIXEL_FORMAT_F32 = 36,
+        PVRSRV_PDUMP_PIXEL_FORMAT_L16 = 37,
+        PVRSRV_PDUMP_PIXEL_FORMAT_L32 = 38,
+        
+        PVRSRV_PDUMP_PIXEL_FORMAT_FORCE_I32 = 0x7fffffff
+
+} PDUMP_PIXEL_FORMAT;
+
+typedef enum _PDUMP_MEM_FORMAT_
+{
+        PVRSRV_PDUMP_MEM_FORMAT_STRIDE = 0,
+        PVRSRV_PDUMP_MEM_FORMAT_RESERVED = 1,
+        PVRSRV_PDUMP_MEM_FORMAT_TILED = 8,
+        PVRSRV_PDUMP_MEM_FORMAT_TWIDDLED = 9,
+        PVRSRV_PDUMP_MEM_FORMAT_HYBRID = 10,
+        
+        PVRSRV_PDUMP_MEM_FORMAT_FORCE_I32 = 0x7fffffff
+} PDUMP_MEM_FORMAT;
+
+typedef enum _PDUMP_POLL_OPERATOR
+{
+        PDUMP_POLL_OPERATOR_EQUAL = 0,
+        PDUMP_POLL_OPERATOR_LESS = 1,
+        PDUMP_POLL_OPERATOR_LESSEQUAL = 2,
+        PDUMP_POLL_OPERATOR_GREATER = 3,
+        PDUMP_POLL_OPERATOR_GREATEREQUAL = 4,
+        PDUMP_POLL_OPERATOR_NOTEQUAL = 5,
+} PDUMP_POLL_OPERATOR;
+
+
+#endif 
+
diff --git a/drivers/gpu/pvr/perproc.c b/drivers/gpu/pvr/perproc.c
new file mode 100644
index 00000000000..62f4a3f1144
--- /dev/null
+++ b/drivers/gpu/pvr/perproc.c
@@ -0,0 +1,283 @@
+/**********************************************************************
+ *
+ * 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 "resman.h"
+#include "handle.h"
+#include "perproc.h"
+#include "osperproc.h"
+
+#define HASH_TAB_INIT_SIZE 32
+
+static HASH_TABLE *psHashTab = IMG_NULL;
+
+static PVRSRV_ERROR FreePerProcessData(PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_ERROR eError;
+        IMG_UINTPTR_T uiPerProc;
+
+        PVR_ASSERT(psPerProc != IMG_NULL);
+
+        if (psPerProc == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        uiPerProc = HASH_Remove(psHashTab, (IMG_UINTPTR_T)psPerProc->ui32PID);
+        if (uiPerProc == 0)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't find process in per-process data hash table"));
+                
+                PVR_ASSERT(psPerProc->ui32PID == 0);
+        }
+        else
+        {
+                PVR_ASSERT((PVRSRV_PER_PROCESS_DATA *)uiPerProc == psPerProc);
+                PVR_ASSERT(((PVRSRV_PER_PROCESS_DATA *)uiPerProc)->ui32PID == psPerProc->ui32PID);
+        }
+
+        
+        if (psPerProc->psHandleBase != IMG_NULL)
+        {
+                eError = PVRSRVFreeHandleBase(psPerProc->psHandleBase);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't free handle base for process (%d)", eError));
+                        return eError;
+                }
+        }
+
+        
+        if (psPerProc->hPerProcData != IMG_NULL)
+        {
+                eError = PVRSRVReleaseHandle(KERNEL_HANDLE_BASE, psPerProc->hPerProcData, PVRSRV_HANDLE_TYPE_PERPROC_DATA);
+
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't release per-process data handle (%d)", eError));
+                        return eError;
+                }
+        }
+
+        
+        eError = OSPerProcessPrivateDataDeInit(psPerProc->hOsPrivateData);
+        if (eError != PVRSRV_OK)
+        {
+                 PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: OSPerProcessPrivateDataDeInit failed (%d)", eError));
+                return eError;
+        }
+
+        eError = OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                sizeof(*psPerProc),
+                psPerProc,
+                psPerProc->hBlockAlloc);
+        
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreePerProcessData: Couldn't free per-process data (%d)", eError));
+                return eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_PER_PROCESS_DATA *PVRSRVPerProcessData(IMG_UINT32 ui32PID)
+{
+        PVRSRV_PER_PROCESS_DATA *psPerProc;
+
+        PVR_ASSERT(psHashTab != IMG_NULL);
+
+        
+        psPerProc = (PVRSRV_PER_PROCESS_DATA *)HASH_Retrieve(psHashTab, (IMG_UINTPTR_T)ui32PID);
+        return psPerProc;
+}
+
+
+PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32     ui32PID)
+{
+        PVRSRV_PER_PROCESS_DATA *psPerProc;
+        IMG_HANDLE hBlockAlloc;
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        PVR_ASSERT(psHashTab != IMG_NULL);
+
+        
+        psPerProc = (PVRSRV_PER_PROCESS_DATA *)HASH_Retrieve(psHashTab, (IMG_UINTPTR_T)ui32PID);
+
+        if (psPerProc == IMG_NULL)
+        {
+                
+                eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                                        sizeof(*psPerProc),
+                                                        (IMG_PVOID *)&psPerProc,
+                                                        &hBlockAlloc,
+                                                        "Per Process Data");
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't allocate per-process data (%d)", eError));
+                        return eError;
+                }
+                OSMemSet(psPerProc, 0, sizeof(*psPerProc));
+                psPerProc->hBlockAlloc = 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_INSERT_HASH_TABLE_DATA_FAILED;
+                        goto failure;
+                }
+
+                psPerProc->ui32PID = ui32PID;
+                psPerProc->ui32RefCount = 0;
+
+                
+                eError = OSPerProcessPrivateDataInit(&psPerProc->hOsPrivateData);
+                if (eError != PVRSRV_OK)
+                {
+                         PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: OSPerProcessPrivateDataInit failed (%d)", eError));
+                        goto failure;
+                }
+
+                
+                eError = PVRSRVAllocHandle(KERNEL_HANDLE_BASE,
+                                                                   &psPerProc->hPerProcData,
+                                                                   psPerProc,
+                                                                   PVRSRV_HANDLE_TYPE_PERPROC_DATA,
+                                                                   PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't allocate handle for per-process data (%d)", eError));
+                        goto failure;
+                }
+
+                
+                eError = PVRSRVAllocHandleBase(&psPerProc->psHandleBase);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't allocate handle base for process (%d)", eError));
+                        goto failure;
+                }
+
+                
+                eError = OSPerProcessSetHandleOptions(psPerProc->psHandleBase);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't set handle options (%d)", eError));
+                        goto failure;
+                }
+                
+                
+                eError = PVRSRVResManConnect(psPerProc, &psPerProc->hResManContext);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataConnect: Couldn't register with the resource manager"));
+                        goto failure;
+                }
+        }
+        
+        psPerProc->ui32RefCount++;
+        PVR_DPF((PVR_DBG_MESSAGE,
+                        "PVRSRVPerProcessDataConnect: Process 0x%x has ref-count %d",
+                        ui32PID, psPerProc->ui32RefCount));
+
+        return eError;
+
+failure:
+        (IMG_VOID)FreePerProcessData(psPerProc);
+        return eError;
+}
+
+
+IMG_VOID PVRSRVPerProcessDataDisconnect(IMG_UINT32      ui32PID)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_PER_PROCESS_DATA *psPerProc;
+
+        PVR_ASSERT(psHashTab != IMG_NULL);
+
+        psPerProc = (PVRSRV_PER_PROCESS_DATA *)HASH_Retrieve(psHashTab, (IMG_UINTPTR_T)ui32PID);
+        if (psPerProc == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDealloc: Couldn't locate per-process data for PID %u", ui32PID));
+        }
+        else
+        {
+                psPerProc->ui32RefCount--;
+                if (psPerProc->ui32RefCount == 0)
+                {
+                        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVPerProcessDataDisconnect: "
+                                        "Last close from process 0x%x received", ui32PID));
+
+                        
+                        PVRSRVResManDisconnect(psPerProc->hResManContext, IMG_FALSE);
+                        
+                        
+                        eError = FreePerProcessData(psPerProc);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDisconnect: Error freeing per-process data"));
+                        }
+                }
+        }
+
+        eError = PVRSRVPurgeHandles(KERNEL_HANDLE_BASE);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDisconnect: Purge of global handle pool failed (%d)", eError));
+        }
+}
+
+
+PVRSRV_ERROR PVRSRVPerProcessDataInit(IMG_VOID)
+{
+        PVR_ASSERT(psHashTab == IMG_NULL);
+
+        
+        psHashTab = HASH_Create(HASH_TAB_INIT_SIZE);
+        if (psHashTab == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataInit: Couldn't create per-process data hash table"));
+                return PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE;
+        }
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR PVRSRVPerProcessDataDeInit(IMG_VOID)
+{
+        
+        if (psHashTab != IMG_NULL)
+        {
+                
+                HASH_Delete(psHashTab);
+                psHashTab = IMG_NULL;
+        }
+
+        return PVRSRV_OK;
+}
+
diff --git a/drivers/gpu/pvr/perproc.h b/drivers/gpu/pvr/perproc.h
new file mode 100644
index 00000000000..0b7542b930f
--- /dev/null
+++ b/drivers/gpu/pvr/perproc.h
@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * 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 __PERPROC_H__
+#define __PERPROC_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "img_types.h"
+#include "resman.h"
+
+#include "handle.h"
+
+typedef struct _PVRSRV_PER_PROCESS_DATA_
+{
+        IMG_UINT32              ui32PID;
+        IMG_HANDLE              hBlockAlloc;
+        PRESMAN_CONTEXT         hResManContext;
+        IMG_HANDLE              hPerProcData;
+        PVRSRV_HANDLE_BASE      *psHandleBase;
+#if defined (PVR_SECURE_HANDLES)
+        
+        IMG_BOOL                bHandlesBatched;
+#endif  
+        IMG_UINT32              ui32RefCount;
+
+        
+        IMG_BOOL                bInitProcess;
+#if defined(PDUMP)
+        
+        IMG_BOOL                bPDumpPersistent;
+#endif
+        
+        IMG_HANDLE              hOsPrivateData;
+} PVRSRV_PER_PROCESS_DATA;
+
+PVRSRV_PER_PROCESS_DATA *PVRSRVPerProcessData(IMG_UINT32 ui32PID);
+
+PVRSRV_ERROR PVRSRVPerProcessDataConnect(IMG_UINT32     ui32PID);
+IMG_VOID PVRSRVPerProcessDataDisconnect(IMG_UINT32      ui32PID);
+
+PVRSRV_ERROR PVRSRVPerProcessDataInit(IMG_VOID);
+PVRSRV_ERROR PVRSRVPerProcessDataDeInit(IMG_VOID);
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVFindPerProcessData)
+#endif
+static INLINE
+PVRSRV_PER_PROCESS_DATA *PVRSRVFindPerProcessData(IMG_VOID)
+{
+        return PVRSRVPerProcessData(OSGetCurrentProcessIDKM());
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVProcessPrivateData)
+#endif
+static INLINE
+IMG_HANDLE PVRSRVProcessPrivateData(PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        return (psPerProc != IMG_NULL) ? psPerProc->hOsPrivateData : IMG_NULL;
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVPerProcessPrivateData)
+#endif
+static INLINE
+IMG_HANDLE PVRSRVPerProcessPrivateData(IMG_UINT32 ui32PID)
+{
+        return PVRSRVProcessPrivateData(PVRSRVPerProcessData(ui32PID));
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVFindPerProcessPrivateData)
+#endif
+static INLINE
+IMG_HANDLE PVRSRVFindPerProcessPrivateData(IMG_VOID)
+{
+        return PVRSRVProcessPrivateData(PVRSRVFindPerProcessData());
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/power.c b/drivers/gpu/pvr/power.c
new file mode 100644
index 00000000000..ba0eced9ba1
--- /dev/null
+++ b/drivers/gpu/pvr/power.c
@@ -0,0 +1,727 @@
+/**********************************************************************
+ *
+ * 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 "pdump_km.h"
+
+#include "lists.h"
+
+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:
+                        gbInitServerRan = bState;
+                        break;
+                case PVRSRV_INIT_SERVER_SUCCESSFUL:
+                        gbInitSuccessful = bState;
+                        break;
+                default:
+                        PVR_DPF((PVR_DBG_ERROR,
+                                "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:
+                        bReturnVal = gbInitServerRan;
+                        break;
+                case PVRSRV_INIT_SERVER_SUCCESSFUL:
+                        bReturnVal = gbInitSuccessful;
+                        break;
+                default:
+                        PVR_DPF((PVR_DBG_ERROR,
+                                "PVRSRVGetInitServerState : Unknown state %x", eInitServerState));
+                        bReturnVal = IMG_FALSE;
+        }
+
+        return bReturnVal;
+}
+
+static IMG_BOOL _IsSystemStatePowered(PVRSRV_SYS_POWER_STATE eSystemPowerState)
+{
+        return (IMG_BOOL)(eSystemPowerState < PVRSRV_SYS_POWER_STATE_D2);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVPowerLock(IMG_UINT32 ui32CallerID,
+                                                         IMG_BOOL       bSystemPowerEvent)
+{
+        PVRSRV_ERROR    eError;
+        SYS_DATA                *psSysData;
+        IMG_UINT32              ui32Timeout = 1000000;
+
+#if defined(SUPPORT_LMA)
+        
+        ui32Timeout *= 60;
+#endif 
+
+        SysAcquireData(&psSysData);
+
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+        eError = SysPowerLockWrap(psSysData);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+#endif
+        do
+        {
+                eError = OSLockResource(&psSysData->sPowerStateChangeResource,
+                                                                ui32CallerID);
+                if (eError == PVRSRV_OK)
+                {
+                        break;
+                }
+                else if (ui32CallerID == ISR_ID)
+                {
+                        
+
+                        eError = PVRSRV_ERROR_RETRY;
+                        break;
+                }
+
+                OSWaitus(1);
+                ui32Timeout--;
+        } while (ui32Timeout > 0);
+
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+        if (eError != PVRSRV_OK)
+        {
+                SysPowerLockUnwrap(psSysData);
+        }
+#endif
+         
+        if ((eError == PVRSRV_OK) &&
+                !bSystemPowerEvent &&
+                !_IsSystemStatePowered(psSysData->eCurrentPowerState))
+        {
+                
+                PVRSRVPowerUnlock(ui32CallerID);
+                eError = PVRSRV_ERROR_RETRY;
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+IMG_VOID PVRSRVPowerUnlock(IMG_UINT32   ui32CallerID)
+{
+        OSUnlockResource(&gpsSysData->sPowerStateChangeResource, ui32CallerID);
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+        SysPowerLockUnwrap(gpsSysData);
+#endif
+}
+
+
+static PVRSRV_ERROR PVRSRVDevicePrePowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
+{
+        PVRSRV_DEV_POWER_STATE  eNewDevicePowerState;
+        PVRSRV_ERROR                    eError;
+
+        
+        IMG_BOOL                                bAllDevices;
+        IMG_UINT32                              ui32DeviceIndex;
+        PVRSRV_DEV_POWER_STATE  eNewPowerState;
+
+        
+        bAllDevices = va_arg(va, IMG_BOOL);
+        ui32DeviceIndex = va_arg(va, IMG_UINT32);
+        eNewPowerState = va_arg(va, PVRSRV_DEV_POWER_STATE);
+
+        if (bAllDevices || (ui32DeviceIndex == psPowerDevice->ui32DeviceIndex))
+        {
+                eNewDevicePowerState = (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT) ?
+                                                        psPowerDevice->eDefaultPowerState : eNewPowerState;
+
+                if (psPowerDevice->eCurrentPowerState != eNewDevicePowerState)
+                {
+                        if (psPowerDevice->pfnPrePower != IMG_NULL)
+                        {
+                                
+                                eError = psPowerDevice->pfnPrePower(psPowerDevice->hDevCookie,
+                                                                                                        eNewDevicePowerState,
+                                                                                                        psPowerDevice->eCurrentPowerState);
+                                if (eError != PVRSRV_OK)
+                                {
+                                        return eError;
+                                }
+                        }
+
+                        
+                        eError = SysDevicePrePowerState(psPowerDevice->ui32DeviceIndex,
+                                                                                        eNewDevicePowerState,
+                                                                                        psPowerDevice->eCurrentPowerState);
+                        if (eError != PVRSRV_OK)
+                        {
+                                return eError;
+                        }
+                }
+        }
+
+        return  PVRSRV_OK;
+}
+
+static
+PVRSRV_ERROR PVRSRVDevicePrePowerStateKM(IMG_BOOL                               bAllDevices,
+                                                                                 IMG_UINT32                             ui32DeviceIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE eNewPowerState)
+{
+        PVRSRV_ERROR            eError;
+        SYS_DATA                        *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        
+        eError = List_PVRSRV_POWER_DEV_PVRSRV_ERROR_Any_va(psSysData->psPowerDeviceList,
+                                                                                                                &PVRSRVDevicePrePowerStateKM_AnyVaCb,
+                                                                                                                bAllDevices,
+                                                                                                                ui32DeviceIndex,
+                                                                                                                eNewPowerState);
+
+        return eError;
+}
+
+static PVRSRV_ERROR PVRSRVDevicePostPowerStateKM_AnyVaCb(PVRSRV_POWER_DEV *psPowerDevice, va_list va)
+{
+        PVRSRV_DEV_POWER_STATE  eNewDevicePowerState;
+        PVRSRV_ERROR                    eError;
+
+        
+        IMG_BOOL                                bAllDevices;
+        IMG_UINT32                              ui32DeviceIndex;
+        PVRSRV_DEV_POWER_STATE  eNewPowerState;
+
+        
+        bAllDevices = va_arg(va, IMG_BOOL);
+        ui32DeviceIndex = va_arg(va, IMG_UINT32);
+        eNewPowerState = va_arg(va, PVRSRV_DEV_POWER_STATE);
+
+        if (bAllDevices || (ui32DeviceIndex == psPowerDevice->ui32DeviceIndex))
+        {
+                eNewDevicePowerState = (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT) ?
+                                                                psPowerDevice->eDefaultPowerState : eNewPowerState;
+
+                if (psPowerDevice->eCurrentPowerState != eNewDevicePowerState)
+                {
+                        
+                        eError = SysDevicePostPowerState(psPowerDevice->ui32DeviceIndex,
+                                                                                         eNewDevicePowerState,
+                                                                                         psPowerDevice->eCurrentPowerState);
+                        if (eError != PVRSRV_OK)
+                        {
+                                return eError;
+                        }
+
+                        if (psPowerDevice->pfnPostPower != IMG_NULL)
+                        {
+                                
+                                eError = psPowerDevice->pfnPostPower(psPowerDevice->hDevCookie,
+                                                                                                         eNewDevicePowerState,
+                                                                                                         psPowerDevice->eCurrentPowerState);
+                                if (eError != PVRSRV_OK)
+                                {
+                                        return eError;
+                                }
+                        }
+
+                        psPowerDevice->eCurrentPowerState = eNewDevicePowerState;
+                }
+        }
+        return PVRSRV_OK;
+}
+
+static
+PVRSRV_ERROR PVRSRVDevicePostPowerStateKM(IMG_BOOL                                      bAllDevices,
+                                                                                  IMG_UINT32                            ui32DeviceIndex,
+                                                                                  PVRSRV_DEV_POWER_STATE        eNewPowerState)
+{
+        PVRSRV_ERROR            eError;
+        SYS_DATA                        *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        
+        eError = List_PVRSRV_POWER_DEV_PVRSRV_ERROR_Any_va(psSysData->psPowerDeviceList,
+                                                                                                                &PVRSRVDevicePostPowerStateKM_AnyVaCb,
+                                                                                                                bAllDevices,
+                                                                                                                ui32DeviceIndex,
+                                                                                                                eNewPowerState);
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetDevicePowerStateKM(IMG_UINT32                             ui32DeviceIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE eNewPowerState,
+                                                                                 IMG_UINT32                             ui32CallerID,
+                                                                                 IMG_BOOL                               bRetainMutex)
+{
+        PVRSRV_ERROR    eError;
+        SYS_DATA                *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        eError = PVRSRVPowerLock(ui32CallerID, IMG_FALSE);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        #if defined(PDUMP)
+        if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
+        {
+                
+
+
+
+                eError = PVRSRVDevicePrePowerStateKM(IMG_FALSE, ui32DeviceIndex, PVRSRV_DEV_POWER_STATE_ON);
+                if(eError != PVRSRV_OK)
+                {
+                        goto Exit;
+                }
+
+                eError = PVRSRVDevicePostPowerStateKM(IMG_FALSE, ui32DeviceIndex, PVRSRV_DEV_POWER_STATE_ON);
+
+                if (eError != PVRSRV_OK)
+                {
+                        goto Exit;
+                }
+
+                PDUMPSUSPEND();
+        }
+        #endif 
+
+        eError = PVRSRVDevicePrePowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState);
+        if(eError != PVRSRV_OK)
+        {
+                if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
+                {
+                        PDUMPRESUME();
+                }
+                goto Exit;
+        }
+
+        eError = PVRSRVDevicePostPowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState);
+
+        if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
+        {
+                PDUMPRESUME();
+        }
+
+Exit:
+
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                "PVRSRVSetDevicePowerStateKM : Transition to %d FAILED 0x%x", eNewPowerState, eError));
+        }
+
+        if (!bRetainMutex || (eError != PVRSRV_OK))
+        {
+                PVRSRVPowerUnlock(ui32CallerID);
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSystemPrePowerStateKM(PVRSRV_SYS_POWER_STATE eNewSysPowerState)
+{
+        PVRSRV_ERROR                    eError;
+        SYS_DATA                                *psSysData;
+        PVRSRV_DEV_POWER_STATE  eNewDevicePowerState;
+
+        SysAcquireData(&psSysData);
+
+        
+        eError = PVRSRVPowerLock(KERNEL_ID, IMG_TRUE);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        if (_IsSystemStatePowered(eNewSysPowerState) !=
+                _IsSystemStatePowered(psSysData->eCurrentPowerState))
+        {
+                if (_IsSystemStatePowered(eNewSysPowerState))
+                {
+                        
+                        eNewDevicePowerState = PVRSRV_DEV_POWER_STATE_DEFAULT;
+                }
+                else
+                {
+                        eNewDevicePowerState = PVRSRV_DEV_POWER_STATE_OFF;
+                }
+
+                
+                eError = PVRSRVDevicePrePowerStateKM(IMG_TRUE, 0, eNewDevicePowerState);
+                if (eError != PVRSRV_OK)
+                {
+                        goto ErrorExit;
+                }
+        }
+
+        if (eNewSysPowerState != psSysData->eCurrentPowerState)
+        {
+                
+                eError = SysSystemPrePowerState(eNewSysPowerState);
+                if (eError != PVRSRV_OK)
+                {
+                        goto ErrorExit;
+                }
+        }
+
+        return eError;
+
+ErrorExit:
+
+        PVR_DPF((PVR_DBG_ERROR,
+                        "PVRSRVSystemPrePowerStateKM: Transition from %d to %d FAILED 0x%x",
+                        psSysData->eCurrentPowerState, eNewSysPowerState, eError));
+
+        
+        psSysData->eFailedPowerState = eNewSysPowerState;
+
+        PVRSRVPowerUnlock(KERNEL_ID);
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSystemPostPowerStateKM(PVRSRV_SYS_POWER_STATE eNewSysPowerState)
+{
+        PVRSRV_ERROR                    eError = PVRSRV_OK;
+        SYS_DATA                                *psSysData;
+        PVRSRV_DEV_POWER_STATE  eNewDevicePowerState;
+
+        SysAcquireData(&psSysData);
+
+        if (eNewSysPowerState != psSysData->eCurrentPowerState)
+        {
+                
+                eError = SysSystemPostPowerState(eNewSysPowerState);
+                if (eError != PVRSRV_OK)
+                {
+                        goto Exit;
+                }
+        }
+
+        if (_IsSystemStatePowered(eNewSysPowerState) !=
+                _IsSystemStatePowered(psSysData->eCurrentPowerState))
+        {
+                if (_IsSystemStatePowered(eNewSysPowerState))
+                {
+                        
+                        eNewDevicePowerState = PVRSRV_DEV_POWER_STATE_DEFAULT;
+                }
+                else
+                {
+                        eNewDevicePowerState = PVRSRV_DEV_POWER_STATE_OFF;
+                }
+
+                
+                eError = PVRSRVDevicePostPowerStateKM(IMG_TRUE, 0, eNewDevicePowerState);
+                if (eError != PVRSRV_OK)
+                {
+                        goto Exit;
+                }
+        }
+
+        PVR_DPF((PVR_DBG_MESSAGE,
+                        "PVRSRVSystemPostPowerStateKM: System Power Transition from %d to %d OK",
+                        psSysData->eCurrentPowerState, eNewSysPowerState));
+
+        psSysData->eCurrentPowerState = eNewSysPowerState;
+
+Exit:
+
+        PVRSRVPowerUnlock(KERNEL_ID);
+
+         
+        if (_IsSystemStatePowered(eNewSysPowerState) &&
+                        PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL))
+        {
+                
+
+
+                PVRSRVScheduleDeviceCallbacks();
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVSetPowerStateKM(PVRSRV_SYS_POWER_STATE eNewSysPowerState)
+{
+        PVRSRV_ERROR    eError;
+        SYS_DATA                *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        eError = PVRSRVSystemPrePowerStateKM(eNewSysPowerState);
+        if(eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        eError = PVRSRVSystemPostPowerStateKM(eNewSysPowerState);
+        if(eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        
+        psSysData->eFailedPowerState = PVRSRV_SYS_POWER_STATE_Unspecified;
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        PVR_DPF((PVR_DBG_ERROR,
+                        "PVRSRVSetPowerStateKM: Transition from %d to %d FAILED 0x%x",
+                        psSysData->eCurrentPowerState, eNewSysPowerState, eError));
+
+        
+        psSysData->eFailedPowerState = eNewSysPowerState;
+
+        return eError;
+}
+
+
+PVRSRV_ERROR PVRSRVRegisterPowerDevice(IMG_UINT32                                       ui32DeviceIndex,
+                                                                           PFN_PRE_POWER                                pfnPrePower,
+                                                                           PFN_POST_POWER                               pfnPostPower,
+                                                                           PFN_PRE_CLOCKSPEED_CHANGE    pfnPreClockSpeedChange,
+                                                                           PFN_POST_CLOCKSPEED_CHANGE   pfnPostClockSpeedChange,
+                                                                           IMG_HANDLE                                   hDevCookie,
+                                                                           PVRSRV_DEV_POWER_STATE               eCurrentPowerState,
+                                                                           PVRSRV_DEV_POWER_STATE               eDefaultPowerState)
+{
+        PVRSRV_ERROR            eError;
+        SYS_DATA                        *psSysData;
+        PVRSRV_POWER_DEV        *psPowerDevice;
+
+        if (pfnPrePower == IMG_NULL &&
+                pfnPostPower == IMG_NULL)
+        {
+                return PVRSRVRemovePowerDevice(ui32DeviceIndex);
+        }
+
+        SysAcquireData(&psSysData);
+
+        eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                                 sizeof(PVRSRV_POWER_DEV),
+                                                 (IMG_VOID **)&psPowerDevice, IMG_NULL,
+                                                 "Power Device");
+        if(eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterPowerDevice: Failed to alloc PVRSRV_POWER_DEV"));
+                return eError;
+        }
+
+        
+        psPowerDevice->pfnPrePower = pfnPrePower;
+        psPowerDevice->pfnPostPower = pfnPostPower;
+        psPowerDevice->pfnPreClockSpeedChange = pfnPreClockSpeedChange;
+        psPowerDevice->pfnPostClockSpeedChange = pfnPostClockSpeedChange;
+        psPowerDevice->hDevCookie = hDevCookie;
+        psPowerDevice->ui32DeviceIndex = ui32DeviceIndex;
+        psPowerDevice->eCurrentPowerState = eCurrentPowerState;
+        psPowerDevice->eDefaultPowerState = eDefaultPowerState;
+
+        
+        List_PVRSRV_POWER_DEV_Insert(&(psSysData->psPowerDeviceList), psPowerDevice);
+
+        return (PVRSRV_OK);
+}
+
+
+PVRSRV_ERROR PVRSRVRemovePowerDevice (IMG_UINT32 ui32DeviceIndex)
+{
+        SYS_DATA                        *psSysData;
+        PVRSRV_POWER_DEV        *psPowerDev;
+
+        SysAcquireData(&psSysData);
+
+        
+        psPowerDev = (PVRSRV_POWER_DEV*)
+                                        List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
+                                                                                                 &MatchPowerDeviceIndex_AnyVaCb,
+                                                                                                 ui32DeviceIndex);
+
+        if (psPowerDev)
+        {
+                List_PVRSRV_POWER_DEV_Remove(psPowerDev);
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_POWER_DEV), psPowerDev, IMG_NULL);
+                
+        }
+
+        return (PVRSRV_OK);
+}
+
+
+IMG_EXPORT
+IMG_BOOL PVRSRVIsDevicePowered(IMG_UINT32 ui32DeviceIndex)
+{
+        SYS_DATA                        *psSysData;
+        PVRSRV_POWER_DEV        *psPowerDevice;
+
+        SysAcquireData(&psSysData);
+
+         
+        if (OSIsResourceLocked(&psSysData->sPowerStateChangeResource, KERNEL_ID) ||
+                OSIsResourceLocked(&psSysData->sPowerStateChangeResource, ISR_ID))
+        {
+                return IMG_FALSE;
+        }
+
+        psPowerDevice = (PVRSRV_POWER_DEV*)
+                                        List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
+                                                                                                 &MatchPowerDeviceIndex_AnyVaCb,
+                                                                                                 ui32DeviceIndex);
+        return (psPowerDevice && (psPowerDevice->eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON))
+                        ? IMG_TRUE : IMG_FALSE;
+}
+
+
+PVRSRV_ERROR PVRSRVDevicePreClockSpeedChange(IMG_UINT32 ui32DeviceIndex,
+                                                                                         IMG_BOOL       bIdleDevice,
+                                                                                         IMG_VOID       *pvInfo)
+{
+        PVRSRV_ERROR            eError = PVRSRV_OK;
+        SYS_DATA                        *psSysData;
+        PVRSRV_POWER_DEV        *psPowerDevice;
+
+        PVR_UNREFERENCED_PARAMETER(pvInfo);
+
+        SysAcquireData(&psSysData);
+
+        if (bIdleDevice)
+        {
+                
+                eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
+                if (eError != PVRSRV_OK)
+                {
+                        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,
+                                                                                                 ui32DeviceIndex);
+
+        if (psPowerDevice && psPowerDevice->pfnPostClockSpeedChange)
+        {
+                        eError = psPowerDevice->pfnPreClockSpeedChange(psPowerDevice->hDevCookie,
+                                                                                                                   bIdleDevice,
+                                                                                                                   psPowerDevice->eCurrentPowerState);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,
+                                                "PVRSRVDevicePreClockSpeedChange : Device %u failed, error:0x%x",
+                                                ui32DeviceIndex, eError));
+                        }
+        }
+
+        if (bIdleDevice && eError != PVRSRV_OK)
+        {
+                PVRSRVPowerUnlock(KERNEL_ID);
+        }
+
+        return eError;
+}
+
+
+IMG_VOID PVRSRVDevicePostClockSpeedChange(IMG_UINT32    ui32DeviceIndex,
+                                                                                  IMG_BOOL              bIdleDevice,
+                                                                                  IMG_VOID              *pvInfo)
+{
+        PVRSRV_ERROR            eError;
+        SYS_DATA                        *psSysData;
+        PVRSRV_POWER_DEV        *psPowerDevice;
+
+        PVR_UNREFERENCED_PARAMETER(pvInfo);
+
+        SysAcquireData(&psSysData);
+
+        
+        psPowerDevice = (PVRSRV_POWER_DEV*)
+                                        List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
+                                                                                                 &MatchPowerDeviceIndex_AnyVaCb,
+                                                                                                 ui32DeviceIndex);
+
+        if (psPowerDevice && psPowerDevice->pfnPostClockSpeedChange)
+        {
+                eError = psPowerDevice->pfnPostClockSpeedChange(psPowerDevice->hDevCookie,
+                                                                                                                bIdleDevice,
+                                                                                                                psPowerDevice->eCurrentPowerState);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,
+                                        "PVRSRVDevicePostClockSpeedChange : Device %u failed, error:0x%x",
+                                        ui32DeviceIndex, eError));
+                }
+        }
+
+
+        if (bIdleDevice)
+        {
+                
+                PVRSRVPowerUnlock(KERNEL_ID);
+        }
+}
+
diff --git a/drivers/gpu/pvr/power.h b/drivers/gpu/pvr/power.h
new file mode 100644
index 00000000000..079f2128659
--- /dev/null
+++ b/drivers/gpu/pvr/power.h
@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * 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 POWER_H
+#define POWER_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+ 
+typedef struct _PVRSRV_POWER_DEV_TAG_
+{
+        PFN_PRE_POWER                                   pfnPrePower;
+        PFN_POST_POWER                                  pfnPostPower;
+        PFN_PRE_CLOCKSPEED_CHANGE               pfnPreClockSpeedChange;
+        PFN_POST_CLOCKSPEED_CHANGE              pfnPostClockSpeedChange;
+        IMG_HANDLE                                              hDevCookie;
+        IMG_UINT32                                              ui32DeviceIndex;
+        PVRSRV_DEV_POWER_STATE                  eDefaultPowerState;
+        PVRSRV_DEV_POWER_STATE                  eCurrentPowerState;
+        struct _PVRSRV_POWER_DEV_TAG_   *psNext;
+        struct _PVRSRV_POWER_DEV_TAG_   **ppsThis;
+
+} PVRSRV_POWER_DEV;
+
+typedef enum _PVRSRV_INIT_SERVER_STATE_
+{
+        PVRSRV_INIT_SERVER_Unspecified          = -1,   
+        PVRSRV_INIT_SERVER_RUNNING                      = 0,    
+        PVRSRV_INIT_SERVER_RAN                          = 1,    
+        PVRSRV_INIT_SERVER_SUCCESSFUL           = 2,    
+        PVRSRV_INIT_SERVER_NUM                          = 3,    
+        PVRSRV_INIT_SERVER_FORCE_I32 = 0x7fffffff
+
+} PVRSRV_INIT_SERVER_STATE, *PPVRSRV_INIT_SERVER_STATE;
+
+IMG_IMPORT
+IMG_BOOL PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_STATE      eInitServerState);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_STATE  eInitServerState, IMG_BOOL bState);
+
+
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVPowerLock(IMG_UINT32 ui32CallerID,
+                                                         IMG_BOOL       bSystemPowerEvent);
+IMG_IMPORT
+IMG_VOID PVRSRVPowerUnlock(IMG_UINT32   ui32CallerID);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetDevicePowerStateKM(IMG_UINT32                             ui32DeviceIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE eNewPowerState,
+                                                                                 IMG_UINT32                             ui32CallerID,
+                                                                                 IMG_BOOL                               bRetainMutex);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSystemPrePowerStateKM(PVRSRV_SYS_POWER_STATE eNewPowerState);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSystemPostPowerStateKM(PVRSRV_SYS_POWER_STATE eNewPowerState);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetPowerStateKM (PVRSRV_SYS_POWER_STATE ePVRState);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVRegisterPowerDevice(IMG_UINT32                                       ui32DeviceIndex,
+                                                                           PFN_PRE_POWER                                pfnPrePower,
+                                                                           PFN_POST_POWER                               pfnPostPower,
+                                                                           PFN_PRE_CLOCKSPEED_CHANGE    pfnPreClockSpeedChange,
+                                                                           PFN_POST_CLOCKSPEED_CHANGE   pfnPostClockSpeedChange,
+                                                                           IMG_HANDLE                                   hDevCookie,
+                                                                           PVRSRV_DEV_POWER_STATE               eCurrentPowerState,
+                                                                           PVRSRV_DEV_POWER_STATE               eDefaultPowerState);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVRemovePowerDevice (IMG_UINT32 ui32DeviceIndex);
+
+IMG_IMPORT
+IMG_BOOL PVRSRVIsDevicePowered(IMG_UINT32 ui32DeviceIndex);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVDevicePreClockSpeedChange(IMG_UINT32 ui32DeviceIndex,
+                                                                                         IMG_BOOL       bIdleDevice,
+                                                                                         IMG_VOID       *pvInfo);
+
+IMG_IMPORT
+IMG_VOID PVRSRVDevicePostClockSpeedChange(IMG_UINT32    ui32DeviceIndex,
+                                                                                  IMG_BOOL              bIdleDevice,
+                                                                                  IMG_VOID              *pvInfo);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif 
+
diff --git a/drivers/gpu/pvr/private_data.h b/drivers/gpu/pvr/private_data.h
new file mode 100644
index 00000000000..0751765f61f
--- /dev/null
+++ b/drivers/gpu/pvr/private_data.h
@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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 __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
+
+typedef struct
+{
+        
+        IMG_UINT32 ui32OpenPID;
+
+#if defined(PVR_SECURE_FD_EXPORT)
+        
+        IMG_HANDLE hKernelMemInfo;
+#endif 
+
+#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
+        
+        struct list_head sDRMAuthListItem;
+
+        struct drm_file *psDRMFile;
+#endif
+
+#if defined(SUPPORT_MEMINFO_IDS)
+        
+        IMG_UINT64 ui64Stamp;
+#endif 
+
+        
+        IMG_HANDLE hBlockAlloc;
+
+#if defined(SUPPORT_DRI_DRM_EXT)
+        IMG_PVOID pPriv;        
+#endif
+}
+PVRSRV_FILE_PRIVATE_DATA;
+
+#endif 
+
diff --git a/drivers/gpu/pvr/proc.c b/drivers/gpu/pvr/proc.c
new file mode 100644
index 00000000000..74f313262b8
--- /dev/null
+++ b/drivers/gpu/pvr/proc.c
@@ -0,0 +1,833 @@
+/**********************************************************************
+ *
+ * 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/init.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+#include "services_headers.h"
+
+#include "queue.h"
+#include "resman.h"
+#include "pvrmmap.h"
+#include "pvr_debug.h"
+#include "pvrversion.h"
+#include "proc.h"
+#include "perproc.h"
+#include "env_perproc.h"
+#include "linkage.h"
+
+#include "lists.h"
+
+static struct proc_dir_entry * dir;
+
+static const IMG_CHAR PVRProcDirRoot[] = "pvr";
+
+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 void *pvr_proc_seq_next (struct seq_file *m, void *v, loff_t *pos);
+static int pvr_proc_seq_show (struct seq_file *m, void *v);
+static ssize_t pvr_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
+
+static struct file_operations pvr_proc_operations =
+{
+        .open           = pvr_proc_open,
+        .read           = seq_read,
+        .write          = pvr_proc_write,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
+static struct seq_operations pvr_proc_seq_operations =
+{
+        .start =        pvr_proc_seq_start,
+        .next =         pvr_proc_seq_next,
+        .stop =         pvr_proc_seq_stop,
+        .show =         pvr_proc_seq_show,
+};
+
+static struct proc_dir_entry* g_pProcQueue;
+static struct proc_dir_entry* g_pProcVersion;
+static struct proc_dir_entry* g_pProcSysNodes;
+
+#ifdef DEBUG
+static struct proc_dir_entry* g_pProcDebugLevel;
+#endif
+
+#ifdef PVR_MANUAL_POWER_CONTROL
+static struct proc_dir_entry* g_pProcPowerLevel;
+#endif
+
+
+static void ProcSeqShowVersion(struct seq_file *sfile,void* el);
+
+static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el);
+static void* ProcSeqOff2ElementSysNodes(struct seq_file * sfile, loff_t off);
+
+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;
+
+    va_start (ap, format);
+
+    n = vsnprintf (buffer+off, space, format, ap);
+
+    va_end (ap);
+    
+    if (n >= (IMG_INT)space || n < 0)
+    {
+        
+        buffer[size - 1] = 0;
+        return (off_t)(size - 1);
+    }
+    else
+    {
+        return (off + (off_t)n);
+    }
+}
+
+
+void* ProcSeq1ElementOff2Element(struct seq_file *sfile, loff_t off)
+{
+        PVR_UNREFERENCED_PARAMETER(sfile);
+        
+        if(!off)
+                return (void*)2;
+        return NULL;
+}
+
+
+void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off)
+{
+        PVR_UNREFERENCED_PARAMETER(sfile);
+
+        if(!off)
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+        
+        if(off == 1)
+                return (void*)2;
+
+        return NULL;
+}
+
+
+static IMG_INT pvr_proc_open(struct inode *inode,struct file *file)
+{
+        IMG_INT ret = seq_open(file, &pvr_proc_seq_operations);
+
+        struct seq_file *seq = (struct seq_file*)file->private_data;
+        struct proc_dir_entry* pvr_proc_entry = PDE(inode);
+
+        
+        seq->private = pvr_proc_entry->data;
+        return ret;
+}
+
+static ssize_t pvr_proc_write(struct file *file, const char __user *buffer,
+                size_t count, loff_t *ppos)
+{
+        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)
+                return -EIO;
+
+        return dp->write_proc(file, buffer, count, dp->data);
+}
+
+
+static void *pvr_proc_seq_start (struct seq_file *proc_seq_file, loff_t *pos)
+{
+        PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+        if(handlers->startstop != NULL)
+                handlers->startstop(proc_seq_file, IMG_TRUE);
+        return handlers->off2element(proc_seq_file, *pos);
+}
+
+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);
+}
+
+static void *pvr_proc_seq_next (struct seq_file *proc_seq_file, void *v, loff_t *pos)
+{
+        PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+        (*pos)++;
+        if( handlers->next != NULL)
+                return handlers->next( proc_seq_file, v, *pos );
+        return handlers->off2element(proc_seq_file, *pos);
+}
+
+static int pvr_proc_seq_show (struct seq_file *proc_seq_file, void *v)
+{
+        PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)proc_seq_file->private;
+        handlers->show( proc_seq_file,v );
+    return 0;
+}
+
+
+
+static struct proc_dir_entry* CreateProcEntryInDirSeq(
+                                                                           struct proc_dir_entry *pdir,
+                                                                           const IMG_CHAR * name,
+                                                                   IMG_VOID* data,
+                                                                           pvr_next_proc_seq_t next_handler,
+                                                                           pvr_show_proc_seq_t show_handler,
+                                                                           pvr_off2element_proc_seq_t off2element_handler,
+                                                                           pvr_startstop_proc_seq_t startstop_handler,
+                                                                           write_proc_t whandler
+                                                                           )
+{
+
+    struct proc_dir_entry * file;
+        mode_t mode;
+
+    if (!dir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDirSeq: cannot make proc entry /proc/%s/%s: no parent", PVRProcDirRoot, name));
+        return NULL;
+    }
+
+        mode = S_IFREG;
+
+    if (show_handler)
+    {
+                mode |= S_IRUGO;
+    }
+
+    if (whandler)
+    {
+                mode |= S_IWUSR;
+    }
+
+        file=create_proc_entry(name, mode, pdir);
+
+    if (file)
+    {
+                PVR_PROC_SEQ_HANDLERS *seq_handlers;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30))
+        file->owner = THIS_MODULE;
+#endif
+
+                file->proc_fops = &pvr_proc_operations;
+                file->write_proc = whandler;
+
+                
+                file->data =  kmalloc(sizeof(PVR_PROC_SEQ_HANDLERS), GFP_KERNEL);
+                if(file->data)
+                {
+                        seq_handlers = (PVR_PROC_SEQ_HANDLERS*)file->data;
+                        seq_handlers->next = next_handler;
+                        seq_handlers->show = show_handler;
+                        seq_handlers->off2element = off2element_handler;
+                        seq_handlers->startstop = startstop_handler;
+                        seq_handlers->data = data;
+
+                return file;
+                }
+    }
+
+    PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDirSeq: cannot make proc entry /proc/%s/%s: no memory", PVRProcDirRoot, name));
+    return NULL;
+}
+
+
+struct proc_dir_entry* CreateProcReadEntrySeq (
+                                                                const IMG_CHAR * name,
+                                                                IMG_VOID* data,
+                                                                pvr_next_proc_seq_t next_handler,
+                                                                pvr_show_proc_seq_t show_handler,
+                                                                pvr_off2element_proc_seq_t off2element_handler,
+                                                                pvr_startstop_proc_seq_t startstop_handler
+                                                           )
+{
+        return CreateProcEntrySeq(name,
+                                                          data,
+                                                          next_handler,
+                                                          show_handler,
+                                                          off2element_handler,
+                                                          startstop_handler,
+                                                          NULL);
+}
+
+struct proc_dir_entry* CreateProcEntrySeq (
+                                                                                        const IMG_CHAR * name,
+                                                                                        IMG_VOID* data,
+                                                                                        pvr_next_proc_seq_t next_handler,
+                                                                                        pvr_show_proc_seq_t show_handler,
+                                                                                        pvr_off2element_proc_seq_t off2element_handler,
+                                                                                        pvr_startstop_proc_seq_t startstop_handler,
+                                                                                        write_proc_t whandler
+                                                                                  )
+{
+        return CreateProcEntryInDirSeq(
+                                                                   dir,
+                                                                   name,
+                                                                   data,
+                                                                   next_handler,
+                                                                   show_handler,
+                                                                   off2element_handler,
+                                                                   startstop_handler,
+                                                                   whandler
+                                                                  );
+}
+
+
+
+struct proc_dir_entry* CreatePerProcessProcEntrySeq (
+                                                                          const IMG_CHAR * name,
+                                                                  IMG_VOID* data,
+                                                                          pvr_next_proc_seq_t next_handler,
+                                                                          pvr_show_proc_seq_t show_handler,
+                                                                          pvr_off2element_proc_seq_t off2element_handler,
+                                                                          pvr_startstop_proc_seq_t startstop_handler,
+                                                                          write_proc_t whandler
+                                                                         )
+{
+    PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+    IMG_UINT32 ui32PID;
+
+    if (!dir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntrySeq: /proc/%s doesn't exist", PVRProcDirRoot));
+        return NULL;
+    }
+
+    ui32PID = OSGetCurrentProcessIDKM();
+
+    psPerProc = PVRSRVPerProcessPrivateData(ui32PID);
+    if (!psPerProc)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntrySeq: no per process data"));
+
+        return NULL;
+    }
+
+    if (!psPerProc->psProcDir)
+    {
+        IMG_CHAR dirname[16];
+        IMG_INT ret;
+
+        ret = snprintf(dirname, sizeof(dirname), "%u", ui32PID);
+
+                if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't generate per process proc directory name \"%u\"", ui32PID));
+                        return NULL;
+                }
+                else
+                {
+                        psPerProc->psProcDir = proc_mkdir(dirname, dir);
+                        if (!psPerProc->psProcDir)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't create per process proc directory /proc/%s/%u",
+                                                PVRProcDirRoot, ui32PID));
+                                return NULL;
+                        }
+                }
+    }
+
+    return CreateProcEntryInDirSeq(psPerProc->psProcDir, name, data, next_handler,
+                                                                   show_handler,off2element_handler,startstop_handler,whandler);
+}
+
+
+IMG_VOID RemoveProcEntrySeq( struct proc_dir_entry* proc_entry )
+{
+    if (dir)
+    {
+                void* data = proc_entry->data ;
+        PVR_DPF((PVR_DBG_MESSAGE, "Removing /proc/%s/%s", PVRProcDirRoot, proc_entry->name));
+
+        remove_proc_entry(proc_entry->name, dir);
+                if( data)
+                        kfree( data );
+
+    }
+}
+
+IMG_VOID RemovePerProcessProcEntrySeq(struct proc_dir_entry* proc_entry)
+{
+    PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+
+    psPerProc = LinuxTerminatingProcessPrivateData();
+    if (!psPerProc)
+    {
+        psPerProc = PVRSRVFindPerProcessPrivateData();
+        if (!psPerProc)
+        {
+            PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: can't "
+                                    "remove %s, no per process data", proc_entry->name));
+            return;
+        }
+    }
+
+    if (psPerProc->psProcDir)
+    {
+                void* data = proc_entry->data ;
+        PVR_DPF((PVR_DBG_MESSAGE, "Removing proc entry %s from %s", proc_entry->name, psPerProc->psProcDir->name));
+
+        remove_proc_entry(proc_entry->name, psPerProc->psProcDir);
+                if(data)
+                        kfree( data );
+    }
+}
+
+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);
+
+    if (len == END_OF_FILE)
+    {
+        len  = 0;
+        *eof = 1;
+    }
+    else if (!len)             
+    {
+        *start = (IMG_CHAR *) 0;   
+    }
+    else
+    {
+        *start = (IMG_CHAR *) 1;
+    }
+
+    return len;
+}
+
+
+static IMG_INT CreateProcEntryInDir(struct proc_dir_entry *pdir, const IMG_CHAR * name, read_proc_t rhandler, write_proc_t whandler, IMG_VOID *data)
+{
+    struct proc_dir_entry * file;
+    mode_t mode;
+
+    if (!pdir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntryInDir: parent directory doesn't exist"));
+
+        return -ENOMEM;
+    }
+
+    mode = S_IFREG;
+
+    if (rhandler)
+    {
+        mode |= S_IRUGO;
+    }
+
+    if (whandler)
+    {
+        mode |= S_IWUSR;
+    }
+
+    file = create_proc_entry(name, mode, pdir);
+
+    if (file)
+    {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30))
+        file->owner = THIS_MODULE;
+#endif
+                file->read_proc = rhandler;
+                file->write_proc = whandler;
+                file->data = data;
+
+                PVR_DPF((PVR_DBG_MESSAGE, "Created proc entry %s in %s", name, pdir->name));
+
+        return 0;
+    }
+
+    PVR_DPF((PVR_DBG_ERROR, "CreateProcEntry: cannot create proc entry %s in %s", name, pdir->name));
+
+    return -ENOMEM;
+}
+
+
+IMG_INT CreateProcEntry(const IMG_CHAR * name, read_proc_t rhandler, write_proc_t whandler, IMG_VOID *data)
+{
+    return CreateProcEntryInDir(dir, name, rhandler, whandler, data);
+}
+
+
+IMG_INT CreatePerProcessProcEntry(const IMG_CHAR * name, read_proc_t rhandler, write_proc_t whandler, IMG_VOID *data)
+{
+    PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+    IMG_UINT32 ui32PID;
+
+    if (!dir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: /proc/%s doesn't exist", PVRProcDirRoot));
+
+        return -ENOMEM;
+    }
+
+    ui32PID = OSGetCurrentProcessIDKM();
+
+    psPerProc = PVRSRVPerProcessPrivateData(ui32PID);
+    if (!psPerProc)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: no per process data"));
+
+        return -ENOMEM;
+    }
+
+    if (!psPerProc->psProcDir)
+    {
+        IMG_CHAR dirname[16];
+        IMG_INT ret;
+
+        ret = snprintf(dirname, sizeof(dirname), "%u", ui32PID);
+
+                if (ret <=0 || ret >= (IMG_INT)sizeof(dirname))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't generate per process proc directory name \"%u\"", ui32PID));
+
+                                        return -ENOMEM;
+                }
+                else
+                {
+                        psPerProc->psProcDir = proc_mkdir(dirname, dir);
+                        if (!psPerProc->psProcDir)
+                        {
+                        PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: couldn't create per process proc directory /proc/%s/%u", PVRProcDirRoot, ui32PID));
+
+                        return -ENOMEM;
+                        }
+                }
+    }
+
+    return CreateProcEntryInDir(psPerProc->psProcDir, name, rhandler, whandler, data);
+}
+
+
+IMG_INT CreateProcReadEntry(const IMG_CHAR * name, pvr_read_proc_t handler)
+{
+    struct proc_dir_entry * file;
+
+    if (!dir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcReadEntry: cannot make proc entry /proc/%s/%s: no parent", PVRProcDirRoot, name));
+
+        return -ENOMEM;
+    }
+
+         
+    file = create_proc_read_entry (name, S_IFREG | S_IRUGO, dir, pvr_read_proc, (IMG_VOID *)handler);
+
+    if (file)
+    {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30))
+        file->owner = THIS_MODULE;
+#endif
+        return 0;
+    }
+
+    PVR_DPF((PVR_DBG_ERROR, "CreateProcReadEntry: cannot make proc entry /proc/%s/%s: no memory", PVRProcDirRoot, name));
+
+    return -ENOMEM;
+}
+
+
+IMG_INT CreateProcEntries(IMG_VOID)
+{
+    dir = proc_mkdir (PVRProcDirRoot, NULL);
+
+    if (!dir)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: cannot make /proc/%s directory", PVRProcDirRoot));
+
+        return -ENOMEM;
+    }
+
+        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)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s files", PVRProcDirRoot));
+
+        return -ENOMEM;
+    }
+
+
+#ifdef DEBUG
+
+        g_pProcDebugLevel = CreateProcEntrySeq("debug_level", NULL, NULL,
+                                                                                        ProcSeqShowDebugLevel,
+                                                                                        ProcSeq1ElementOff2Element, NULL,
+                                                                                    (IMG_VOID*)PVRDebugProcSetLevel);
+        if(!g_pProcDebugLevel)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/debug_level", PVRProcDirRoot));
+
+        return -ENOMEM;
+    }
+
+#ifdef PVR_MANUAL_POWER_CONTROL
+        g_pProcPowerLevel = CreateProcEntrySeq("power_control", NULL, NULL,
+                                                                                        ProcSeqShowPowerLevel,
+                                                                                        ProcSeq1ElementOff2Element, NULL,
+                                                                                    PVRProcSetPowerLevel);
+        if(!g_pProcPowerLevel)
+    {
+        PVR_DPF((PVR_DBG_ERROR, "CreateProcEntries: couldn't make /proc/%s/power_control", PVRProcDirRoot));
+
+        return -ENOMEM;
+    }
+#endif
+#endif
+
+    return 0;
+}
+
+
+IMG_VOID RemoveProcEntry(const IMG_CHAR * name)
+{
+    if (dir)
+    {
+        remove_proc_entry(name, dir);
+        PVR_DPF((PVR_DBG_MESSAGE, "Removing /proc/%s/%s", PVRProcDirRoot, name));
+    }
+}
+
+
+IMG_VOID RemovePerProcessProcEntry(const IMG_CHAR *name)
+{
+    PVRSRV_ENV_PER_PROCESS_DATA *psPerProc;
+
+    psPerProc = LinuxTerminatingProcessPrivateData();
+    if (!psPerProc)
+    {
+        psPerProc = PVRSRVFindPerProcessPrivateData();
+        if (!psPerProc)
+        {
+            PVR_DPF((PVR_DBG_ERROR, "CreatePerProcessProcEntries: can't "
+                                    "remove %s, no per process data", name));
+            return;
+        }
+    }
+
+    if (psPerProc->psProcDir)
+    {
+        remove_proc_entry(name, psPerProc->psProcDir);
+
+        PVR_DPF((PVR_DBG_MESSAGE, "Removing proc entry %s from %s", name, psPerProc->psProcDir->name));
+    }
+}
+
+
+IMG_VOID RemovePerProcessProcDir(PVRSRV_ENV_PER_PROCESS_DATA *psPerProc)
+{
+    if (psPerProc->psProcDir)
+    {
+        while (psPerProc->psProcDir->subdir)
+        {
+            PVR_DPF((PVR_DBG_WARNING, "Belatedly removing /proc/%s/%s/%s", PVRProcDirRoot, psPerProc->psProcDir->name, psPerProc->psProcDir->subdir->name));
+
+            RemoveProcEntry(psPerProc->psProcDir->subdir->name);
+        }
+        RemoveProcEntry(psPerProc->psProcDir->name);
+    }
+}
+
+IMG_VOID RemoveProcEntries(IMG_VOID)
+{
+#ifdef DEBUG
+        RemoveProcEntrySeq( g_pProcDebugLevel );
+#ifdef PVR_MANUAL_POWER_CONTROL
+        RemoveProcEntrySeq( g_pProcPowerLevel );
+#endif 
+#endif
+
+    RemoveProcEntrySeq(g_pProcQueue);
+    RemoveProcEntrySeq(g_pProcVersion);
+        RemoveProcEntrySeq(g_pProcSysNodes);
+
+        while (dir->subdir)
+        {
+                PVR_DPF((PVR_DBG_WARNING, "Belatedly removing /proc/%s/%s", PVRProcDirRoot, dir->subdir->name));
+
+                RemoveProcEntry(dir->subdir->name);
+        }
+
+        remove_proc_entry(PVRProcDirRoot, NULL);
+}
+
+static void ProcSeqShowVersion(struct seq_file *sfile,void* el)
+{
+        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);
+                return;
+        }
+
+    SysAcquireData(&psSysData);
+
+    if(psSysData->pszVersionString)
+        {
+        pszSystemVersionString = psSysData->pszVersionString;
+    }
+
+        seq_printf( sfile, "System Version String: %s\n", pszSystemVersionString);
+}
+
+static const IMG_CHAR *deviceTypeToString(PVRSRV_DEVICE_TYPE deviceType)
+{
+    switch (deviceType)
+    {
+        default:
+        {
+            static IMG_CHAR text[10];
+
+            sprintf(text, "?%x", (IMG_UINT)deviceType);
+
+            return text;
+        }
+    }
+}
+
+
+static const IMG_CHAR *deviceClassToString(PVRSRV_DEVICE_CLASS deviceClass)
+{
+    switch (deviceClass)
+    {
+        case PVRSRV_DEVICE_CLASS_3D:
+        {
+            return "3D";
+        }
+        case PVRSRV_DEVICE_CLASS_DISPLAY:
+        {
+            return "display";
+        }
+        case PVRSRV_DEVICE_CLASS_BUFFER:
+        {
+            return "buffer";
+        }
+        default:
+        {
+            static IMG_CHAR text[10];
+
+            sprintf(text, "?%x", (IMG_UINT)deviceClass);
+            return text;
+        }
+    }
+}
+
+static IMG_VOID* DecOffPsDev_AnyVaCb(PVRSRV_DEVICE_NODE *psNode, va_list va)
+{
+        off_t *pOff = va_arg(va, off_t*);
+        if (--(*pOff))
+        {
+                return IMG_NULL;
+        }
+        else
+        {
+                return psNode;
+        }
+}
+
+static void ProcSeqShowSysNodes(struct seq_file *sfile,void* el)
+{
+        SYS_DATA * psSysData;
+    PVRSRV_DEVICE_NODE  *psDevNode = (PVRSRV_DEVICE_NODE*)el;
+
+        if(el == PVR_PROC_SEQ_START_TOKEN)
+        {
+                seq_printf( sfile,
+                                                "Registered nodes\n"
+                                                "Addr     Type     Class    Index Ref pvDev     Size Res\n");
+                return;
+        }
+
+    SysAcquireData(&psSysData);
+
+        seq_printf( sfile,
+                                  "%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;
+    
+    PVR_UNREFERENCED_PARAMETER(sfile);
+    
+        if(!off)
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+    SysAcquireData(&psSysData);
+
+    
+        psDevNode = (PVRSRV_DEVICE_NODE*)
+                                List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                                        DecOffPsDev_AnyVaCb,
+                                                                                                        &off);
+
+        
+        return (void*)psDevNode;
+}
+
diff --git a/drivers/gpu/pvr/proc.h b/drivers/gpu/pvr/proc.h
new file mode 100644
index 00000000000..823b666176b
--- /dev/null
+++ b/drivers/gpu/pvr/proc.h
@@ -0,0 +1,108 @@
+/**********************************************************************
+ *
+ * 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_PROC_H__
+#define __SERVICES_PROC_H__
+
+#include <asm/system.h>         
+#include <linux/proc_fs.h>      
+#include <linux/seq_file.h> 
+
+#define END_OF_FILE (off_t) -1
+
+typedef off_t (pvr_read_proc_t)(IMG_CHAR *, size_t, off_t);
+
+
+#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);
+typedef void (pvr_show_proc_seq_t)(struct seq_file *,void*);
+typedef void (pvr_startstop_proc_seq_t)(struct seq_file *, IMG_BOOL start);
+
+typedef struct _PVR_PROC_SEQ_HANDLERS_ {
+        pvr_next_proc_seq_t *next;      
+        pvr_show_proc_seq_t *show;      
+        pvr_off2element_proc_seq_t *off2element;
+        pvr_startstop_proc_seq_t *startstop;
+        IMG_VOID *data;
+} PVR_PROC_SEQ_HANDLERS;
+
+
+void* ProcSeq1ElementOff2Element(struct seq_file *sfile, loff_t off);
+
+void* ProcSeq1ElementHeaderOff2Element(struct seq_file *sfile, loff_t off);
+
+off_t printAppend(IMG_CHAR * buffer, size_t size, off_t off, const IMG_CHAR * format, ...)
+        __attribute__((format(printf, 4, 5)));
+
+IMG_INT CreateProcEntries(IMG_VOID);
+
+IMG_INT CreateProcReadEntry (const IMG_CHAR * name, pvr_read_proc_t handler);
+
+IMG_INT CreateProcEntry(const IMG_CHAR * name, read_proc_t rhandler, write_proc_t whandler, IMG_VOID *data);
+
+IMG_INT CreatePerProcessProcEntry(const IMG_CHAR * name, read_proc_t rhandler, write_proc_t whandler, IMG_VOID *data);
+
+IMG_VOID RemoveProcEntry(const IMG_CHAR * name);
+
+IMG_VOID RemovePerProcessProcEntry(const IMG_CHAR * name);
+
+IMG_VOID RemoveProcEntries(IMG_VOID);
+
+struct proc_dir_entry* CreateProcReadEntrySeq (
+                                                                const IMG_CHAR* name, 
+                                                                IMG_VOID* data,
+                                                                pvr_next_proc_seq_t next_handler, 
+                                                                pvr_show_proc_seq_t show_handler,
+                                                                pvr_off2element_proc_seq_t off2element_handler,
+                                                                pvr_startstop_proc_seq_t startstop_handler
+                                                           );
+
+struct proc_dir_entry* CreateProcEntrySeq (
+                                                                const IMG_CHAR* name, 
+                                                                IMG_VOID* data,
+                                                                pvr_next_proc_seq_t next_handler, 
+                                                                pvr_show_proc_seq_t show_handler,
+                                                                pvr_off2element_proc_seq_t off2element_handler,
+                                                                pvr_startstop_proc_seq_t startstop_handler,
+                                                                write_proc_t whandler
+                                                           );
+
+struct proc_dir_entry* CreatePerProcessProcEntrySeq (
+                                                                const IMG_CHAR* name, 
+                                                                IMG_VOID* data,
+                                                                pvr_next_proc_seq_t next_handler, 
+                                                                pvr_show_proc_seq_t show_handler,
+                                                                pvr_off2element_proc_seq_t off2element_handler,
+                                                                pvr_startstop_proc_seq_t startstop_handler,
+                                                                write_proc_t whandler
+                                                           );
+
+
+IMG_VOID RemoveProcEntrySeq(struct proc_dir_entry* proc_entry);
+IMG_VOID RemovePerProcessProcEntrySeq(struct proc_dir_entry* proc_entry);
+
+#endif
diff --git a/drivers/gpu/pvr/pvr_bridge.h b/drivers/gpu/pvr/pvr_bridge.h
new file mode 100644
index 00000000000..469ceb223cd
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_bridge.h
@@ -0,0 +1,1450 @@
+/**********************************************************************
+ *
+ * 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_BRIDGE_H__
+#define __PVR_BRIDGE_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "servicesint.h"
+
+#ifdef __linux__
+
+                #include <linux/ioctl.h>
+    
+    #define PVRSRV_IOC_GID      'g'
+    #define PVRSRV_IO(INDEX)    _IO(PVRSRV_IOC_GID, INDEX, PVRSRV_BRIDGE_PACKAGE)
+    #define PVRSRV_IOW(INDEX)   _IOW(PVRSRV_IOC_GID, INDEX, PVRSRV_BRIDGE_PACKAGE)
+    #define PVRSRV_IOR(INDEX)   _IOR(PVRSRV_IOC_GID, INDEX, PVRSRV_BRIDGE_PACKAGE)
+    #define PVRSRV_IOWR(INDEX)  _IOWR(PVRSRV_IOC_GID, INDEX, PVRSRV_BRIDGE_PACKAGE)
+
+#else 
+
+                        #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_BRIDGE_BASE                  PVRSRV_IOC_GID
+#endif 
+
+
+#define PVRSRV_BRIDGE_CORE_CMD_FIRST                    0UL
+#define PVRSRV_BRIDGE_ENUM_DEVICES                              PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+0)     
+#define PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO                PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+1)     
+#define PVRSRV_BRIDGE_RELEASE_DEVICEINFO                PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+2)     
+#define PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT              PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+3)     
+#define PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT             PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+4)     
+#define PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO               PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+5)     
+#define PVRSRV_BRIDGE_ALLOC_DEVICEMEM                   PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+6)     
+#define PVRSRV_BRIDGE_FREE_DEVICEMEM                    PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+7)     
+#define PVRSRV_BRIDGE_GETFREE_DEVICEMEM                 PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+8)     
+#define PVRSRV_BRIDGE_CREATE_COMMANDQUEUE               PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+9)     
+#define PVRSRV_BRIDGE_DESTROY_COMMANDQUEUE              PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+10)    
+#define PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA           PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+11)   
+#define PVRSRV_BRIDGE_CONNECT_SERVICES                  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+12)    
+#define PVRSRV_BRIDGE_DISCONNECT_SERVICES               PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+13)    
+#define PVRSRV_BRIDGE_WRAP_DEVICE_MEM                   PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+14)    
+#define PVRSRV_BRIDGE_GET_DEVICEMEMINFO                 PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+15)    
+#define PVRSRV_BRIDGE_RESERVE_DEV_VIRTMEM               PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+16)
+#define PVRSRV_BRIDGE_FREE_DEV_VIRTMEM                  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+17)
+#define PVRSRV_BRIDGE_MAP_EXT_MEMORY                    PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+18)
+#define PVRSRV_BRIDGE_UNMAP_EXT_MEMORY                  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+19)
+#define PVRSRV_BRIDGE_MAP_DEV_MEMORY                    PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+20)
+#define PVRSRV_BRIDGE_UNMAP_DEV_MEMORY                  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+21)
+#define PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY    PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+22)
+#define PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+23)
+#define PVRSRV_BRIDGE_MAP_MEM_INFO_TO_USER              PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+24)
+#define PVRSRV_BRIDGE_UNMAP_MEM_INFO_FROM_USER  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+25)
+#define PVRSRV_BRIDGE_EXPORT_DEVICEMEM                  PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+26)
+#define PVRSRV_BRIDGE_RELEASE_MMAP_DATA                 PVRSRV_IOWR(PVRSRV_BRIDGE_CORE_CMD_FIRST+27)
+#define PVRSRV_BRIDGE_CORE_CMD_LAST                             (PVRSRV_BRIDGE_CORE_CMD_FIRST+27)
+
+#define PVRSRV_BRIDGE_SIM_CMD_FIRST                             (PVRSRV_BRIDGE_CORE_CMD_LAST+1)
+#define PVRSRV_BRIDGE_PROCESS_SIMISR_EVENT              PVRSRV_IOWR(PVRSRV_BRIDGE_SIM_CMD_FIRST+0)      
+#define PVRSRV_BRIDGE_REGISTER_SIM_PROCESS              PVRSRV_IOWR(PVRSRV_BRIDGE_SIM_CMD_FIRST+1)      
+#define PVRSRV_BRIDGE_UNREGISTER_SIM_PROCESS    PVRSRV_IOWR(PVRSRV_BRIDGE_SIM_CMD_FIRST+2)      
+#define PVRSRV_BRIDGE_SIM_CMD_LAST                              (PVRSRV_BRIDGE_SIM_CMD_FIRST+2)
+
+#define PVRSRV_BRIDGE_MAPPING_CMD_FIRST                 (PVRSRV_BRIDGE_SIM_CMD_LAST+1)
+#define PVRSRV_BRIDGE_MAPPHYSTOUSERSPACE                PVRSRV_IOWR(PVRSRV_BRIDGE_MAPPING_CMD_FIRST+0)  
+#define PVRSRV_BRIDGE_UNMAPPHYSTOUSERSPACE              PVRSRV_IOWR(PVRSRV_BRIDGE_MAPPING_CMD_FIRST+1)  
+#define PVRSRV_BRIDGE_GETPHYSTOUSERSPACEMAP             PVRSRV_IOWR(PVRSRV_BRIDGE_MAPPING_CMD_FIRST+2)  
+#define PVRSRV_BRIDGE_MAPPING_CMD_LAST                  (PVRSRV_BRIDGE_MAPPING_CMD_FIRST+2)
+
+#define PVRSRV_BRIDGE_STATS_CMD_FIRST                   (PVRSRV_BRIDGE_MAPPING_CMD_LAST+1)
+#define PVRSRV_BRIDGE_GET_FB_STATS                              PVRSRV_IOWR(PVRSRV_BRIDGE_STATS_CMD_FIRST+0)    
+#define PVRSRV_BRIDGE_STATS_CMD_LAST                    (PVRSRV_BRIDGE_STATS_CMD_FIRST+0)
+
+#define PVRSRV_BRIDGE_MISC_CMD_FIRST                    (PVRSRV_BRIDGE_STATS_CMD_LAST+1)
+#define PVRSRV_BRIDGE_GET_MISC_INFO                             PVRSRV_IOWR(PVRSRV_BRIDGE_MISC_CMD_FIRST+0)     
+#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)
+
+#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)  
+#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_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_REG                         PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+3)    
+#define PVRSRV_BRIDGE_PDUMP_REGPOL                      PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+4)    
+#define PVRSRV_BRIDGE_PDUMP_COMMENT                     PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+5)    
+#define PVRSRV_BRIDGE_PDUMP_SETFRAME                    PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+6)    
+#define PVRSRV_BRIDGE_PDUMP_ISCAPTURING                 PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+7)    
+#define PVRSRV_BRIDGE_PDUMP_DUMPBITMAP                  PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+8)    
+#define PVRSRV_BRIDGE_PDUMP_DUMPREADREG                 PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+9)    
+#define PVRSRV_BRIDGE_PDUMP_SYNCPOL                     PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+10)   
+#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_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_PDUMP_STOPINITPHASE                       PVRSRV_IOWR(PVRSRV_BRIDGE_PDUMP_CMD_FIRST+18)
+#define PVRSRV_BRIDGE_PDUMP_CMD_LAST                    (PVRSRV_BRIDGE_PDUMP_CMD_FIRST+18)
+#else
+#define PVRSRV_BRIDGE_PDUMP_CMD_LAST                    PVRSRV_BRIDGE_OVERLAY_CMD_LAST
+#endif
+
+#define PVRSRV_BRIDGE_OEM_CMD_FIRST                             (PVRSRV_BRIDGE_PDUMP_CMD_LAST+1)
+#define PVRSRV_BRIDGE_GET_OEMJTABLE                             PVRSRV_IOWR(PVRSRV_BRIDGE_OEM_CMD_FIRST+0)      
+#define PVRSRV_BRIDGE_OEM_CMD_LAST                              (PVRSRV_BRIDGE_OEM_CMD_FIRST+0)
+
+#define PVRSRV_BRIDGE_DEVCLASS_CMD_FIRST                (PVRSRV_BRIDGE_OEM_CMD_LAST+1)
+#define PVRSRV_BRIDGE_ENUM_CLASS                                PVRSRV_IOWR(PVRSRV_BRIDGE_DEVCLASS_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_DEVCLASS_CMD_LAST                 (PVRSRV_BRIDGE_DEVCLASS_CMD_FIRST+0)
+
+#define PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST               (PVRSRV_BRIDGE_DEVCLASS_CMD_LAST+1)
+#define PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE             PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE    PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS    PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+2)
+#define PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS               PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+3)
+#define PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER   PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+4)
+#define PVRSRV_BRIDGE_GET_DISPCLASS_INFO                PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+5)
+#define PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN                PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+6)
+#define PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN               PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+7)
+#define PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT             PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+8)
+#define PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT             PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+9)
+#define PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY                PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+10)
+#define PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY                PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+11)
+#define PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS             PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+12)
+#define PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER  PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+13)
+#define PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM  PVRSRV_IOWR(PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+14)
+#define PVRSRV_BRIDGE_DISPCLASS_CMD_LAST                (PVRSRV_BRIDGE_DISPCLASS_CMD_FIRST+14)
+
+ 
+#define PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST                (PVRSRV_BRIDGE_DISPCLASS_CMD_LAST+1)
+#define PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE   PVRSRV_IOWR(PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE  PVRSRV_IOWR(PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO              PVRSRV_IOWR(PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST+2)
+#define PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER    PVRSRV_IOWR(PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST+3)
+#define PVRSRV_BRIDGE_BUFCLASS_CMD_LAST                 (PVRSRV_BRIDGE_BUFCLASS_CMD_FIRST+3)
+
+#define PVRSRV_BRIDGE_WRAP_CMD_FIRST                    (PVRSRV_BRIDGE_BUFCLASS_CMD_LAST+1)
+#define PVRSRV_BRIDGE_WRAP_EXT_MEMORY                   PVRSRV_IOWR(PVRSRV_BRIDGE_WRAP_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY                 PVRSRV_IOWR(PVRSRV_BRIDGE_WRAP_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_WRAP_CMD_LAST                             (PVRSRV_BRIDGE_WRAP_CMD_FIRST+1)
+
+#define PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST               (PVRSRV_BRIDGE_WRAP_CMD_LAST+1)
+#define PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM              PVRSRV_IOWR(PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM               PVRSRV_IOWR(PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_MAP_MEMINFO_MEM                   PVRSRV_IOWR(PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST+2)
+#define PVRSRV_BRIDGE_UNMAP_MEMINFO_MEM                 PVRSRV_IOWR(PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST+3)
+#define PVRSRV_BRIDGE_SHAREDMEM_CMD_LAST                (PVRSRV_BRIDGE_SHAREDMEM_CMD_FIRST+3)
+
+#define PVRSRV_BRIDGE_SERVICES4_TMP_CMD_FIRST   (PVRSRV_BRIDGE_SHAREDMEM_CMD_LAST+1)
+#define PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR        PVRSRV_IOWR(PVRSRV_BRIDGE_SERVICES4_TMP_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_SERVICES4_TMP_CMD_LAST    (PVRSRV_BRIDGE_SERVICES4_TMP_CMD_FIRST+0)
+
+#define PVRSRV_BRIDGE_INITSRV_CMD_FIRST                 (PVRSRV_BRIDGE_SERVICES4_TMP_CMD_LAST+1)
+#define PVRSRV_BRIDGE_INITSRV_CONNECT                   PVRSRV_IOWR(PVRSRV_BRIDGE_INITSRV_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_INITSRV_DISCONNECT                PVRSRV_IOWR(PVRSRV_BRIDGE_INITSRV_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_INITSRV_CMD_LAST                  (PVRSRV_BRIDGE_INITSRV_CMD_FIRST+1)
+
+#define PVRSRV_BRIDGE_EVENT_OBJECT_CMD_FIRST    (PVRSRV_BRIDGE_INITSRV_CMD_LAST+1)      
+#define PVRSRV_BRIDGE_EVENT_OBJECT_WAIT                 PVRSRV_IOWR(PVRSRV_BRIDGE_EVENT_OBJECT_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_EVENT_OBJECT_OPEN                 PVRSRV_IOWR(PVRSRV_BRIDGE_EVENT_OBJECT_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE                PVRSRV_IOWR(PVRSRV_BRIDGE_EVENT_OBJECT_CMD_FIRST+2)
+#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_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)
+
+
+#define PVRSRV_KERNEL_MODE_CLIENT                               1
+
+typedef struct PVRSRV_BRIDGE_RETURN_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_VOID *pvData;
+
+}PVRSRV_BRIDGE_RETURN;
+
+
+typedef struct PVRSRV_BRIDGE_PACKAGE_TAG
+{
+        IMG_UINT32                              ui32BridgeID;                   
+        IMG_UINT32                              ui32Size;                               
+        IMG_VOID                                *pvParamIn;                              
+        IMG_UINT32                              ui32InBufferSize;               
+        IMG_VOID                                *pvParamOut;                    
+        IMG_UINT32                              ui32OutBufferSize;              
+
+        IMG_HANDLE                              hKernelServices;                
+}PVRSRV_BRIDGE_PACKAGE;
+
+
+ 
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_CONNECT_SERVICES_TAG
+{
+        IMG_UINT32              ui32Flags;
+} PVRSRV_BRIDGE_IN_CONNECT_SERVICES;
+
+typedef struct PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_UINT32                      uiDevIndex;
+        PVRSRV_DEVICE_TYPE      eDeviceType;
+
+} PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO;
+
+
+typedef struct PVRSRV_BRIDGE_IN_ENUMCLASS_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        PVRSRV_DEVICE_CLASS sDeviceClass;
+} PVRSRV_BRIDGE_IN_ENUMCLASS;
+
+
+typedef struct PVRSRV_BRIDGE_IN_CLOSE_DISPCLASS_DEVICE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_CLOSE_DISPCLASS_DEVICE;
+
+
+typedef struct PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_FORMATS_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_FORMATS;
+
+
+typedef struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_SYSBUFFER_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_GET_DISPCLASS_SYSBUFFER;
+
+
+typedef struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_INFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_GET_DISPCLASS_INFO;
+
+
+typedef struct PVRSRV_BRIDGE_IN_CLOSE_BUFFERCLASS_DEVICE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_CLOSE_BUFFERCLASS_DEVICE;
+
+
+typedef struct PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_INFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+} PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_RELEASE_DEVICEINFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+
+} PVRSRV_BRIDGE_IN_RELEASE_DEVICEINFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_FREE_CLASSDEVICEINFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        PVRSRV_DEVICE_CLASS DeviceClass;
+        IMG_VOID*                       pvDevInfo;
+
+}PVRSRV_BRIDGE_IN_FREE_CLASSDEVICEINFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GET_DEVMEM_HEAPINFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_HANDLE                      hDevMemContext;
+
+}PVRSRV_BRIDGE_IN_GET_DEVMEM_HEAPINFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+
+}PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_DESTROY_DEVMEMCONTEXT_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_HANDLE                      hDevMemContext;
+
+}PVRSRV_BRIDGE_IN_DESTROY_DEVMEMCONTEXT;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_HANDLE                      hDevMemHeap;
+        IMG_UINT32                      ui32Attribs;
+        IMG_SIZE_T                      ui32Size;
+        IMG_SIZE_T                      ui32Alignment;
+
+}PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MAPMEMINFOTOUSER_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+
+}PVRSRV_BRIDGE_IN_MAPMEMINFOTOUSER;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNMAPMEMINFOFROMUSER_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        IMG_PVOID                                pvLinAddr;
+        IMG_HANDLE                               hMappingInfo;
+
+}PVRSRV_BRIDGE_IN_UNMAPMEMINFOFROMUSER;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_FREEDEVICEMEM_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+
+}PVRSRV_BRIDGE_IN_FREEDEVICEMEM;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_EXPORTDEVICEMEM_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+
+}PVRSRV_BRIDGE_IN_EXPORTDEVICEMEM;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_UINT32                      ui32Flags;
+
+} PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_CREATECOMMANDQUEUE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_SIZE_T                      ui32QueueSize;
+
+}PVRSRV_BRIDGE_IN_CREATECOMMANDQUEUE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_DESTROYCOMMANDQUEUE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        PVRSRV_QUEUE_INFO       *psQueueInfo;
+
+}PVRSRV_BRIDGE_IN_DESTROYCOMMANDQUEUE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hMHandle;        
+} PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_RELEASE_MMAP_DATA_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hMHandle;        
+} PVRSRV_BRIDGE_IN_RELEASE_MMAP_DATA;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_RESERVE_DEV_VIRTMEM_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevMemHeap;
+        IMG_DEV_VIRTADDR        *psDevVAddr;
+        IMG_SIZE_T                      ui32Size;
+        IMG_SIZE_T                      ui32Alignment;
+
+}PVRSRV_BRIDGE_IN_RESERVE_DEV_VIRTMEM;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_CONNECT_SERVICES_TAG
+{
+        PVRSRV_ERROR                    eError;
+        IMG_HANDLE              hKernelServices;
+}PVRSRV_BRIDGE_OUT_CONNECT_SERVICES;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_RESERVE_DEV_VIRTMEM_TAG
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+}PVRSRV_BRIDGE_OUT_RESERVE_DEV_VIRTMEM;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_FREE_DEV_VIRTMEM_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+}PVRSRV_BRIDGE_IN_FREE_DEV_VIRTMEM;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hKernelMemInfo;
+        IMG_HANDLE                              hDstDevMemHeap;
+
+}PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY_TAG
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_KERNEL_MEM_INFO  *psDstKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sDstClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sDstClientSyncInfo;
+
+}PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNMAP_DEV_MEMORY_TAG
+{
+        IMG_UINT32                                      ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO          *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO          sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO         sClientSyncInfo;        
+
+}PVRSRV_BRIDGE_IN_UNMAP_DEV_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MAP_EXT_MEMORY_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        IMG_SYS_PHYADDR                 *psSysPAddr;
+        IMG_UINT32                              ui32Flags;
+
+}PVRSRV_BRIDGE_IN_MAP_EXT_MEMORY;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNMAP_EXT_MEMORY_TAG
+{
+        IMG_UINT32                                      ui32BridgeFlags; 
+        PVRSRV_CLIENT_MEM_INFO          sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO         sClientSyncInfo;
+        IMG_UINT32                                      ui32Flags;
+
+}PVRSRV_BRIDGE_IN_UNMAP_EXT_MEMORY;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MAP_DEVICECLASS_MEMORY_TAG
+{
+        IMG_UINT32                                      ui32BridgeFlags; 
+        IMG_HANDLE              hDeviceClassBuffer;
+        IMG_HANDLE              hDevMemContext;
+
+}PVRSRV_BRIDGE_IN_MAP_DEVICECLASS_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY_TAG
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        IMG_HANDLE                              hMappingInfo;
+
+}PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNMAP_DEVICECLASS_MEMORY_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+}PVRSRV_BRIDGE_IN_UNMAP_DEVICECLASS_MEMORY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_MEMPOL_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        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_SYNCPOL_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+        IMG_BOOL bIsRead;
+        IMG_UINT32 ui32Value;
+        IMG_UINT32 ui32Mask;
+
+}PVRSRV_BRIDGE_IN_PDUMP_SYNCPOL;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_DUMPMEM_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_PVOID pvLinAddr;
+        IMG_PVOID pvAltLinAddr;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        IMG_UINT32 ui32Offset;
+        IMG_UINT32 ui32Bytes;
+        IMG_UINT32 ui32Flags;
+
+}PVRSRV_BRIDGE_IN_PDUMP_DUMPMEM;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_DUMPSYNC_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_PVOID pvAltLinAddr;
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+        IMG_UINT32 ui32Offset;
+        IMG_UINT32 ui32Bytes;
+
+}PVRSRV_BRIDGE_IN_PDUMP_DUMPSYNC;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_DUMPREG_TAG
+{
+        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_DUMPPDREG_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        PVRSRV_HWREG sHWReg;
+        IMG_UINT32 ui32Flags;
+
+}PVRSRV_BRIDGE_IN_PDUMP_DUMPPDREG;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_MEMPAGES_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hKernelMemInfo;
+        IMG_DEV_PHYADDR         *pPages;
+        IMG_UINT32                      ui32NumPages;
+        IMG_DEV_VIRTADDR        sDevAddr;
+        IMG_UINT32                      ui32Start;
+        IMG_UINT32                      ui32Length;
+        IMG_BOOL                        bContinuous;
+
+}PVRSRV_BRIDGE_IN_PDUMP_MEMPAGES;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_COMMENT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_CHAR szComment[PVRSRV_PDUMP_MAX_COMMENT_SIZE];
+        IMG_UINT32 ui32Flags;
+
+}PVRSRV_BRIDGE_IN_PDUMP_COMMENT;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_SETFRAME_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_UINT32 ui32Frame;
+
+}PVRSRV_BRIDGE_IN_PDUMP_SETFRAME;
+
+
+ 
+
+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;
+        IMG_UINT32 ui32Flags;
+
+}PVRSRV_BRIDGE_IN_PDUMP_BITMAP;
+
+
+ 
+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_IN_PDUMP_DRIVERINFO_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_CHAR szString[PVRSRV_PDUMP_MAX_COMMENT_SIZE];
+        IMG_BOOL bContinuous;
+
+}PVRSRV_BRIDGE_IN_PDUMP_DRIVERINFO;
+
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_DUMPPDDEVPADDR_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hKernelMemInfo;
+        IMG_UINT32 ui32Offset;
+        IMG_DEV_PHYADDR sPDDevPAddr;
+}PVRSRV_BRIDGE_IN_PDUMP_DUMPPDDEVPADDR;
+
+ 
+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;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ENUMDEVICE_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_UINT32 ui32NumDevices;
+        PVRSRV_DEVICE_IDENTIFIER asDeviceIdentifier[PVRSRV_MAX_DEVICES];
+
+}PVRSRV_BRIDGE_OUT_ENUMDEVICE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO_TAG
+{
+
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hDevCookie;
+
+} PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ENUMCLASS_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_UINT32 ui32NumDevices;
+        IMG_UINT32 ui32DevID[PVRSRV_MAX_DEVICES];
+
+}PVRSRV_BRIDGE_OUT_ENUMCLASS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_OPEN_DISPCLASS_DEVICE_TAG
+{
+        IMG_UINT32              ui32BridgeFlags; 
+        IMG_UINT32              ui32DeviceID;
+        IMG_HANDLE              hDevCookie;
+        
+}PVRSRV_BRIDGE_IN_OPEN_DISPCLASS_DEVICE;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_OPEN_DISPCLASS_DEVICE_TAG
+{
+        PVRSRV_ERROR    eError;
+        IMG_HANDLE              hDeviceKM;
+
+}PVRSRV_BRIDGE_OUT_OPEN_DISPCLASS_DEVICE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE              hDevCookie;
+        IMG_HANDLE                              hDevMemContext;
+        IMG_VOID                                *pvLinAddr;
+        IMG_SIZE_T              ui32ByteSize;
+        IMG_SIZE_T              ui32PageOffset;
+        IMG_BOOL                bPhysContig;
+        IMG_UINT32                              ui32NumPageTableEntries;
+        IMG_SYS_PHYADDR         *psSysPAddr;
+        IMG_UINT32                              ui32Flags;
+
+}PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY_TAG
+{
+        PVRSRV_ERROR    eError;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+}PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNWRAP_EXT_MEMORY_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+}PVRSRV_BRIDGE_IN_UNWRAP_EXT_MEMORY;
+
+
+#define PVRSRV_MAX_DC_DISPLAY_FORMATS                   10
+#define PVRSRV_MAX_DC_DISPLAY_DIMENSIONS                10
+#define PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS                 4
+#define PVRSRV_MAX_DC_CLIP_RECTS                                32
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_FORMATS_TAG
+{
+        PVRSRV_ERROR    eError;
+        IMG_UINT32              ui32Count;
+        DISPLAY_FORMAT  asFormat[PVRSRV_MAX_DC_DISPLAY_FORMATS];
+
+}PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_FORMATS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_DIMS_TAG
+{
+        IMG_UINT32              ui32BridgeFlags; 
+        IMG_HANDLE              hDeviceKM;
+        DISPLAY_FORMAT  sFormat;
+
+}PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_DIMS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_DIMS_TAG
+{
+        PVRSRV_ERROR    eError;
+        IMG_UINT32              ui32Count;
+        DISPLAY_DIMS    asDim[PVRSRV_MAX_DC_DISPLAY_DIMENSIONS];
+
+}PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_DIMS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_INFO_TAG
+{
+        PVRSRV_ERROR    eError;
+        DISPLAY_INFO    sDisplayInfo;
+
+}PVRSRV_BRIDGE_OUT_GET_DISPCLASS_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_SYSBUFFER_TAG
+{
+        PVRSRV_ERROR    eError;
+        IMG_HANDLE              hBuffer;
+
+}PVRSRV_BRIDGE_OUT_GET_DISPCLASS_SYSBUFFER;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_CREATE_DISPCLASS_SWAPCHAIN_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDeviceKM;
+        IMG_UINT32                              ui32Flags;
+        DISPLAY_SURF_ATTRIBUTES sDstSurfAttrib;
+        DISPLAY_SURF_ATTRIBUTES sSrcSurfAttrib;
+        IMG_UINT32                              ui32BufferCount;
+        IMG_UINT32                              ui32OEMFlags;
+        IMG_UINT32                              ui32SwapChainID;
+
+} PVRSRV_BRIDGE_IN_CREATE_DISPCLASS_SWAPCHAIN;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_CREATE_DISPCLASS_SWAPCHAIN_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hSwapChain;
+        IMG_UINT32                      ui32SwapChainID;
+
+} PVRSRV_BRIDGE_OUT_CREATE_DISPCLASS_SWAPCHAIN;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_DESTROY_DISPCLASS_SWAPCHAIN_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hSwapChain;
+
+} PVRSRV_BRIDGE_IN_DESTROY_DISPCLASS_SWAPCHAIN;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hSwapChain;
+        IMG_RECT                        sRect;
+
+} PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hSwapChain;
+        IMG_UINT32                      ui32CKColour;
+
+} PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_BUFFERS_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hSwapChain;
+
+} PVRSRV_BRIDGE_IN_GET_DISPCLASS_BUFFERS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_BUFFERS_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_UINT32                      ui32BufferCount;
+        IMG_HANDLE                      ahBuffer[PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS];
+
+} PVRSRV_BRIDGE_OUT_GET_DISPCLASS_BUFFERS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_BUFFER_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hBuffer;
+        IMG_UINT32                      ui32SwapInterval;
+        IMG_HANDLE                      hPrivateTag;
+        IMG_UINT32                      ui32ClipRectCount;
+        IMG_RECT                        sClipRect[PVRSRV_MAX_DC_CLIP_RECTS];
+
+} PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_BUFFER;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_SYSTEM_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_HANDLE                      hSwapChain;
+
+} PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_SYSTEM;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_OPEN_BUFFERCLASS_DEVICE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_UINT32                      ui32DeviceID;
+        IMG_HANDLE                      hDevCookie;
+        
+} PVRSRV_BRIDGE_IN_OPEN_BUFFERCLASS_DEVICE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_OPEN_BUFFERCLASS_DEVICE_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hDeviceKM;
+
+} PVRSRV_BRIDGE_OUT_OPEN_BUFFERCLASS_DEVICE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_INFO_TAG
+{
+        PVRSRV_ERROR            eError;
+        BUFFER_INFO                     sBufferInfo;
+
+} PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_BUFFER_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDeviceKM;
+        IMG_UINT32                      ui32BufferIndex;
+
+} PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_BUFFER;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_BUFFER_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hBuffer;
+
+} PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_BUFFER;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_DEVMEM_HEAPINFO_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_UINT32                      ui32ClientHeapCount;
+        PVRSRV_HEAP_INFO        sHeapInfo[PVRSRV_MAX_CLIENT_HEAPS];
+
+} PVRSRV_BRIDGE_OUT_GET_DEVMEM_HEAPINFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hDevMemContext;
+        IMG_UINT32                      ui32ClientHeapCount;
+        PVRSRV_HEAP_INFO        sHeapInfo[PVRSRV_MAX_CLIENT_HEAPS];
+
+} PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_CREATE_DEVMEMHEAP_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hDevMemHeap;
+
+} PVRSRV_BRIDGE_OUT_CREATE_DEVMEMHEAP;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM_TAG
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+
+} PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM_TAG
+{
+        PVRSRV_ERROR                    eError;
+        IMG_HANDLE                              hMemInfo;
+#if defined(SUPPORT_MEMINFO_IDS)
+        IMG_UINT64                              ui64Stamp;
+#endif
+
+} PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM;
+
+
+typedef struct PVRSRV_BRIDGE_OUT_MAPMEMINFOTOUSER_TAG
+{
+        PVRSRV_ERROR                    eError;
+        IMG_PVOID                               pvLinAddr;
+        IMG_HANDLE                              hMappingInfo;
+
+}PVRSRV_BRIDGE_OUT_MAPMEMINFOTOUSER;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_SIZE_T ui32Total;
+        IMG_SIZE_T ui32Free;
+        IMG_SIZE_T ui32LargestBlock;
+
+} PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM;
+
+
+#include "pvrmmap.h"
+typedef struct PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA_TAG
+{
+    PVRSRV_ERROR                eError;
+    
+    
+     IMG_UINT32                 ui32MMapOffset;
+
+    
+    IMG_UINT32                  ui32ByteOffset;
+
+    
+    IMG_UINT32                  ui32RealByteSize;
+
+    
+    IMG_UINT32                  ui32UserVAddr;
+
+} PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA;
+
+typedef struct PVRSRV_BRIDGE_OUT_RELEASE_MMAP_DATA_TAG
+{
+    PVRSRV_ERROR                eError;
+    
+    
+    IMG_BOOL                    bMUnmap;
+
+    
+    IMG_UINT32                  ui32UserVAddr;
+
+    
+    IMG_UINT32                  ui32RealByteSize;
+} PVRSRV_BRIDGE_OUT_RELEASE_MMAP_DATA;
+ 
+typedef struct PVRSRV_BRIDGE_IN_GET_MISC_INFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        PVRSRV_MISC_INFO        sMiscInfo;
+
+}PVRSRV_BRIDGE_IN_GET_MISC_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GET_MISC_INFO_TAG
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_MISC_INFO        sMiscInfo;
+
+}PVRSRV_BRIDGE_OUT_GET_MISC_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_RELEASE_MISC_INFO_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        PVRSRV_MISC_INFO        sMiscInfo;
+
+}PVRSRV_BRIDGE_IN_RELEASE_MISC_INFO;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_RELEASE_MISC_INFO_TAG
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_MISC_INFO        sMiscInfo;
+
+}PVRSRV_BRIDGE_OUT_RELEASE_MISC_INFO;
+
+
+ 
+
+typedef struct PVRSRV_BRIDGE_OUT_PDUMP_ISCAPTURING_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_BOOL bIsCapturing;
+
+} PVRSRV_BRIDGE_OUT_PDUMP_ISCAPTURING;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GET_FB_STATS_TAG 
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_SIZE_T ui32Total;
+        IMG_SIZE_T ui32Available;
+
+} PVRSRV_BRIDGE_IN_GET_FB_STATS;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_MAPPHYSTOUSERSPACE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_SYS_PHYADDR         sSysPhysAddr;
+        IMG_UINT32                      uiSizeInBytes;
+
+} PVRSRV_BRIDGE_IN_MAPPHYSTOUSERSPACE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_MAPPHYSTOUSERSPACE_TAG
+{
+        IMG_PVOID                       pvUserAddr;
+        IMG_UINT32                      uiActualSize;
+        IMG_PVOID                       pvProcess;
+
+} PVRSRV_BRIDGE_OUT_MAPPHYSTOUSERSPACE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_UNMAPPHYSTOUSERSPACE_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_PVOID                       pvUserAddr;
+        IMG_PVOID                       pvProcess;
+
+} PVRSRV_BRIDGE_IN_UNMAPPHYSTOUSERSPACE;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GETPHYSTOUSERSPACEMAP_TAG
+{
+        IMG_PVOID                       *ppvTbl;
+        IMG_UINT32                      uiTblSize;
+
+} PVRSRV_BRIDGE_OUT_GETPHYSTOUSERSPACEMAP;
+
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_REGISTER_SIM_PROCESS_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_PVOID                       pvProcess;
+
+} PVRSRV_BRIDGE_IN_REGISTER_SIM_PROCESS;
+
+
+typedef struct PVRSRV_BRIDGE_OUT_REGISTER_SIM_PROCESS_TAG
+{
+        IMG_SYS_PHYADDR         sRegsPhysBase;                  
+        IMG_VOID                        *pvRegsBase;                    
+        IMG_PVOID                       pvProcess;
+        IMG_UINT32                      ulNoOfEntries;
+        IMG_PVOID                       pvTblLinAddr;
+
+} PVRSRV_BRIDGE_OUT_REGISTER_SIM_PROCESS;
+
+
+typedef struct PVRSRV_BRIDGE_IN_UNREGISTER_SIM_PROCESS_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_PVOID                       pvProcess;
+        IMG_VOID                        *pvRegsBase;                    
+
+} PVRSRV_BRIDGE_IN_UNREGISTER_SIM_PROCESS;
+
+typedef struct PVRSRV_BRIDGE_IN_PROCESS_SIMISR_EVENT_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_UINT32                      ui32StatusAndMask;
+        PVRSRV_ERROR            eError;
+
+} PVRSRV_BRIDGE_IN_PROCESS_SIMISR_EVENT;
+
+typedef struct PVRSRV_BRIDGE_IN_INITSRV_DISCONNECT_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_BOOL                        bInitSuccesful;
+} PVRSRV_BRIDGE_IN_INITSRV_DISCONNECT;
+
+
+typedef struct PVRSRV_BRIDGE_IN_ALLOC_SHARED_SYS_MEM_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+    IMG_UINT32 ui32Flags;
+    IMG_SIZE_T ui32Size;
+}PVRSRV_BRIDGE_IN_ALLOC_SHARED_SYS_MEM;
+
+typedef struct PVRSRV_BRIDGE_OUT_ALLOC_SHARED_SYS_MEM_TAG
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+}PVRSRV_BRIDGE_OUT_ALLOC_SHARED_SYS_MEM;
+
+typedef struct PVRSRV_BRIDGE_IN_FREE_SHARED_SYS_MEM_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+}PVRSRV_BRIDGE_IN_FREE_SHARED_SYS_MEM;
+
+typedef struct PVRSRV_BRIDGE_OUT_FREE_SHARED_SYS_MEM_TAG
+{
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_FREE_SHARED_SYS_MEM;
+
+typedef struct PVRSRV_BRIDGE_IN_MAP_MEMINFO_MEM_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hKernelMemInfo;
+}PVRSRV_BRIDGE_IN_MAP_MEMINFO_MEM;
+
+typedef struct PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM_TAG
+{
+        PVRSRV_CLIENT_MEM_INFO  sClientMemInfo;
+        PVRSRV_CLIENT_SYNC_INFO sClientSyncInfo;
+        PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo;
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM;
+
+typedef struct PVRSRV_BRIDGE_IN_UNMAP_MEMINFO_MEM_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        PVRSRV_CLIENT_MEM_INFO sClientMemInfo;
+}PVRSRV_BRIDGE_IN_UNMAP_MEMINFO_MEM;
+
+typedef struct PVRSRV_BRIDGE_OUT_UNMAP_MEMINFO_MEM_TAG
+{
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_UNMAP_MEMINFO_MEM;
+
+typedef struct PVRSRV_BRIDGE_IN_GETMMU_PD_DEVPADDR_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+    IMG_HANDLE hDevMemContext;
+}PVRSRV_BRIDGE_IN_GETMMU_PD_DEVPADDR;
+
+typedef struct PVRSRV_BRIDGE_OUT_GETMMU_PD_DEVPADDR_TAG
+{
+    IMG_DEV_PHYADDR sPDDevPAddr;
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_GETMMU_PD_DEVPADDR;
+
+typedef struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_WAI_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE      hOSEventKM;
+} PVRSRV_BRIDGE_IN_EVENT_OBJECT_WAIT;
+
+typedef struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_OPEN_TAG
+{
+        PVRSRV_EVENTOBJECT sEventObject;
+} PVRSRV_BRIDGE_IN_EVENT_OBJECT_OPEN;
+
+typedef struct  PVRSRV_BRIDGE_OUT_EVENT_OBJECT_OPEN_TAG
+{
+        IMG_HANDLE hOSEvent;
+        PVRSRV_ERROR eError;
+} PVRSRV_BRIDGE_OUT_EVENT_OBJECT_OPEN;
+
+typedef struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_CLOSE_TAG
+{
+        PVRSRV_EVENTOBJECT sEventObject;
+        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;
+
+} PVRSRV_BRIDGE_IN_MODIFY_PENDING_SYNC_OPS;
+
+typedef struct PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hKernelSyncInfoModObj;
+} PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS;
+
+typedef struct PVRSRV_BRIDGE_OUT_MODIFY_PENDING_SYNC_OPS_TAG
+{
+        PVRSRV_ERROR eError;
+
+        
+        IMG_UINT32 ui32ReadOpsPending;
+        IMG_UINT32 ui32WriteOpsPending;
+
+} 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
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pvr_bridge_k.c b/drivers/gpu/pvr/pvr_bridge_k.c
new file mode 100644
index 00000000000..81a0201113b
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_bridge_k.c
@@ -0,0 +1,570 @@
+/**********************************************************************
+ *
+ * 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 "services.h"
+#include "pvr_bridge.h"
+#include "perproc.h"
+#include "mutex.h"
+#include "syscommon.h"
+#include "pvr_debug.h"
+#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)
+#include "vgx_bridge.h"
+#endif
+
+#if defined(SUPPORT_SGX)
+#include "sgx_bridge.h"
+#endif
+
+#include "bridged_pvr_bridge.h"
+
+#ifdef MODULE_TEST
+#include "pvr_test_bridge.h"
+#include "kern_test.h"
+#endif
+
+
+#if defined(SUPPORT_DRI_DRM)
+#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
+#else
+#define PRIVATE_DATA(pFile) ((pFile)->private_data)
+#endif
+
+#if defined(DEBUG_BRIDGE_KM)
+
+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);
+
+#endif
+
+extern PVRSRV_LINUX_MUTEX gPVRSRVLock;
+
+#if defined(SUPPORT_MEMINFO_IDS)
+static IMG_UINT64 ui64Stamp;
+#endif 
+
+PVRSRV_ERROR
+LinuxBridgeInit(IMG_VOID)
+{
+#if defined(DEBUG_BRIDGE_KM)
+        {
+                g_ProcBridgeStats = CreateProcReadEntrySeq(
+                                                                                                  "bridge_stats", 
+                                                                                                  NULL,
+                                                                                                  ProcSeqNextBridgeStats,
+                                                                                                  ProcSeqShowBridgeStats,
+                                                                                                  ProcSeqOff2ElementBridgeStats,
+                                                                                                  ProcSeqStartstopBridgeStats
+                                                                                                 );
+                if(!g_ProcBridgeStats)
+                {
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+        }
+#endif
+        return CommonBridgeInit();
+}
+
+IMG_VOID
+LinuxBridgeDeInit(IMG_VOID)
+{
+#if defined(DEBUG_BRIDGE_KM)
+    RemoveProcEntrySeq(g_ProcBridgeStats);
+#endif
+}
+
+#if defined(DEBUG_BRIDGE_KM)
+
+static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start) 
+{
+        if(start) 
+        {
+                LinuxLockMutex(&gPVRSRVLock);
+        }
+        else
+        {
+                LinuxUnLockMutex(&gPVRSRVLock);
+        }
+}
+
+
+static void* ProcSeqOff2ElementBridgeStats(struct seq_file *sfile, loff_t off)
+{
+        if(!off) 
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+        if(off > BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)
+        {
+                return (void*)0;
+        }
+
+
+        return (void*)&g_BridgeDispatchTable[off-1];
+}
+
+static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off)
+{
+        return ProcSeqOff2ElementBridgeStats(sfile,off);
+}
+
+
+static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el)
+{
+        PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY *psEntry = ( PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY*)el;
+
+        if(el == PVR_PROC_SEQ_START_TOKEN) 
+        {
+                seq_printf(sfile,
+                                                  "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,
+                                                  g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
+                                                  g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
+                                                  "Bridge Name",
+                                                  "Wrapper Function",
+                                                  "Call Count",
+                                                  "copy_from_user Bytes",
+                                                  "copy_to_user Bytes"
+                                                 );
+                return;
+        }
+
+        seq_printf(sfile,
+                                   "%-45s   %-40s   %-10u   %-20u   %-10u\n",
+                                   psEntry->pszIOCName,
+                                   psEntry->pszFunctionName,
+                                   psEntry->ui32CallCount,
+                                   psEntry->ui32CopyFromUserTotalBytes,
+                                   psEntry->ui32CopyToUserTotalBytes);
+}
+
+#endif 
+
+
+#if defined(SUPPORT_DRI_DRM)
+IMG_INT
+PVRSRV_BridgeDispatchKM(struct drm_device *dev, IMG_VOID *arg, struct drm_file *pFile)
+#else
+IMG_INT32
+PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT unref__ ioctlCmd, IMG_UINT32 arg)
+#endif
+{
+        IMG_UINT32 cmd;
+#if !defined(SUPPORT_DRI_DRM)
+        PVRSRV_BRIDGE_PACKAGE *psBridgePackageUM = (PVRSRV_BRIDGE_PACKAGE *)arg;
+        PVRSRV_BRIDGE_PACKAGE sBridgePackageKM;
+#endif
+        PVRSRV_BRIDGE_PACKAGE *psBridgePackageKM;
+        IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
+        PVRSRV_PER_PROCESS_DATA *psPerProc;
+        IMG_INT err = -EFAULT;
+
+        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,
+                                   psBridgePackageUM,
+                                   sizeof(PVRSRV_BRIDGE_PACKAGE)))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: Received invalid pointer to function arguments",
+                                 __FUNCTION__));
+
+                goto unlock_and_return;
+        }
+        
+        
+        if(OSCopyFromUser(IMG_NULL,
+                                          psBridgePackageKM,
+                                          psBridgePackageUM,
+                                          sizeof(PVRSRV_BRIDGE_PACKAGE))
+          != PVRSRV_OK)
+        {
+                goto unlock_and_return;
+        }
+#endif
+
+        cmd = psBridgePackageKM->ui32BridgeID;
+
+#if defined(MODULE_TEST)
+        switch (cmd)
+        {
+                case PVRSRV_BRIDGE_SERVICES_TEST_MEM1:
+                        {
+                                PVRSRV_ERROR eError = MemTest1();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+                case PVRSRV_BRIDGE_SERVICES_TEST_MEM2:
+                        {
+                                PVRSRV_ERROR eError = MemTest2();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_RESOURCE:
+                        {
+                                PVRSRV_ERROR eError = ResourceTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_EVENTOBJECT:
+                        {
+                                PVRSRV_ERROR eError = EventObjectTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_MEMMAPPING:
+                        {
+                                PVRSRV_ERROR eError = MemMappingTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_PROCESSID:
+                        {
+                                PVRSRV_ERROR eError = ProcessIDTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_CLOCKUSWAITUS:
+                        {
+                                PVRSRV_ERROR eError = ClockusWaitusTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_TIMER:
+                        {
+                                PVRSRV_ERROR eError = TimerTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_PRIVSRV:
+                        {
+                                PVRSRV_ERROR eError = PrivSrvTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+                case PVRSRV_BRIDGE_SERVICES_TEST_COPYDATA:
+                {
+                        IMG_UINT32               ui32PID;
+                        PVRSRV_PER_PROCESS_DATA *psPerProc;
+                        PVRSRV_ERROR eError;
+                        
+                        ui32PID = OSGetCurrentProcessIDKM();
+                
+                        PVRSRVTrace("PVRSRV_BRIDGE_SERVICES_TEST_COPYDATA %d", ui32PID);
+                        
+                        psPerProc = PVRSRVPerProcessData(ui32PID);
+                                                
+                        eError = CopyDataTest(psBridgePackageKM->pvParamIn, psBridgePackageKM->pvParamOut, psPerProc);
+                        
+                        *(PVRSRV_ERROR*)psBridgePackageKM->pvParamOut = eError;
+                        err = 0;
+                        goto unlock_and_return;
+                }
+
+
+                case PVRSRV_BRIDGE_SERVICES_TEST_POWERMGMT:
+                        {
+                                PVRSRV_ERROR eError = PowerMgmtTest();
+                                if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
+                                {
+                                        PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
+                                        pReturn->eError = eError;
+                                }
+                        }
+                        err = 0;
+                        goto unlock_and_return;
+
+        }
+#endif
+        
+        if(cmd != PVRSRV_BRIDGE_CONNECT_SERVICES)
+        {
+                PVRSRV_ERROR eError;
+
+                eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
+                                                                        (IMG_PVOID *)&psPerProc,
+                                                                        psBridgePackageKM->hKernelServices,
+                                                                        PVRSRV_HANDLE_TYPE_PERPROC_DATA);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "%s: Invalid kernel services handle (%d)",
+                                         __FUNCTION__, eError));
+                        goto unlock_and_return;
+                }
+
+                if(psPerProc->ui32PID != ui32PID)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "%s: Process %d tried to access data "
+                                         "belonging to process %d", __FUNCTION__, ui32PID,
+                                         psPerProc->ui32PID));
+                        goto unlock_and_return;
+                }
+        }
+        else
+        {
+                
+                psPerProc = PVRSRVPerProcessData(ui32PID);
+                if(psPerProc == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BridgeDispatchKM: "
+                                         "Couldn't create per-process data area"));
+                        goto unlock_and_return;
+                }
+        }
+
+        psBridgePackageKM->ui32BridgeID = PVRSRV_GET_BRIDGE_ID(psBridgePackageKM->ui32BridgeID);
+
+#if defined(PVR_SECURE_FD_EXPORT)
+        switch(cmd)
+        {
+                case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
+                {
+                        PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+
+                        if(psPrivateData->hKernelMemInfo)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: Can only export one MemInfo "
+                                                 "per file descriptor", __FUNCTION__));
+                                err = -EINVAL;
+                                goto unlock_and_return;
+                        }
+                        break;
+                }
+
+                case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
+                {
+                        PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN =
+                                (PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamIn;
+                        PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+
+                        if(!psPrivateData->hKernelMemInfo)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: File descriptor has no "
+                                                 "associated MemInfo handle", __FUNCTION__));
+                                err = -EINVAL;
+                                goto unlock_and_return;
+                        }
+
+                        psMapDevMemIN->hKernelMemInfo = psPrivateData->hKernelMemInfo;
+                        break;
+                }
+
+                default:
+                {
+                        PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+
+                        if(psPrivateData->hKernelMemInfo)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "%s: Import/Export handle tried "
+                                                 "to use privileged service", __FUNCTION__));
+                                goto unlock_and_return;
+                        }
+                        break;
+                }
+        }
+#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)
+                goto unlock_and_return;
+
+        switch(cmd)
+        {
+#if defined(PVR_SECURE_FD_EXPORT)
+                case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
+                {
+                        PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT =
+                                (PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)psBridgePackageKM->pvParamOut;
+                        PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+
+                        psPrivateData->hKernelMemInfo = psExportDeviceMemOUT->hMemInfo;
+#if defined(SUPPORT_MEMINFO_IDS)
+                        psExportDeviceMemOUT->ui64Stamp = psPrivateData->ui64Stamp = ++ui64Stamp;
+#endif
+                        break;
+                }
+#endif 
+
+#if defined(SUPPORT_MEMINFO_IDS)
+                case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
+                {
+                        PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDeviceMemoryOUT =
+                                (PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamOut;
+                        PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
+                        psMapDeviceMemoryOUT->sDstClientMemInfo.ui64Stamp =     psPrivateData->ui64Stamp;
+                        break;
+                }
+
+                case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
+                {
+                        PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psDeviceClassMemoryOUT =
+                                (PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *)psBridgePackageKM->pvParamOut;
+                        psDeviceClassMemoryOUT->sClientMemInfo.ui64Stamp = ++ui64Stamp;
+                        break;
+                }
+#endif 
+
+                default:
+                        break;
+        }
+
+unlock_and_return:
+        LinuxUnLockMutex(&gPVRSRVLock);
+        return err;
+}
diff --git a/drivers/gpu/pvr/pvr_bridge_km.h b/drivers/gpu/pvr/pvr_bridge_km.h
new file mode 100644
index 00000000000..d5592c2ecf5
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_bridge_km.h
@@ -0,0 +1,285 @@
+/**********************************************************************
+ *
+ * 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_BRIDGE_KM_H_
+#define __PVR_BRIDGE_KM_H_
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "pvr_bridge.h"
+#include "perproc.h"
+
+#if defined(__linux__)
+PVRSRV_ERROR LinuxBridgeInit(IMG_VOID);
+IMG_VOID LinuxBridgeDeInit(IMG_VOID);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevicesKM(IMG_UINT32 *pui32NumDevices,
+                                                                                                   PVRSRV_DEVICE_IDENTIFIER *psDevIdList);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAcquireDeviceDataKM(IMG_UINT32                  uiDevIndex,
+                                                                                                        PVRSRV_DEVICE_TYPE      eDeviceType,
+                                                                                                        IMG_HANDLE                      *phDevCookie);
+                                                        
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_SIZE_T ui32QueueSize,
+                                                                                                         PVRSRV_QUEUE_INFO **ppsQueueInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueueInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapsKM(IMG_HANDLE hDevCookie,
+                                                                                                        PVRSRV_HEAP_INFO *psHeapInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDeviceMemContextKM(IMG_HANDLE                                     hDevCookie,
+                                                                                                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                                                                                                 IMG_HANDLE                                     *phDevMemContext,
+                                                                                                                 IMG_UINT32                                     *pui32ClientHeapCount,
+                                                                                                                 PVRSRV_HEAP_INFO                       *psHeapInfo,
+                                                                                                                 IMG_BOOL                                       *pbCreated,
+                                                                                                                 IMG_BOOL                                       *pbShared);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDeviceMemContextKM(IMG_HANDLE hDevCookie,
+                                                                                                                  IMG_HANDLE hDevMemContext,
+                                                                                                                  IMG_BOOL *pbDestroyed);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfoKM(IMG_HANDLE                               hDevCookie,
+                                                                                                                        IMG_HANDLE                      hDevMemContext,
+                                                                                                                        IMG_UINT32                      *pui32ClientHeapCount,
+                                                                                                                        PVRSRV_HEAP_INFO        *psHeapInfo,
+                                                                                                                        IMG_BOOL                        *pbShared
+                                        );
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV _PVRSRVAllocDeviceMemKM(IMG_HANDLE                                    hDevCookie,
+                                                                                                 PVRSRV_PER_PROCESS_DATA        *psPerProc,
+                                                                                                 IMG_HANDLE                                     hDevMemHeap,
+                                                                                                 IMG_UINT32                                     ui32Flags,
+                                                                                                 IMG_SIZE_T                                     ui32Size,
+                                                                                                 IMG_SIZE_T                                     ui32Alignment,
+                                                                                                 PVRSRV_KERNEL_MEM_INFO         **ppsMemInfo);
+
+
+#if defined(PVRSRV_LOG_MEMORY_ALLOCS)
+        #define PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo, logStr) \
+                (PVR_TRACE(("PVRSRVAllocDeviceMemKM(" #devCookie ", " #perProc ", " #devMemHeap ", " #flags ", " #size \
+                        ", " #alignment "," #memInfo "): " logStr " (size = 0x%;x)", size)),\
+                        _PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo))
+#else
+        #define PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo, logStr) \
+                        _PVRSRVAllocDeviceMemKM(devCookie, perProc, devMemHeap, flags, size, alignment, memInfo)
+#endif
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE                      hDevCookie,
+                                                                                                PVRSRV_KERNEL_MEM_INFO  *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDissociateDeviceMemKM(IMG_HANDLE                        hDevCookie,
+                                                                                                PVRSRV_KERNEL_MEM_INFO  *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReserveDeviceVirtualMemKM(IMG_HANDLE            hDevMemHeap,
+                                                                                                                 IMG_DEV_VIRTADDR       *psDevVAddr,
+                                                                                                                 IMG_SIZE_T                     ui32Size,
+                                                                                                                 IMG_SIZE_T                     ui32Alignment,
+                                                                                                                 PVRSRV_KERNEL_MEM_INFO **ppsMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceVirtualMemKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemoryKM(PVRSRV_PER_PROCESS_DATA       *psPerProc,
+                                                                                                  PVRSRV_KERNEL_MEM_INFO        *psSrcMemInfo,
+                                                                                                  IMG_HANDLE                            hDstDevMemHeap,
+                                                                                                  PVRSRV_KERNEL_MEM_INFO        **ppsDstMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceMemoryKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemoryKM(IMG_HANDLE                              hDevCookie,
+                                                                                                PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                                                                                IMG_HANDLE                              hDevMemContext,
+                                                                                                IMG_SIZE_T                              ui32ByteSize, 
+                                                                                                IMG_SIZE_T                              ui32PageOffset,
+                                                                                                IMG_BOOL                                bPhysContig,
+                                                                                                IMG_SYS_PHYADDR                 *psSysAddr,
+                                                                                                IMG_VOID                                *pvLinAddr,
+                                                                                                IMG_UINT32                              ui32Flags,
+                                                                                                PVRSRV_KERNEL_MEM_INFO **ppsMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnwrapExtMemoryKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVEnumerateDCKM(PVRSRV_DEVICE_CLASS DeviceClass,
+                                                                 IMG_UINT32 *pui32DevCount,
+                                                                 IMG_UINT32 *pui32DevID );
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVOpenDCDeviceKM(PVRSRV_PER_PROCESS_DATA       *psPerProc,
+                                                                  IMG_UINT32                            ui32DeviceID,
+                                                                  IMG_HANDLE                            hDevCookie,
+                                                                  IMG_HANDLE                            *phDeviceKM);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVCloseDCDeviceKM(IMG_HANDLE hDeviceKM, IMG_BOOL bResManCallback);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVEnumDCFormatsKM(IMG_HANDLE hDeviceKM,
+                                                                   IMG_UINT32 *pui32Count,
+                                                                   DISPLAY_FORMAT *psFormat);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVEnumDCDimsKM(IMG_HANDLE hDeviceKM,
+                                                                DISPLAY_FORMAT *psFormat,
+                                                                IMG_UINT32 *pui32Count,
+                                                                DISPLAY_DIMS *psDim);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVGetDCSystemBufferKM(IMG_HANDLE hDeviceKM,
+                                                                           IMG_HANDLE *phBuffer);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVGetDCInfoKM(IMG_HANDLE hDeviceKM,
+                                                           DISPLAY_INFO *psDisplayInfo);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVCreateDCSwapChainKM(PVRSRV_PER_PROCESS_DATA  *psPerProc,
+                                                                           IMG_HANDLE                           hDeviceKM,
+                                                                           IMG_UINT32                           ui32Flags,
+                                                                           DISPLAY_SURF_ATTRIBUTES      *psDstSurfAttrib,
+                                                                           DISPLAY_SURF_ATTRIBUTES      *psSrcSurfAttrib,
+                                                                           IMG_UINT32                           ui32BufferCount,
+                                                                           IMG_UINT32                           ui32OEMFlags,
+                                                                           IMG_HANDLE                           *phSwapChain,
+                                                                           IMG_UINT32                           *pui32SwapChainID);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(IMG_HANDLE      hSwapChain);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetDCDstRectKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChain,
+                                                                  IMG_RECT      *psRect);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetDCSrcRectKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChain,
+                                                                  IMG_RECT      *psRect);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetDCDstColourKeyKM(IMG_HANDLE       hDeviceKM,
+                                                                           IMG_HANDLE   hSwapChain,
+                                                                           IMG_UINT32   ui32CKColour);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSetDCSrcColourKeyKM(IMG_HANDLE       hDeviceKM,
+                                                                        IMG_HANDLE              hSwapChain,
+                                                                        IMG_UINT32              ui32CKColour);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVGetDCBuffersKM(IMG_HANDLE    hDeviceKM,
+                                                                  IMG_HANDLE    hSwapChain,
+                                                                  IMG_UINT32    *pui32BufferCount,
+                                                                  IMG_HANDLE    *phBuffer);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSwapToDCBufferKM(IMG_HANDLE  hDeviceKM,
+                                                                        IMG_HANDLE      hBuffer,
+                                                                        IMG_UINT32      ui32SwapInterval,
+                                                                        IMG_HANDLE      hPrivateTag,
+                                                                        IMG_UINT32      ui32ClipRectCount,
+                                                                        IMG_RECT        *psClipRect);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVSwapToDCSystemKM(IMG_HANDLE  hDeviceKM,
+                                                                        IMG_HANDLE      hSwapChain);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVOpenBCDeviceKM(PVRSRV_PER_PROCESS_DATA       *psPerProc,
+                                                                  IMG_UINT32                            ui32DeviceID,
+                                                                  IMG_HANDLE                            hDevCookie,
+                                                                  IMG_HANDLE                            *phDeviceKM);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVCloseBCDeviceKM(IMG_HANDLE hDeviceKM, IMG_BOOL bResManCallback);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVGetBCInfoKM(IMG_HANDLE       hDeviceKM,
+                                                           BUFFER_INFO  *psBufferInfo);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVGetBCBufferKM(IMG_HANDLE     hDeviceKM,
+                                                                 IMG_UINT32     ui32BufferIndex,
+                                                                 IMG_HANDLE     *phBuffer);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemoryKM(PVRSRV_PER_PROCESS_DATA  *psPerProc,
+                                                                                                           IMG_HANDLE                           hDevMemContext,
+                                                                                                           IMG_HANDLE                           hDeviceClassBuffer,
+                                                                                                           PVRSRV_KERNEL_MEM_INFO       **ppsMemInfo,
+                                                                                                           IMG_HANDLE                           *phOSMapInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceClassMemoryKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetFreeDeviceMemKM(IMG_UINT32 ui32Flags,
+                                                                                                   IMG_SIZE_T *pui32Total,
+                                                                                                   IMG_SIZE_T *pui32Free,
+                                                                                                   IMG_SIZE_T *pui32LargestBlock);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfoKM(IMG_HANDLE                                      hDevCookie,
+                                                                                                IMG_HANDLE                                      hDevMemContext,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO **ppsKernelSyncInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfoKM(PVRSRV_KERNEL_SYNC_INFO  *psKernelSyncInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfoKM(PVRSRV_MISC_INFO *psMiscInfo);
+
+IMG_IMPORT PVRSRV_ERROR
+PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA    *psPerProc,
+                                                         IMG_UINT32                             ui32Flags,
+                                                         IMG_SIZE_T                             ui32Size,
+                                                         PVRSRV_KERNEL_MEM_INFO         **ppsKernelMemInfo);
+
+IMG_IMPORT PVRSRV_ERROR
+PVRSRVFreeSharedSysMemoryKM(PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo);
+
+IMG_IMPORT PVRSRV_ERROR
+PVRSRVDissociateMemFromResmanKM(PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pvr_debug.c b/drivers/gpu/pvr/pvr_debug.c
new file mode 100644
index 00000000000..091f6590e70
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_debug.c
@@ -0,0 +1,420 @@
+/**********************************************************************
+ *
+ * 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 <asm/io.h>
+#include <asm/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/hardirq.h>
+#include <linux/module.h>
+#include <linux/spinlock.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_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 
+
+#define PVR_MAX_MSG_LEN PVR_MAX_DEBUG_MESSAGE_LEN
+
+static IMG_CHAR gszBufferNonIRQ[PVR_MAX_MSG_LEN + 1];
+
+static IMG_CHAR gszBufferIRQ[PVR_MAX_MSG_LEN + 1];
+
+static PVRSRV_LINUX_MUTEX gsDebugMutexNonIRQ;
+
+ 
+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)
+{
+        if (USE_SPIN_LOCK)
+        {
+                spin_lock_irqsave(&gsDebugLockIRQ, *pulLockFlags);
+        }
+        else
+        {
+                LinuxLockMutex(&gsDebugMutexNonIRQ);
+        }
+}
+
+static inline void ReleaseBufferLock(unsigned long ulLockFlags)
+{
+        if (USE_SPIN_LOCK)
+        {
+                spin_unlock_irqrestore(&gsDebugLockIRQ, ulLockFlags);
+        }
+        else
+        {
+                LinuxUnLockMutex(&gsDebugMutexNonIRQ);
+        }
+}
+
+static inline void SelectBuffer(IMG_CHAR **ppszBuf, IMG_UINT32 *pui32BufSiz)
+{
+        if (USE_SPIN_LOCK)
+        {
+                *ppszBuf = gszBufferIRQ;
+                *pui32BufSiz = sizeof(gszBufferIRQ);
+        }
+        else
+        {
+                *ppszBuf = gszBufferNonIRQ;
+                *pui32BufSiz = sizeof(gszBufferNonIRQ);
+        }
+}
+
+static IMG_BOOL VBAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR* pszFormat, va_list VArgs)
+{
+        IMG_UINT32 ui32Used;
+        IMG_UINT32 ui32Space;
+        IMG_INT32 i32Len;
+
+        ui32Used = strlen(pszBuf);
+        BUG_ON(ui32Used >= ui32BufSiz);
+        ui32Space = ui32BufSiz - ui32Used;
+
+        i32Len = vsnprintf(&pszBuf[ui32Used], ui32Space, pszFormat, VArgs);
+        pszBuf[ui32BufSiz - 1] = 0;
+
+        
+        return (i32Len < 0 || i32Len >= (IMG_INT32)ui32Space) ? IMG_TRUE : IMG_FALSE;
+}
+
+IMG_VOID PVRDPFInit(IMG_VOID)
+{
+    LinuxInitMutex(&gsDebugMutexNonIRQ);
+}
+
+IMG_VOID PVRSRVReleasePrintf(const IMG_CHAR *pszFormat, ...)
+{
+        va_list vaArgs;
+        unsigned long ulLockFlags = 0;
+        IMG_CHAR *pszBuf;
+        IMG_UINT32 ui32BufSiz;
+
+        SelectBuffer(&pszBuf, &ui32BufSiz);
+
+        va_start(vaArgs, pszFormat);
+
+        GetBufferLock(&ulLockFlags);
+        strncpy (pszBuf, "PVR_K: ", (ui32BufSiz -1));
+
+        if (VBAppend(pszBuf, ui32BufSiz, pszFormat, vaArgs))
+        {
+                printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+        }
+        else
+        {
+                printk(KERN_INFO "%s\n", pszBuf);
+        }
+
+        ReleaseBufferLock(ulLockFlags);
+        va_end(vaArgs);
+
+}
+
+#if defined(PVRSRV_NEED_PVR_ASSERT)
+
+IMG_VOID PVRSRVDebugAssertFail(const IMG_CHAR* pszFile, IMG_UINT32 uLine)
+{
+        PVRSRVDebugPrintf(DBGPRIV_FATAL, pszFile, uLine, "Debug assertion failed!");
+        BUG();
+}
+
+#endif 
+
+#if defined(PVRSRV_NEED_PVR_TRACE)
+
+IMG_VOID PVRSRVTrace(const IMG_CHAR* pszFormat, ...)
+{
+        va_list VArgs;
+        unsigned long ulLockFlags = 0;
+        IMG_CHAR *pszBuf;
+        IMG_UINT32 ui32BufSiz;
+
+        SelectBuffer(&pszBuf, &ui32BufSiz);
+
+        va_start(VArgs, pszFormat);
+
+        GetBufferLock(&ulLockFlags);
+
+        strncpy(pszBuf, "PVR: ", (ui32BufSiz -1));
+
+        if (VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs))
+        {
+                printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+        }
+        else
+        {
+                printk(KERN_INFO "%s\n", pszBuf);
+        }
+
+        ReleaseBufferLock(ulLockFlags);
+
+        va_end(VArgs);
+}
+
+#endif 
+
+#if defined(PVRSRV_NEED_PVR_DPF)
+
+static IMG_BOOL BAppend(IMG_CHAR *pszBuf, IMG_UINT32 ui32BufSiz, const IMG_CHAR *pszFormat, ...)
+{
+        va_list VArgs;
+        IMG_BOOL bTrunc;
+
+        va_start (VArgs, pszFormat);
+
+        bTrunc = VBAppend(pszBuf, ui32BufSiz, pszFormat, VArgs);
+
+        va_end (VArgs);
+
+        return bTrunc;
+}
+
+IMG_VOID PVRSRVDebugPrintf      (
+                                                IMG_UINT32      ui32DebugLevel,
+                                                const IMG_CHAR* pszFullFileName,
+                                                IMG_UINT32      ui32Line,
+                                                const IMG_CHAR* pszFormat,
+                                                ...
+                                        )
+{
+        IMG_BOOL bTrace;
+        const IMG_CHAR *pszFileName = pszFullFileName;
+        IMG_CHAR *pszLeafName;
+
+
+        bTrace = (IMG_BOOL)(ui32DebugLevel & DBGPRIV_CALLTRACE) ? IMG_TRUE : IMG_FALSE;
+
+        if (gPVRDebugLevel & ui32DebugLevel)
+        {
+                va_list vaArgs;
+                unsigned long ulLockFlags = 0;
+                IMG_CHAR *pszBuf;
+                IMG_UINT32 ui32BufSiz;
+
+                SelectBuffer(&pszBuf, &ui32BufSiz);
+
+                va_start(vaArgs, pszFormat);
+
+                GetBufferLock(&ulLockFlags);
+
+                
+                if (bTrace == IMG_FALSE)
+                {
+                        switch(ui32DebugLevel)
+                        {
+                                case DBGPRIV_FATAL:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Fatal): ", (ui32BufSiz -1));
+                                        break;
+                                }
+                                case DBGPRIV_ERROR:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Error): ", (ui32BufSiz -1));
+                                        break;
+                                }
+                                case DBGPRIV_WARNING:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Warning): ", (ui32BufSiz -1));
+                                        break;
+                                }
+                                case DBGPRIV_MESSAGE:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Message): ", (ui32BufSiz -1));
+                                        break;
+                                }
+                                case DBGPRIV_VERBOSE:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Verbose): ", (ui32BufSiz -1));
+                                        break;
+                                }
+                                default:
+                                {
+                                        strncpy (pszBuf, "PVR_K:(Unknown message level)", (ui32BufSiz -1));
+                                        break;
+                                }
+                        }
+                }
+                else
+                {
+                        strncpy (pszBuf, "PVR_K: ", (ui32BufSiz -1));
+                }
+
+                if (VBAppend(pszBuf, ui32BufSiz, pszFormat, vaArgs))
+                {
+                        printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+                }
+                else
+                {
+                        
+                        if (bTrace == IMG_FALSE)
+                        {
+#ifdef DEBUG_LOG_PATH_TRUNCATE
+                                
+                                static IMG_CHAR szFileNameRewrite[PVR_MAX_FILEPATH_LEN];
+
+                                IMG_CHAR* pszTruncIter;
+                                IMG_CHAR* pszTruncBackInter;
+
+                                
+                                pszFileName = pszFullFileName + strlen(DEBUG_LOG_PATH_TRUNCATE)+1;
+
+                                
+                                strncpy(szFileNameRewrite, pszFileName,PVR_MAX_FILEPATH_LEN);
+
+                                if(strlen(szFileNameRewrite) == PVR_MAX_FILEPATH_LEN-1) {
+                                        IMG_CHAR szTruncateMassage[] = "FILENAME TRUNCATED";
+                                        strcpy(szFileNameRewrite + (PVR_MAX_FILEPATH_LEN - 1 - strlen(szTruncateMassage)), szTruncateMassage);
+                                }
+
+                                pszTruncIter = szFileNameRewrite;
+                                while(*pszTruncIter++ != 0)
+                                {
+                                        IMG_CHAR* pszNextStartPoint;
+                                        
+                                        if(
+                                           !( ( *pszTruncIter == '/' && (pszTruncIter-4 >= szFileNameRewrite) ) &&
+                                                 ( *(pszTruncIter-1) == '.') &&
+                                                 ( *(pszTruncIter-2) == '.') &&
+                                                 ( *(pszTruncIter-3) == '/') )
+                                           ) continue;
+
+                                        
+                                        pszTruncBackInter = pszTruncIter - 3;
+                                        while(*(--pszTruncBackInter) != '/')
+                                        {
+                                                if(pszTruncBackInter <= szFileNameRewrite) break;
+                                        }
+                                        pszNextStartPoint = pszTruncBackInter;
+
+                                        
+                                        while(*pszTruncIter != 0)
+                                        {
+                                                *pszTruncBackInter++ = *pszTruncIter++;
+                                        }
+                                        *pszTruncBackInter = 0;
+
+                                        
+                                        pszTruncIter = pszNextStartPoint;
+                                }
+
+                                pszFileName = szFileNameRewrite;
+                                
+                                if(*pszFileName == '/') pszFileName++;
+#endif
+
+#if !defined(__sh__)
+                                pszLeafName = (IMG_CHAR *)strrchr (pszFileName, '\\');
+
+                                if (pszLeafName)
+                                {
+                                        pszFileName = pszLeafName;
+                        }
+#endif 
+
+                                if (BAppend(pszBuf, ui32BufSiz, " [%u, %s]", ui32Line, pszFileName))
+                                {
+                                        printk(KERN_INFO "PVR_K:(Message Truncated): %s\n", pszBuf);
+                                }
+                                else
+                                {
+                                        printk(KERN_INFO "%s\n", pszBuf);
+                                }
+                        }
+                        else
+                        {
+                                printk(KERN_INFO "%s\n", pszBuf);
+                        }
+                }
+
+                ReleaseBufferLock(ulLockFlags);
+
+                va_end (vaArgs);
+        }
+}
+
+#endif 
+
+#if defined(DEBUG)
+
+IMG_INT PVRDebugProcSetLevel(struct file *file, const IMG_CHAR *buffer, IMG_UINT32 count, IMG_VOID *data)
+{
+#define _PROC_SET_BUFFER_SZ             2
+        IMG_CHAR data_buffer[_PROC_SET_BUFFER_SZ];
+
+        if (count != _PROC_SET_BUFFER_SZ)
+        {
+                return -EINVAL;
+        }
+        else
+        {
+                if (pvr_copy_from_user(data_buffer, buffer, count))
+                        return -EINVAL;
+                if (data_buffer[count - 1] != '\n')
+                        return -EINVAL;
+                gPVRDebugLevel = data_buffer[0] - '0';
+        }
+        return (count);
+}
+
+void ProcSeqShowDebugLevel(struct seq_file *sfile,void* el)
+{
+        seq_printf(sfile, "%u\n", gPVRDebugLevel);
+}
+
+#endif 
diff --git a/drivers/gpu/pvr/pvr_debug.h b/drivers/gpu/pvr/pvr_debug.h
new file mode 100644
index 00000000000..21fa2cdfbe3
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_debug.h
@@ -0,0 +1,133 @@
+/**********************************************************************
+ *
+ * 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_DEBUG_H__
+#define __PVR_DEBUG_H__
+
+
+#include "img_types.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define PVR_MAX_DEBUG_MESSAGE_LEN       (512)
+
+#define DBGPRIV_FATAL           0x01UL
+#define DBGPRIV_ERROR           0x02UL
+#define DBGPRIV_WARNING         0x04UL
+#define DBGPRIV_MESSAGE         0x08UL
+#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_FATAL           DBGPRIV_FATAL,__FILE__, __LINE__
+#define PVR_DBG_ERROR           DBGPRIV_ERROR,__FILE__, __LINE__
+#define PVR_DBG_WARNING         DBGPRIV_WARNING,__FILE__, __LINE__
+#define PVR_DBG_MESSAGE         DBGPRIV_MESSAGE,__FILE__, __LINE__
+#define PVR_DBG_VERBOSE         DBGPRIV_VERBOSE,__FILE__, __LINE__
+#define PVR_DBG_CALLTRACE       DBGPRIV_CALLTRACE,__FILE__, __LINE__
+#define PVR_DBG_ALLOC           DBGPRIV_ALLOC,__FILE__, __LINE__
+
+#define PVR_DBGDRIV_MESSAGE             DBGPRIV_DBGDRV_MESSAGE, "", 0
+
+#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)
+
+        #define PVR_ASSERT(EXPR) if (!(EXPR)) PVRSRVDebugAssertFail(__FILE__, __LINE__);
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVDebugAssertFail(const IMG_CHAR *pszFile,
+                                                                                                           IMG_UINT32 ui32Line);
+
+                        #if defined(PVR_DBG_BREAK_ASSERT_FAIL)
+                                #define PVR_DBG_BREAK   PVRSRVDebugAssertFail("PVR_DBG_BREAK", 0)
+                        #else
+                                #define PVR_DBG_BREAK
+                        #endif
+
+#else  
+
+        #define PVR_ASSERT(EXPR)
+        #define PVR_DBG_BREAK
+
+#endif 
+
+
+#if defined(PVRSRV_NEED_PVR_DPF)
+
+        #define PVR_DPF(X)              PVRSRVDebugPrintf X
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVDebugPrintf(IMG_UINT32 ui32DebugLevel,
+                                                                                                   const IMG_CHAR *pszFileName,
+                                                                                                   IMG_UINT32 ui32Line,
+                                                                                                   const IMG_CHAR *pszFormat,
+                                                                                                   ...) IMG_FORMAT_PRINTF(4, 5);
+
+#else  
+
+        #define PVR_DPF(X)
+
+#endif 
+
+
+#if defined(PVRSRV_NEED_PVR_TRACE)
+
+        #define PVR_TRACE(X)    PVRSRVTrace X
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVTrace(const IMG_CHAR* pszFormat, ... )
+        IMG_FORMAT_PRINTF(1, 2);
+
+#else 
+
+        #define PVR_TRACE(X)
+
+#endif 
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif  
+
diff --git a/drivers/gpu/pvr/pvr_uaccess.h b/drivers/gpu/pvr/pvr_uaccess.h
new file mode 100644
index 00000000000..04fdcc2211a
--- /dev/null
+++ b/drivers/gpu/pvr/pvr_uaccess.h
@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * 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 
+
diff --git a/drivers/gpu/pvr/pvrmmap.h b/drivers/gpu/pvr/pvrmmap.h
new file mode 100644
index 00000000000..4404d8852af
--- /dev/null
+++ b/drivers/gpu/pvr/pvrmmap.h
@@ -0,0 +1,36 @@
+/**********************************************************************
+ *
+ * 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 __PVRMMAP_H__
+#define __PVRMMAP_H__
+
+PVRSRV_ERROR PVRPMapKMem(IMG_HANDLE hModule, IMG_VOID **ppvLinAddr, IMG_VOID *pvLinAddrKM, IMG_HANDLE *phMappingInfo, IMG_HANDLE hMHandle);
+
+
+IMG_BOOL PVRUnMapKMem(IMG_HANDLE hModule, IMG_HANDLE hMappingInfo, IMG_HANDLE hMHandle);
+
+#endif 
+
diff --git a/drivers/gpu/pvr/pvrmodule.h b/drivers/gpu/pvr/pvrmodule.h
new file mode 100644
index 00000000000..30cb2c3b5aa
--- /dev/null
+++ b/drivers/gpu/pvr/pvrmodule.h
@@ -0,0 +1,31 @@
+/**********************************************************************
+ *
+ * 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 _PVRMODULE_H_
+#define _PVRMODULE_H_
+MODULE_AUTHOR("Imagination Technologies Ltd. <gpl-support@imgtec.com>");
+MODULE_LICENSE("GPL");
+#endif  
diff --git a/drivers/gpu/pvr/pvrsrv.c b/drivers/gpu/pvr/pvrsrv.c
new file mode 100644
index 00000000000..98aeb23d745
--- /dev/null
+++ b/drivers/gpu/pvr/pvrsrv.c
@@ -0,0 +1,1253 @@
+/**********************************************************************
+ *
+ * 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 "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"
+
+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;
+
+        
+        while (psDeviceWalker < psDeviceEnd)
+        {
+                if (!psDeviceWalker->bInUse)
+                {
+                        psDeviceWalker->bInUse = IMG_TRUE;
+                        *pui32DevID = psDeviceWalker->uiID;
+                        return PVRSRV_OK;
+                }
+                psDeviceWalker++;
+        }
+
+        PVR_DPF((PVR_DBG_ERROR,"AllocateDeviceID: No free and valid device IDs available!"));
+
+        
+        PVR_ASSERT(psDeviceWalker < psDeviceEnd);
+
+        return PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE;
+}
+
+
+PVRSRV_ERROR FreeDeviceID(SYS_DATA *psSysData, IMG_UINT32 ui32DevID)
+{
+        SYS_DEVICE_ID* psDeviceWalker;
+        SYS_DEVICE_ID* psDeviceEnd;
+
+        psDeviceWalker = &psSysData->sDeviceID[0];
+        psDeviceEnd = psDeviceWalker + psSysData->ui32NumDevices;
+
+        
+        while (psDeviceWalker < psDeviceEnd)
+        {
+                
+                if      (
+                                (psDeviceWalker->uiID == ui32DevID) &&
+                                (psDeviceWalker->bInUse)
+                        )
+                {
+                        psDeviceWalker->bInUse = IMG_FALSE;
+                        return PVRSRV_OK;
+                }
+                psDeviceWalker++;
+        }
+
+        PVR_DPF((PVR_DBG_ERROR,"FreeDeviceID: no matching dev ID that is in use!"));
+
+        
+        PVR_ASSERT(psDeviceWalker < psDeviceEnd);
+
+        return PVRSRV_ERROR_INVALID_DEVICEID;
+}
+
+
+#ifndef ReadHWReg
+IMG_EXPORT
+IMG_UINT32 ReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset)
+{
+        return *(volatile IMG_UINT32*)((IMG_UINTPTR_T)pvLinRegBaseAddr+ui32Offset);
+}
+#endif
+
+
+#ifndef WriteHWReg
+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",
+                        (IMG_UINTPTR_T)pvLinRegBaseAddr,ui32Offset,ui32Value));
+
+        *(IMG_UINT32*)((IMG_UINTPTR_T)pvLinRegBaseAddr+ui32Offset) = ui32Value;
+}
+#endif
+
+
+#ifndef WriteHWRegs
+IMG_EXPORT
+IMG_VOID WriteHWRegs(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Count, PVRSRV_HWREG *psHWRegs)
+{
+        while (ui32Count)
+        {
+                WriteHWReg (pvLinRegBaseAddr, psHWRegs->ui32RegAddr, psHWRegs->ui32RegVal);
+                psHWRegs++;
+                ui32Count--;
+        }
+}
+#endif
+
+static IMG_VOID PVRSRVEnumerateDevicesKM_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+{
+        IMG_UINT *pui32DevCount;
+        PVRSRV_DEVICE_IDENTIFIER **ppsDevIdList;
+
+        pui32DevCount = va_arg(va, IMG_UINT*);
+        ppsDevIdList = va_arg(va, PVRSRV_DEVICE_IDENTIFIER**);
+
+        if (psDeviceNode->sDevId.eDeviceType != PVRSRV_DEVICE_TYPE_EXT)
+        {
+                *(*ppsDevIdList) = psDeviceNode->sDevId;
+                (*ppsDevIdList)++;
+                (*pui32DevCount)++;
+        }
+}
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevicesKM(IMG_UINT32 *pui32NumDevices,
+                                                                                                   PVRSRV_DEVICE_IDENTIFIER *psDevIdList)
+{
+        SYS_DATA                        *psSysData;
+        IMG_UINT32                      i;
+
+        if (!pui32NumDevices || !psDevIdList)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDevicesKM: Invalid params"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        SysAcquireData(&psSysData);
+
+        
+
+        for (i=0; i<PVRSRV_MAX_DEVICES; i++)
+        {
+                psDevIdList[i].eDeviceType = PVRSRV_DEVICE_TYPE_UNKNOWN;
+        }
+
+        
+        *pui32NumDevices = 0;
+
+        
+
+
+
+        List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+                                                                           &PVRSRVEnumerateDevicesKM_ForEachVaCb,
+                                                                           pui32NumDevices,
+                                                                           &psDevIdList);
+
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInit(PSYS_DATA psSysData)
+{
+        PVRSRV_ERROR    eError;
+
+        
+        eError = ResManInit();
+        if (eError != PVRSRV_OK)
+        {
+                goto Error;
+        }
+
+        eError = PVRSRVPerProcessDataInit();
+        if(eError != PVRSRV_OK)
+        {
+                goto Error;
+        }
+
+        
+        eError = PVRSRVHandleInit();
+        if(eError != PVRSRV_OK)
+        {
+                goto Error;
+        }
+
+        
+        eError = OSCreateResource(&psSysData->sPowerStateChangeResource);
+        if (eError != PVRSRV_OK)
+        {
+                goto Error;
+        }
+
+        
+        psSysData->eCurrentPowerState = PVRSRV_SYS_POWER_STATE_D0;
+        psSysData->eFailedPowerState = PVRSRV_SYS_POWER_STATE_Unspecified;
+
+        
+        if(OSAllocMem( PVRSRV_PAGEABLE_SELECT,
+                                         sizeof(PVRSRV_EVENTOBJECT) ,
+                                         (IMG_VOID **)&psSysData->psGlobalEventObject, 0,
+                                         "Event Object") != PVRSRV_OK)
+        {
+
+                goto Error;
+        }
+
+        if(OSEventObjectCreate("PVRSRV_GLOBAL_EVENTOBJECT", psSysData->psGlobalEventObject) != PVRSRV_OK)
+        {
+                goto Error;
+        }
+
+        
+        PDUMPINIT();
+        g_ui32InitFlags |= INIT_DATA_ENABLE_PDUMPINIT;
+
+        return eError;
+
+Error:
+        PVRSRVDeInit(psSysData);
+        return eError;
+}
+
+
+
+IMG_VOID IMG_CALLCONV PVRSRVDeInit(PSYS_DATA psSysData)
+{
+        PVRSRV_ERROR    eError;
+
+        PVR_UNREFERENCED_PARAMETER(psSysData);
+
+        if (psSysData == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed - invalid param"));
+                return;
+        }
+
+        
+        if( (g_ui32InitFlags & INIT_DATA_ENABLE_PDUMPINIT) > 0)
+        {
+                PDUMPDEINIT();
+        }
+        
+        
+        if(psSysData->psGlobalEventObject)
+        {
+                OSEventObjectDestroy(psSysData->psGlobalEventObject);
+                OSFreeMem( PVRSRV_PAGEABLE_SELECT,
+                                                 sizeof(PVRSRV_EVENTOBJECT),
+                                                 psSysData->psGlobalEventObject,
+                                                 0);
+                psSysData->psGlobalEventObject = IMG_NULL;
+        }
+
+        eError = PVRSRVHandleDeInit();
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed"));
+        }
+
+        eError = PVRSRVPerProcessDataDeInit();
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVPerProcessDataDeInit failed"));
+        }
+
+        ResManDeInit();
+}
+
+
+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),
+                                         (IMG_VOID **)&psDeviceNode, IMG_NULL,
+                                         "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));
+
+        eError = pfnRegisterDevice(psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                        sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
+                
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to register device"));
+                return (PVRSRV_ERROR_DEVICE_REGISTER_FAILED);
+        }
+
+        
+
+
+
+
+        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;
+}
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInitialiseDevice (IMG_UINT32 ui32DevIndex)
+{
+        PVRSRV_DEVICE_NODE      *psDeviceNode;
+        SYS_DATA                        *psSysData;
+        PVRSRV_ERROR            eError;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInitialiseDevice"));
+
+        SysAcquireData(&psSysData);
+
+        
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)
+                                         List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                                        &MatchDeviceKM_AnyVaCb,
+                                                                                                        ui32DevIndex,
+                                                                                                        IMG_TRUE);
+        if(!psDeviceNode)
+        {
+                
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: requested device is not present"));
+                return PVRSRV_ERROR_INIT_FAILURE;
+        }
+        PVR_ASSERT (psDeviceNode->ui32RefCount > 0);
+
+        
+
+        eError = PVRSRVResManConnect(IMG_NULL, &psDeviceNode->hResManContext);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: Failed PVRSRVResManConnect call"));
+                return eError;
+        }
+
+        
+        if(psDeviceNode->pfnInitDevice != IMG_NULL)
+        {
+                eError = psDeviceNode->pfnInitDevice(psDeviceNode);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: Failed InitDevice call"));
+                        return eError;
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static PVRSRV_ERROR PVRSRVFinaliseSystem_SetPowerState_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR eError;
+        eError = PVRSRVSetDevicePowerStateKM(psDeviceNode->sDevId.ui32DeviceIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE_DEFAULT,
+                                                                                 KERNEL_ID, IMG_FALSE);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVFinaliseSystem: Failed PVRSRVSetDevicePowerStateKM call (device index: %d)", psDeviceNode->sDevId.ui32DeviceIndex));
+        }
+        return eError;
+}
+
+static PVRSRV_ERROR PVRSRVFinaliseSystem_CompatCheck_AnyCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR eError;
+        eError = PVRSRVDevInitCompatCheck(psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVFinaliseSystem: Failed PVRSRVDevInitCompatCheck call (device index: %d)", psDeviceNode->sDevId.ui32DeviceIndex));
+        }
+        return eError;
+}
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFinaliseSystem(IMG_BOOL bInitSuccessful)
+{
+        SYS_DATA                *psSysData;
+        PVRSRV_ERROR            eError;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVFinaliseSystem"));
+
+        SysAcquireData(&psSysData);
+
+        if (bInitSuccessful)
+        {
+                eError = SysFinalise();
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVFinaliseSystem: SysFinalise failed (%d)", eError));
+                        return eError;
+                }
+
+                
+                eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
+                                                                                                                &PVRSRVFinaliseSystem_SetPowerState_AnyCb);
+                if (eError != PVRSRV_OK)
+                {
+                        return eError;
+                }
+
+                
+                eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
+                                                                                                        &PVRSRVFinaliseSystem_CompatCheck_AnyCb);
+                if (eError != PVRSRV_OK)
+                {
+                        return eError;
+                }
+        }
+
+        
+
+
+
+        PDUMPENDINITPHASE();
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR PVRSRVDevInitCompatCheck(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        
+        if (psDeviceNode->pfnInitDeviceCompatCheck)
+                return psDeviceNode->pfnInitDeviceCompatCheck(psDeviceNode);
+        else
+                return PVRSRV_OK;
+}
+
+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->sDevId.ui32DeviceIndex == ui32DevIndex))
+        {
+                return psDeviceNode;
+        }
+        else
+        {
+                return IMG_NULL;
+        }
+}
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAcquireDeviceDataKM (IMG_UINT32                 ui32DevIndex,
+                                                                                                         PVRSRV_DEVICE_TYPE     eDeviceType,
+                                                                                                         IMG_HANDLE                     *phDevCookie)
+{
+        PVRSRV_DEVICE_NODE      *psDeviceNode;
+        SYS_DATA                        *psSysData;
+
+        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVAcquireDeviceDataKM"));
+
+        SysAcquireData(&psSysData);
+
+        
+        psDeviceNode = List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                                &PVRSRVAcquireDeviceDataKM_Match_AnyVaCb,
+                                                                                                eDeviceType,
+                                                                                                ui32DevIndex);
+
+
+        if (!psDeviceNode)
+        {
+                
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVAcquireDeviceDataKM: requested device is not present"));
+                return PVRSRV_ERROR_INIT_FAILURE;
+        }
+
+        PVR_ASSERT (psDeviceNode->ui32RefCount > 0);
+
+        
+        if (phDevCookie)
+        {
+                *phDevCookie = (IMG_HANDLE)psDeviceNode;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDeinitialiseDevice(IMG_UINT32 ui32DevIndex)
+{
+        PVRSRV_DEVICE_NODE      *psDeviceNode;
+        SYS_DATA                        *psSysData;
+        PVRSRV_ERROR            eError;
+
+        SysAcquireData(&psSysData);
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)
+                                         List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
+                                                                                                        &MatchDeviceKM_AnyVaCb,
+                                                                                                        ui32DevIndex,
+                                                                                                        IMG_TRUE);
+
+        if (!psDeviceNode)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: requested device %d is not present", ui32DevIndex));
+                return PVRSRV_ERROR_DEVICEID_NOT_FOUND;
+        }
+
+        
+
+        eError = PVRSRVSetDevicePowerStateKM(ui32DevIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE_OFF,
+                                                                                 KERNEL_ID,
+                                                                                 IMG_FALSE);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed PVRSRVSetDevicePowerStateKM call"));
+                return eError;
+        }
+
+        
+
+        eError = ResManFreeResByCriteria(psDeviceNode->hResManContext,
+                                                                         RESMAN_CRITERIA_RESTYPE,
+                                                                         RESMAN_TYPE_DEVICEMEM_ALLOCATION,
+                                                                         IMG_NULL, 0);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed ResManFreeResByCriteria call"));
+                return eError;
+        }
+
+        
+
+        if(psDeviceNode->pfnDeInitDevice != IMG_NULL)
+        {
+                eError = psDeviceNode->pfnDeInitDevice(psDeviceNode);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed DeInitDevice call"));
+                        return eError;
+                }
+        }
+
+        
+
+        PVRSRVResManDisconnect(psDeviceNode->hResManContext, IMG_TRUE);
+        psDeviceNode->hResManContext = IMG_NULL;
+
+        
+        List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
+
+        
+        (IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
+        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
+        
+
+        return (PVRSRV_OK);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PollForValueKM (volatile IMG_UINT32* pui32LinMemAddr,
+                                                                                  IMG_UINT32 ui32Value,
+                                                                                  IMG_UINT32 ui32Mask,
+                                                                                  IMG_UINT32 ui32Waitus,
+                                                                                  IMG_UINT32 ui32Tries)
+{
+        {
+                IMG_UINT32      ui32ActualValue = 0xFFFFFFFFU; 
+                IMG_UINT32      uiMaxTime = ui32Tries * ui32Waitus;
+
+                 
+                LOOP_UNTIL_TIMEOUT(uiMaxTime)
+                {
+                        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_TIMEOUT;
+}
+
+
+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)
+        {
+                pfnGetStats(psBMHeap->pImportArena,
+                                        ppszStr,
+                                        pui32StrLen);
+        }
+
+        if(psBMHeap->pVMArena)
+        {
+                pfnGetStats(psBMHeap->pVMArena,
+                                        ppszStr,
+                                        pui32StrLen);
+        }
+}
+
+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) %p:\n",
+                                                        (IMG_HANDLE)psBMContext);
+        UPDATE_SPACE(*ppszStr, *pi32Count, *pui32StrLen);
+
+        List_BM_HEAP_ForEach_va(psBMContext->psBMHeap,
+                                                        &PVRSRVGetMiscInfoKM_RA_GetStats_ForEachVaCb,
+                                                        ppszStr,
+                                                        pui32StrLen,
+                                                        ui32Mode);
+        return PVRSRV_OK;
+}
+
+
+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**);
+        ui32Mode = va_arg(va, IMG_UINT32);
+
+        CHECK_SPACE(*pui32StrLen);
+        *pi32Count = OSSNPrintf(*ppszStr, 100, "\n\nDevice Type %d:\n", psDeviceNode->sDevId.eDeviceType);
+        UPDATE_SPACE(*ppszStr, *pi32Count, *pui32StrLen);
+
+        
+        if(psDeviceNode->sDevMemoryInfo.pBMKernelContext)
+        {
+                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,
+                                                                ppszStr,
+                                                                pui32StrLen,
+                                                                ui32Mode);
+        }
+
+        
+        return List_BM_CONTEXT_PVRSRV_ERROR_Any_va(psDeviceNode->sDevMemoryInfo.pBMContext,
+                                                                                                &PVRSRVGetMiscInfoKM_BMContext_AnyVaCb,
+                                                                                                pui32StrLen,
+                                                                                                pi32Count,
+                                                                                                ppszStr,
+                                                                                                ui32Mode);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfoKM(PVRSRV_MISC_INFO *psMiscInfo)
+{
+        SYS_DATA *psSysData;
+
+        if(!psMiscInfo)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVGetMiscInfoKM: invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        psMiscInfo->ui32StatePresent = 0;
+
+        
+        if(psMiscInfo->ui32StateRequest & ~(PVRSRV_MISC_INFO_TIMER_PRESENT
+                                                                                |PVRSRV_MISC_INFO_CLOCKGATE_PRESENT
+                                                                                |PVRSRV_MISC_INFO_MEMSTATS_PRESENT
+                                                                                |PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT
+                                                                                |PVRSRV_MISC_INFO_DDKVERSION_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;
+        }
+
+        SysAcquireData(&psSysData);
+
+        
+        if(((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_TIMER_PRESENT) != 0UL) &&
+                (psSysData->pvSOCTimerRegisterKM != IMG_NULL))
+        {
+                psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_TIMER_PRESENT;
+                psMiscInfo->pvSOCTimerRegisterKM = psSysData->pvSOCTimerRegisterKM;
+                psMiscInfo->hSOCTimerRegisterOSMemHandle = psSysData->hSOCTimerRegisterOSMemHandle;
+        }
+        else
+        {
+                psMiscInfo->pvSOCTimerRegisterKM = IMG_NULL;
+                psMiscInfo->hSOCTimerRegisterOSMemHandle = IMG_NULL;
+        }
+
+        
+        if(((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_CLOCKGATE_PRESENT) != 0UL) &&
+                (psSysData->pvSOCClockGateRegsBase != IMG_NULL))
+        {
+                psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_CLOCKGATE_PRESENT;
+                psMiscInfo->pvSOCClockGateRegs = psSysData->pvSOCClockGateRegsBase;
+                psMiscInfo->ui32SOCClockGateRegsSize = psSysData->ui32SOCClockGateRegsSize;
+        }
+
+        
+        if(((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0UL) &&
+                (psMiscInfo->pszMemoryStr != IMG_NULL))
+        {
+                RA_ARENA                        **ppArena;
+                IMG_CHAR                        *pszStr;
+                IMG_UINT32                      ui32StrLen;
+                IMG_INT32                       i32Count;
+
+                pszStr = psMiscInfo->pszMemoryStr;
+                ui32StrLen = psMiscInfo->ui32MemoryStrLen;
+
+                psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_MEMSTATS_PRESENT;
+
+                
+                ppArena = &psSysData->apsLocalDevMemArena[0];
+                while(*ppArena)
+                {
+                        CHECK_SPACE(ui32StrLen);
+                        i32Count = OSSNPrintf(pszStr, 100, "\nLocal Backing Store:\n");
+                        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+
+                        RA_GetStats(*ppArena,
+                                                        &pszStr,
+                                                        &ui32StrLen);
+                        
+                        ppArena++;
+                }
+
+                
+                
+                List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any_va(psSysData->psDeviceNodeList,
+                                                                                                        &PVRSRVGetMiscInfoKM_Device_AnyVaCb,
+                                                                                                        &ui32StrLen,
+                                                                                                        &i32Count,
+                                                                                                        &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;
+
+                
+                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);
+        }
+
+        if(((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT) != 0UL) &&
+                (psSysData->psGlobalEventObject != IMG_NULL))
+        {
+                psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT;
+                psMiscInfo->sGlobalEventObject = *psSysData->psGlobalEventObject;
+        }
+
+        
+
+        if (((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0UL)
+                && ((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) == 0UL)
+                && (psMiscInfo->pszMemoryStr != IMG_NULL))
+        {
+                IMG_CHAR        *pszStr;
+                IMG_UINT32      ui32StrLen;
+                IMG_UINT32      ui32LenStrPerNum = 12; 
+                IMG_INT32       i32Count;
+                IMG_INT i;
+                psMiscInfo->ui32StatePresent |= PVRSRV_MISC_INFO_DDKVERSION_PRESENT;
+
+                
+                psMiscInfo->aui32DDKVersion[0] = PVRVERSION_MAJ;
+                psMiscInfo->aui32DDKVersion[1] = PVRVERSION_MIN;
+                psMiscInfo->aui32DDKVersion[2] = PVRVERSION_BRANCH;
+                psMiscInfo->aui32DDKVersion[3] = PVRVERSION_BUILD;
+
+                pszStr = psMiscInfo->pszMemoryStr;
+                ui32StrLen = psMiscInfo->ui32MemoryStrLen;
+
+                for (i=0; i<4; i++)
+                {
+                        if (ui32StrLen < ui32LenStrPerNum)
+                        {
+                                return PVRSRV_ERROR_INVALID_PARAMS;
+                        }
+
+                        i32Count = OSSNPrintf(pszStr, ui32LenStrPerNum, "%u", psMiscInfo->aui32DDKVersion[i]);
+                        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+                        if (i != 3)
+                        {
+                                i32Count = OSSNPrintf(pszStr, 2, ".");
+                                UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+                        }
+                }
+        }
+
+        if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_CPUCACHEOP_PRESENT) != 0UL)
+        {
+                if(psMiscInfo->sCacheOpCtl.bDeferOp)
+                {
+                        
+                        psSysData->ePendingCacheOpType = psMiscInfo->sCacheOpCtl.eCacheOpType;
+                }
+                else
+                {
+                        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
+                        PVRSRV_PER_PROCESS_DATA *psPerProc;
+
+                        if(!psMiscInfo->sCacheOpCtl.u.psKernelMemInfo)
+                        {
+                                PVR_DPF((PVR_DBG_WARNING, "PVRSRVGetMiscInfoKM: "
+                                                 "Ignoring non-deferred cache op with no meminfo"));
+                                return PVRSRV_ERROR_INVALID_PARAMS;
+                        }
+
+                        if(psSysData->ePendingCacheOpType != PVRSRV_MISC_INFO_CPUCACHEOP_NONE)
+                        {
+                                PVR_DPF((PVR_DBG_WARNING, "PVRSRVGetMiscInfoKM: "
+                                                 "Deferred cache op is pending. It is unlikely you want "
+                                                 "to combine deferred cache ops with immediate ones"));
+                        }
+
+                        
+                        psPerProc = PVRSRVFindPerProcessData();
+
+                        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;
+                        }
+
+                        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;
+                                }
+                        }
+                }
+        }
+
+#if defined(PVRSRV_RESET_ON_HWTIMEOUT)
+        if((psMiscInfo->ui32StateRequest & PVRSRV_MISC_INFO_RESET_PRESENT) != 0UL)
+        {
+                PVR_LOG(("User requested OS reset"));
+                OSPanic();
+        }
+#endif 
+
+        return PVRSRV_OK;
+}
+
+
+IMG_BOOL IMG_CALLCONV PVRSRVDeviceLISR(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        SYS_DATA                        *psSysData;
+        IMG_BOOL                        bStatus = IMG_FALSE;
+        IMG_UINT32                      ui32InterruptSource;
+
+        if(!psDeviceNode)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVDeviceLISR: Invalid params\n"));
+                goto out;
+        }
+        psSysData = psDeviceNode->psSysData;
+
+        
+        ui32InterruptSource = SysGetInterruptSource(psSysData, psDeviceNode);
+        if(ui32InterruptSource & psDeviceNode->ui32SOCInterruptBit)
+        {
+                if(psDeviceNode->pfnDeviceISR != IMG_NULL)
+                {
+                        bStatus = (*psDeviceNode->pfnDeviceISR)(psDeviceNode->pvISRData);
+                }
+
+                SysClearInterrupts(psSysData, psDeviceNode->ui32SOCInterruptBit);
+        }
+
+out:
+        return bStatus;
+}
+
+static IMG_VOID PVRSRVSystemLISR_ForEachVaCb(PVRSRV_DEVICE_NODE *psDeviceNode, va_list va)
+{
+
+        IMG_BOOL *pbStatus;
+        IMG_UINT32 *pui32InterruptSource;
+        IMG_UINT32 *pui32ClearInterrupts;
+
+        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)
+                {
+                        if((*psDeviceNode->pfnDeviceISR)(psDeviceNode->pvISRData))
+                        {
+                                
+                                *pbStatus = IMG_TRUE;
+                        }
+                        
+                        *pui32ClearInterrupts |= psDeviceNode->ui32SOCInterruptBit;
+                }
+        }
+}
+
+IMG_BOOL IMG_CALLCONV PVRSRVSystemLISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA                        *psSysData = pvSysData;
+        IMG_BOOL                        bStatus = IMG_FALSE;
+        IMG_UINT32                      ui32InterruptSource;
+        IMG_UINT32                      ui32ClearInterrupts = 0;
+        if(!psSysData)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVSystemLISR: Invalid params\n"));
+        }
+        else
+        {
+                
+                ui32InterruptSource = SysGetInterruptSource(psSysData, IMG_NULL);
+
+                
+                if(ui32InterruptSource)
+                {
+                        
+                        List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
+                                                                                                &PVRSRVSystemLISR_ForEachVaCb,
+                                                                                                &bStatus,
+                                                                                                &ui32InterruptSource,
+                                                                                                &ui32ClearInterrupts);
+
+                        SysClearInterrupts(psSysData, ui32ClearInterrupts);
+                }
+        }
+        return bStatus;
+}
+
+
+static IMG_VOID PVRSRVMISR_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        if(psDeviceNode->pfnDeviceMISR != IMG_NULL)
+        {
+                (*psDeviceNode->pfnDeviceMISR)(psDeviceNode->pvISRData);
+        }
+}
+
+IMG_VOID IMG_CALLCONV PVRSRVMISR(IMG_VOID *pvSysData)
+{
+        SYS_DATA                        *psSysData = pvSysData;
+        if(!psSysData)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVMISR: Invalid params\n"));
+                return;
+        }
+
+        
+        List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
+                                                                        &PVRSRVMISR_ForEachCb);
+
+        
+        if (PVRSRVProcessQueues(ISR_ID, IMG_FALSE) == PVRSRV_ERROR_PROCESSING_BLOCKED)
+        {
+                PVRSRVProcessQueues(ISR_ID, IMG_FALSE);
+        }
+
+        
+        if (psSysData->psGlobalEventObject)
+        {
+                IMG_HANDLE hOSEventKM = psSysData->psGlobalEventObject->hOSEventKM;
+                if(hOSEventKM)
+                {
+                        OSEventObjectSignal(hOSEventKM);
+                }
+        }
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVProcessConnect(IMG_UINT32       ui32PID)
+{
+        return PVRSRVPerProcessDataConnect(ui32PID);
+}
+
+
+IMG_EXPORT
+IMG_VOID IMG_CALLCONV PVRSRVProcessDisconnect(IMG_UINT32        ui32PID)
+{
+        PVRSRVPerProcessDataDisconnect(ui32PID);
+}
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSaveRestoreLiveSegments(IMG_HANDLE hArena, IMG_PBYTE pbyBuffer,
+                                                                                                                IMG_SIZE_T *puiBufSize, IMG_BOOL bSave)
+{
+        IMG_SIZE_T         uiBytesSaved = 0;
+        IMG_PVOID          pvLocalMemCPUVAddr;
+        RA_SEGMENT_DETAILS sSegDetails;
+
+        if (hArena == IMG_NULL)
+        {
+                return (PVRSRV_ERROR_INVALID_PARAMS);
+        }
+
+        sSegDetails.uiSize = 0;
+        sSegDetails.sCpuPhyAddr.uiAddr = 0;
+        sSegDetails.hSegment = 0;
+
+        
+        while (RA_GetNextLiveSegment(hArena, &sSegDetails))
+        {
+                if (pbyBuffer == IMG_NULL)
+                {
+                        
+                        uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
+                }
+                else
+                {
+                        if ((uiBytesSaved + sizeof(sSegDetails.uiSize) + sSegDetails.uiSize) > *puiBufSize)
+                        {
+                                return (PVRSRV_ERROR_OUT_OF_MEMORY);
+                        }
+
+                        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVSaveRestoreLiveSegments: Base %08x size %08x", sSegDetails.sCpuPhyAddr.uiAddr, sSegDetails.uiSize));
+
+                        
+                        pvLocalMemCPUVAddr = OSMapPhysToLin(sSegDetails.sCpuPhyAddr,
+                                                                        sSegDetails.uiSize,
+                                                                        PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                                                        IMG_NULL);
+                        if (pvLocalMemCPUVAddr == IMG_NULL)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Failed to map local memory to host"));
+                                return (PVRSRV_ERROR_OUT_OF_MEMORY);
+                        }
+
+                        if (bSave)
+                        {
+                                
+                                OSMemCopy(pbyBuffer, &sSegDetails.uiSize, sizeof(sSegDetails.uiSize));
+                                pbyBuffer += sizeof(sSegDetails.uiSize);
+
+                                OSMemCopy(pbyBuffer, pvLocalMemCPUVAddr, sSegDetails.uiSize);
+                                pbyBuffer += sSegDetails.uiSize;
+                        }
+                        else
+                        {
+                                IMG_UINT32 uiSize;
+                                
+                                OSMemCopy(&uiSize, pbyBuffer, sizeof(sSegDetails.uiSize));
+
+                                if (uiSize != sSegDetails.uiSize)
+                                {
+                                        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSaveRestoreLiveSegments: Segment size error"));
+                                }
+                                else
+                                {
+                                        pbyBuffer += sizeof(sSegDetails.uiSize);
+
+                                        OSMemCopy(pvLocalMemCPUVAddr, pbyBuffer, sSegDetails.uiSize);
+                                        pbyBuffer += sSegDetails.uiSize;
+                                }
+                        }
+
+
+                        uiBytesSaved += sizeof(sSegDetails.uiSize) + sSegDetails.uiSize;
+
+                        OSUnMapPhysToLin(pvLocalMemCPUVAddr,
+                                     sSegDetails.uiSize,
+                                     PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                     IMG_NULL);
+                }
+        }
+
+        if (pbyBuffer == IMG_NULL)
+        {
+                *puiBufSize = uiBytesSaved;
+        }
+
+        return (PVRSRV_OK);
+}
+
+
+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();
+}
+
diff --git a/drivers/gpu/pvr/pvrsrv_errors.h b/drivers/gpu/pvr/pvrsrv_errors.h
new file mode 100644
index 00000000000..56c7184fe2c
--- /dev/null
+++ b/drivers/gpu/pvr/pvrsrv_errors.h
@@ -0,0 +1,264 @@
+/**********************************************************************
+ *
+ * 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 
+
diff --git a/drivers/gpu/pvr/pvrversion.h b/drivers/gpu/pvr/pvrversion.h
new file mode 100644
index 00000000000..d7c06c21402
--- /dev/null
+++ b/drivers/gpu/pvr/pvrversion.h
@@ -0,0 +1,38 @@
+/**********************************************************************
+ *
+ * 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 _PVRVERSION_H_
+#define _PVRVERSION_H_
+
+#define PVRVERSION_MAJ 1
+#define PVRVERSION_MIN 6
+#define PVRVERSION_BRANCH 16
+#define PVRVERSION_BUILD 3421
+#define PVRVERSION_STRING "1.6.16.3421"
+#define PVRVERSION_FILE "eurasiacon.pj"
+
+#endif 
+
diff --git a/drivers/gpu/pvr/queue.c b/drivers/gpu/pvr/queue.c
new file mode 100644
index 00000000000..5340571d64c
--- /dev/null
+++ b/drivers/gpu/pvr/queue.c
@@ -0,0 +1,1154 @@
+/**********************************************************************
+ *
+ * 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 "lists.h"
+
+#if defined(__linux__) && defined(__KERNEL__)
+
+#include "proc.h"
+
+static IMG_INT
+QueuePrintCommands (PVRSRV_QUEUE_INFO * psQueue, IMG_CHAR * buffer, size_t size)
+{
+        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, "%x %x  %5u  %6u  %3u  %5u   %2u   %2u    %3u  \n",
+                                                        (IMG_UINTPTR_T)psQueue,
+                                                        (IMG_UINTPTR_T)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, "%x <empty>\n", (IMG_UINTPTR_T)psQueue);
+        }
+        return off;
+} 
+
+
+
+void ProcSeqShowQueue(struct seq_file *sfile,void* el)
+{
+        PVRSRV_QUEUE_INFO * psQueue = (PVRSRV_QUEUE_INFO*)el;
+        IMG_INT cmds = 0;
+        IMG_SIZE_T ui32ReadOffset;
+        IMG_SIZE_T ui32WriteOffset;
+        PVRSRV_COMMAND * psCmd;
+
+        if(el == PVR_PROC_SEQ_START_TOKEN)
+        {
+                seq_printf( sfile,
+                                        "Command Queues\n"
+                                        "Queue    CmdPtr      Pid Command Size DevInd  DSC  SSC  #Data ...\n");
+                return;
+        }
+
+        ui32ReadOffset = psQueue->ui32ReadOffset;
+        ui32WriteOffset = psQueue->ui32WriteOffset;
+
+        while (ui32ReadOffset != ui32WriteOffset)
+        {
+                psCmd= (PVRSRV_COMMAND *)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + ui32ReadOffset);
+
+                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,
+                                                        psCmd->ui32DevIndex,
+                                                        psCmd->ui32DstSyncCount,
+                                                        psCmd->ui32SrcSyncCount,
+                                                        psCmd->ui32DataSize);
+                
+                ui32ReadOffset += psCmd->ui32CmdSize;
+                ui32ReadOffset &= psQueue->ui32QueueSize - 1;
+                cmds++;
+        }
+
+        if (cmds == 0)
+        {
+                seq_printf(sfile, "%x <empty>\n", (IMG_UINTPTR_T)psQueue);
+        }
+}
+
+void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off)
+{
+        PVRSRV_QUEUE_INFO * psQueue;
+        SYS_DATA * psSysData;
+
+        PVR_UNREFERENCED_PARAMETER(sfile);
+
+        if(!off)
+        {
+                return PVR_PROC_SEQ_START_TOKEN;
+        }
+
+
+        SysAcquireData(&psSysData);
+
+        for (psQueue = psSysData->psQueueList; (((--off) > 0) && (psQueue != IMG_NULL)); psQueue = psQueue->psNextKM);
+        return psQueue;
+}
+
+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))
+
+#define UPDATE_QUEUE_WOFF(psQueue, ui32Size)                                                    \
+        (psQueue)->ui32WriteOffset = ((psQueue)->ui32WriteOffset + (ui32Size))  \
+        & ((psQueue)->ui32QueueSize - 1);
+
+#define SYNCOPS_STALE(ui32OpsComplete, ui32OpsPending)                                  \
+        ((ui32OpsComplete) >= (ui32OpsPending))
+
+
+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 %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))
+        }
+        else
+        {
+                PVR_LOG(("\t%s %u: (Not in use)", bIsSrc ? "SRC" : "DEST", i))
+        }
+}
+
+
+static IMG_VOID QueueDumpDebugInfo_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        if (psDeviceNode->sDevId.eDeviceClass == PVRSRV_DEVICE_CLASS_DISPLAY)
+        {
+                IMG_UINT32              i;
+                SYS_DATA                *psSysData;
+                COMMAND_COMPLETE_DATA   **ppsCmdCompleteData;
+                COMMAND_COMPLETE_DATA   *psCmdCompleteData;
+
+                SysAcquireData(&psSysData);
+
+                ppsCmdCompleteData = psSysData->ppsCmdCompleteData[psDeviceNode->sDevId.ui32DeviceIndex];
+
+                if (ppsCmdCompleteData != IMG_NULL)
+                {
+                        psCmdCompleteData = ppsCmdCompleteData[DC_FLIP_COMMAND];
+
+                        PVR_LOG(("Command Complete Data for display device %u:", psDeviceNode->sDevId.ui32DeviceIndex))
+
+                        for (i = 0; i < psCmdCompleteData->ui32SrcSyncCount; i++)
+                        {
+                                QueueDumpCmdComplete(psCmdCompleteData, i, IMG_TRUE);
+                        }
+
+                        for (i = 0; i < psCmdCompleteData->ui32DstSyncCount; i++)
+                        {
+                                QueueDumpCmdComplete(psCmdCompleteData, i, IMG_FALSE);
+                        }
+                }
+                else
+                {
+                        PVR_LOG(("There is no Command Complete Data for display device %u", psDeviceNode->sDevId.ui32DeviceIndex))
+                }
+        }
+}
+
+
+IMG_VOID QueueDumpDebugInfo(IMG_VOID)
+{
+        SYS_DATA        *psSysData;
+        SysAcquireData(&psSysData);
+        List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList, &QueueDumpDebugInfo_ForEachCb);
+}
+
+
+static IMG_SIZE_T NearestPower2(IMG_SIZE_T ui32Value)
+{
+        IMG_SIZE_T ui32Temp, ui32Result = 1;
+
+        if(!ui32Value)
+                return 0;
+
+        ui32Temp = ui32Value - 1;
+        while(ui32Temp)
+        {
+                ui32Result <<= 1;
+                ui32Temp >>= 1;
+        }
+
+        return ui32Result;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_SIZE_T ui32QueueSize,
+                                                                                                         PVRSRV_QUEUE_INFO **ppsQueueInfo)
+{
+        PVRSRV_QUEUE_INFO       *psQueueInfo;
+        IMG_SIZE_T                      ui32Power2QueueSize = NearestPower2(ui32QueueSize);
+        SYS_DATA                        *psSysData;
+        PVRSRV_ERROR            eError;
+        IMG_HANDLE                      hMemBlock;
+
+        SysAcquireData(&psSysData);
+
+        
+        eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                         sizeof(PVRSRV_QUEUE_INFO),
+                                         (IMG_VOID **)&psQueueInfo, &hMemBlock,
+                                         "Queue Info");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue struct"));
+                goto ErrorExit;
+        }
+        OSMemSet(psQueueInfo, 0, sizeof(PVRSRV_QUEUE_INFO));
+
+        psQueueInfo->hMemBlock[0] = hMemBlock;
+        psQueueInfo->ui32ProcessID = OSGetCurrentProcessIDKM();
+
+        
+        eError = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                         ui32Power2QueueSize + PVRSRV_MAX_CMD_SIZE,
+                                         &psQueueInfo->pvLinQueueKM, &hMemBlock,
+                                         "Command Queue");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateCommandQueueKM: Failed to alloc queue buffer"));
+                goto ErrorExit;
+        }
+
+        psQueueInfo->hMemBlock[1] = hMemBlock;
+        psQueueInfo->pvLinQueueUM = psQueueInfo->pvLinQueueKM;
+
+        
+        PVR_ASSERT(psQueueInfo->ui32ReadOffset == 0);
+        PVR_ASSERT(psQueueInfo->ui32WriteOffset == 0);
+
+        psQueueInfo->ui32QueueSize = ui32Power2QueueSize;
+
+        
+        if (psSysData->psQueueList == IMG_NULL)
+        {
+                eError = OSCreateResource(&psSysData->sQProcessResource);
+                if (eError != PVRSRV_OK)
+                {
+                        goto ErrorExit;
+                }
+        }
+
+        
+        eError = OSLockResource(&psSysData->sQProcessResource,
+                                                        KERNEL_ID);
+        if (eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        psQueueInfo->psNextKM = psSysData->psQueueList;
+        psSysData->psQueueList = psQueueInfo;
+
+        eError = OSUnlockResource(&psSysData->sQProcessResource, KERNEL_ID);
+        if (eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        *ppsQueueInfo = psQueueInfo;
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        if(psQueueInfo)
+        {
+                if(psQueueInfo->pvLinQueueKM)
+                {
+                        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                                psQueueInfo->ui32QueueSize,
+                                                psQueueInfo->pvLinQueueKM,
+                                                psQueueInfo->hMemBlock[1]);
+                        psQueueInfo->pvLinQueueKM = IMG_NULL;
+                }
+
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                        sizeof(PVRSRV_QUEUE_INFO),
+                                        psQueueInfo,
+                                        psQueueInfo->hMemBlock[0]);
+                
+        }
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueueInfo)
+{
+        PVRSRV_QUEUE_INFO       *psQueue;
+        SYS_DATA                        *psSysData;
+        PVRSRV_ERROR            eError;
+        IMG_BOOL                        bTimeout = IMG_TRUE;
+
+        SysAcquireData(&psSysData);
+
+        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();
+
+        if (bTimeout)
+        {
+                
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVDestroyCommandQueueKM : Failed to empty queue"));
+                eError = PVRSRV_ERROR_CANNOT_FLUSH_QUEUE;
+                goto ErrorExit;
+        }
+
+        
+        eError = OSLockResource(&psSysData->sQProcessResource,
+                                                                KERNEL_ID);
+        if (eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        if(psQueue == psQueueInfo)
+        {
+                psSysData->psQueueList = psQueueInfo->psNextKM;
+
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                        NearestPower2(psQueueInfo->ui32QueueSize) + PVRSRV_MAX_CMD_SIZE,
+                                        psQueueInfo->pvLinQueueKM,
+                                        psQueueInfo->hMemBlock[1]);
+                psQueueInfo->pvLinQueueKM = IMG_NULL;
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                        sizeof(PVRSRV_QUEUE_INFO),
+                                        psQueueInfo,
+                                        psQueueInfo->hMemBlock[0]);
+                 
+                psQueueInfo = IMG_NULL; 
+        }
+        else
+        {
+                while(psQueue)
+                {
+                        if(psQueue->psNextKM == psQueueInfo)
+                        {
+                                psQueue->psNextKM = psQueueInfo->psNextKM;
+
+                                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                                        psQueueInfo->ui32QueueSize,
+                                                        psQueueInfo->pvLinQueueKM,
+                                                        psQueueInfo->hMemBlock[1]);
+                                psQueueInfo->pvLinQueueKM = IMG_NULL;
+                                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                                        sizeof(PVRSRV_QUEUE_INFO),
+                                                        psQueueInfo,
+                                                        psQueueInfo->hMemBlock[0]);
+                                 
+                                psQueueInfo = IMG_NULL; 
+                                break;
+                        }
+                        psQueue = psQueue->psNextKM;
+                }
+
+                if(!psQueue)
+                {
+                        eError = OSUnlockResource(&psSysData->sQProcessResource, KERNEL_ID);
+                        if (eError != PVRSRV_OK)
+                        {
+                                goto ErrorExit;
+                        }
+                        eError = PVRSRV_ERROR_INVALID_PARAMS;
+                        goto ErrorExit;
+                }
+        }
+
+        
+        eError = OSUnlockResource(&psSysData->sQProcessResource, KERNEL_ID);
+        if (eError != PVRSRV_OK)
+        {
+                goto ErrorExit;
+        }
+
+        
+        if (psSysData->psQueueList == IMG_NULL)
+        {
+                eError = OSDestroyResource(&psSysData->sQProcessResource);
+                if (eError != PVRSRV_OK)
+                {
+                        goto ErrorExit;
+                }
+        }
+
+ErrorExit:
+
+        return eError;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetQueueSpaceKM(PVRSRV_QUEUE_INFO *psQueue,
+                                                                                                IMG_SIZE_T ui32ParamSize,
+                                                                                                IMG_VOID **ppvSpace)
+{
+        IMG_BOOL bTimeout = IMG_TRUE;
+
+        
+        ui32ParamSize =  (ui32ParamSize+3) & 0xFFFFFFFC;
+
+        if (ui32ParamSize > PVRSRV_MAX_CMD_SIZE)
+        {
+                PVR_DPF((PVR_DBG_WARNING,"PVRSRVGetQueueSpace: max command size is %d bytes", PVRSRV_MAX_CMD_SIZE));
+                return PVRSRV_ERROR_CMD_TOO_BIG;
+        }
+
+         
+        LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+        {
+                if (GET_SPACE_IN_CMDQ(psQueue) > ui32ParamSize)
+                {
+                        bTimeout = IMG_FALSE;
+                        break;
+                }
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+        } END_LOOP_UNTIL_TIMEOUT();
+
+        if (bTimeout == IMG_TRUE)
+        {
+                *ppvSpace = IMG_NULL;
+
+                return PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE;
+        }
+        else
+        {
+                *ppvSpace = (IMG_VOID *)((IMG_UINTPTR_T)psQueue->pvLinQueueUM + psQueue->ui32WriteOffset);
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO       *psQueue,
+                                                                                                PVRSRV_COMMAND          **ppsCommand,
+                                                                                                IMG_UINT32                      ui32DevIndex,
+                                                                                                IMG_UINT16                      CommandType,
+                                                                                                IMG_UINT32                      ui32DstSyncCount,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO *apsDstSync[],
+                                                                                                IMG_UINT32                      ui32SrcSyncCount,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO *apsSrcSync[],
+                                                                                                IMG_SIZE_T                      ui32DataByteSize )
+{
+        PVRSRV_ERROR    eError;
+        PVRSRV_COMMAND  *psCommand;
+        IMG_SIZE_T              ui32CommandSize;
+        IMG_UINT32              i;
+
+        
+        ui32DataByteSize = (ui32DataByteSize + 3UL) & ~3UL;
+
+        
+        ui32CommandSize = sizeof(PVRSRV_COMMAND)
+                                        + ((ui32DstSyncCount + ui32SrcSyncCount) * sizeof(PVRSRV_SYNC_OBJECT))
+                                        + ui32DataByteSize;
+
+        
+        eError = PVRSRVGetQueueSpaceKM (psQueue, ui32CommandSize, (IMG_VOID**)&psCommand);
+        if(eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        psCommand->ui32ProcessID        = OSGetCurrentProcessIDKM();
+
+        
+        psCommand->ui32CmdSize          = ui32CommandSize; 
+        psCommand->ui32DevIndex         = ui32DevIndex;
+        psCommand->CommandType          = CommandType;
+        psCommand->ui32DstSyncCount     = ui32DstSyncCount;
+        psCommand->ui32SrcSyncCount     = ui32SrcSyncCount;
+        
+        
+        psCommand->psDstSync            = (PVRSRV_SYNC_OBJECT*)(((IMG_UINTPTR_T)psCommand) + sizeof(PVRSRV_COMMAND));
+
+
+        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)
+                                                                + (ui32SrcSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
+        psCommand->ui32DataSize         = ui32DataByteSize;
+
+        
+        for (i=0; i<ui32DstSyncCount; i++)
+        {
+                psCommand->psDstSync[i].psKernelSyncInfoKM = apsDstSync[i];
+                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 %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->psDstSync[i].ui32WriteOpsPending));
+        }
+
+        
+        for (i=0; i<ui32SrcSyncCount; i++)
+        {
+                psCommand->psSrcSync[i].psKernelSyncInfoKM = apsSrcSync[i];
+                psCommand->psSrcSync[i].ui32WriteOpsPending = PVRSRVGetWriteOpsPending(apsSrcSync[i], IMG_TRUE);
+                psCommand->psSrcSync[i].ui32ReadOpsPending = PVRSRVGetReadOpsPending(apsSrcSync[i], IMG_TRUE);
+
+                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,
+                                psCommand->psSrcSync[i].ui32WriteOpsPending));
+        }
+
+        
+        *ppsCommand = psCommand;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSubmitCommandKM(PVRSRV_QUEUE_INFO *psQueue,
+                                                                                                PVRSRV_COMMAND *psCommand)
+{
+        
+        
+        
+        if (psCommand->ui32DstSyncCount > 0)
+        {
+                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)
+                                                                        + psQueue->ui32WriteOffset + sizeof(PVRSRV_COMMAND)
+                                                                        + (psCommand->ui32DstSyncCount * sizeof(PVRSRV_SYNC_OBJECT)));
+        }
+
+        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;
+}
+
+
+
+static
+PVRSRV_ERROR PVRSRVProcessCommand(SYS_DATA                      *psSysData,
+                                                                  PVRSRV_COMMAND        *psCommand,
+                                                                  IMG_BOOL                      bFlush)
+{
+        PVRSRV_SYNC_OBJECT              *psWalkerObj;
+        PVRSRV_SYNC_OBJECT              *psEndObj;
+        IMG_UINT32                              i;
+        COMMAND_COMPLETE_DATA   *psCmdCompleteData;
+        PVRSRV_ERROR                    eError = PVRSRV_OK;
+        IMG_UINT32                              ui32WriteOpsComplete;
+        IMG_UINT32                              ui32ReadOpsComplete;
+
+        
+        psWalkerObj = psCommand->psDstSync;
+        psEndObj = psWalkerObj + psCommand->ui32DstSyncCount;
+        while (psWalkerObj < psEndObj)
+        {
+                PVRSRV_SYNC_DATA *psSyncData = psWalkerObj->psKernelSyncInfoKM->psSyncData;
+
+                ui32WriteOpsComplete = psSyncData->ui32WriteOpsComplete;
+                ui32ReadOpsComplete = psSyncData->ui32ReadOpsComplete;
+                
+                if ((ui32WriteOpsComplete != psWalkerObj->ui32WriteOpsPending)
+                ||      (ui32ReadOpsComplete != psWalkerObj->ui32ReadOpsPending))
+                {
+                        if (!bFlush ||
+                                !SYNCOPS_STALE(ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending) ||
+                                !SYNCOPS_STALE(ui32ReadOpsComplete, psWalkerObj->ui32ReadOpsPending))
+                        {
+                                return PVRSRV_ERROR_FAILED_DEPENDENCIES;
+                        }
+                }
+
+                psWalkerObj++;
+        }
+
+        
+        psWalkerObj = psCommand->psSrcSync;
+        psEndObj = psWalkerObj + psCommand->ui32SrcSyncCount;
+        while (psWalkerObj < psEndObj)
+        {
+                PVRSRV_SYNC_DATA *psSyncData = psWalkerObj->psKernelSyncInfoKM->psSyncData;
+
+                ui32ReadOpsComplete = psSyncData->ui32ReadOpsComplete;
+                ui32WriteOpsComplete = psSyncData->ui32WriteOpsComplete;
+                
+                if ((ui32WriteOpsComplete != psWalkerObj->ui32WriteOpsPending)
+                || (ui32ReadOpsComplete != psWalkerObj->ui32ReadOpsPending))
+                {
+                        if (!bFlush &&
+                                SYNCOPS_STALE(ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending) &&
+                                SYNCOPS_STALE(ui32ReadOpsComplete, psWalkerObj->ui32ReadOpsPending))
+                        {
+                                PVR_DPF((PVR_DBG_WARNING,
+                                                "PVRSRVProcessCommand: Stale syncops psSyncData:0x%x ui32WriteOpsComplete:0x%x ui32WriteOpsPending:0x%x",
+                                                (IMG_UINTPTR_T)psSyncData, ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending));
+                        }
+
+                        if (!bFlush ||
+                                !SYNCOPS_STALE(ui32WriteOpsComplete, psWalkerObj->ui32WriteOpsPending) ||
+                                !SYNCOPS_STALE(ui32ReadOpsComplete, psWalkerObj->ui32ReadOpsPending))
+                        {
+                                return PVRSRV_ERROR_FAILED_DEPENDENCIES;
+                        }
+                }
+                psWalkerObj++;
+        }
+
+        
+        if (psCommand->ui32DevIndex >= SYS_DEVICE_COUNT)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                        "PVRSRVProcessCommand: invalid DeviceType 0x%x",
+                                        psCommand->ui32DevIndex));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        psCmdCompleteData = psSysData->ppsCmdCompleteData[psCommand->ui32DevIndex][psCommand->CommandType];
+        if (psCmdCompleteData->bInUse)
+        {
+                
+                return PVRSRV_ERROR_FAILED_DEPENDENCIES;
+        }
+
+        
+        psCmdCompleteData->bInUse = IMG_TRUE;
+
+        
+        psCmdCompleteData->ui32DstSyncCount = psCommand->ui32DstSyncCount;
+        for (i=0; i<psCommand->ui32DstSyncCount; i++)
+        {
+                psCmdCompleteData->psDstSync[i] = psCommand->psDstSync[i];
+
+                PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: 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->psDstSync[i].ui32WriteOpsPending));
+        }
+
+
+        
+        psCmdCompleteData->ui32SrcSyncCount = psCommand->ui32SrcSyncCount;
+        for (i=0; i<psCommand->ui32SrcSyncCount; i++)
+        {
+                psCmdCompleteData->psSrcSync[i] = psCommand->psSrcSync[i];
+
+                PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVProcessCommand: 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));
+        }
+
+        
+
+
+
+
+
+
+
+
+
+        if (psSysData->ppfnCmdProcList[psCommand->ui32DevIndex][psCommand->CommandType]((IMG_HANDLE)psCmdCompleteData,
+                                                                                                                                                                psCommand->ui32DataSize,
+                                                                                                                                                                psCommand->pvData) == IMG_FALSE)
+        {
+                
+
+
+                psCmdCompleteData->bInUse = IMG_FALSE;
+                eError = PVRSRV_ERROR_CMD_NOT_PROCESSED;
+        }
+
+        return eError;
+}
+
+
+static IMG_VOID PVRSRVProcessQueues_ForEachCb(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        if (psDeviceNode->bReProcessDeviceCommandComplete &&
+                psDeviceNode->pfnDeviceCommandComplete != IMG_NULL)
+        {
+                (*psDeviceNode->pfnDeviceCommandComplete)(psDeviceNode);
+        }
+}
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVProcessQueues(IMG_UINT32     ui32CallerID,
+                                                                 IMG_BOOL       bFlush)
+{
+        PVRSRV_QUEUE_INFO       *psQueue;
+        SYS_DATA                        *psSysData;
+        PVRSRV_COMMAND          *psCommand;
+        PVRSRV_ERROR            eError;
+
+        SysAcquireData(&psSysData);
+
+        
+        psSysData->bReProcessQueues = IMG_FALSE;
+
+        
+        eError = OSLockResource(&psSysData->sQProcessResource,
+                                                        ui32CallerID);
+        if(eError != PVRSRV_OK)
+        {
+                
+                psSysData->bReProcessQueues = IMG_TRUE;
+
+                
+                if(ui32CallerID == ISR_ID)
+                {
+                        if (bFlush)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"PVRSRVProcessQueues: Couldn't acquire queue processing lock for FLUSH"));
+                        }
+                        else
+                        {
+                                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;
+        }
+
+        psQueue = psSysData->psQueueList;
+
+        if(!psQueue)
+        {
+                PVR_DPF((PVR_DBG_MESSAGE,"No Queues installed - cannot process commands"));
+        }
+
+        if (bFlush)
+        {
+                PVRSRVSetDCState(DC_STATE_FLUSH_COMMANDS);
+        }
+
+        while (psQueue)
+        {
+                while (psQueue->ui32ReadOffset != psQueue->ui32WriteOffset)
+                {
+                        psCommand = (PVRSRV_COMMAND*)((IMG_UINTPTR_T)psQueue->pvLinQueueKM + psQueue->ui32ReadOffset);
+
+                        if (PVRSRVProcessCommand(psSysData, psCommand, bFlush) == PVRSRV_OK)
+                        {
+                                
+                                UPDATE_QUEUE_ROFF(psQueue, psCommand->ui32CmdSize)
+
+                                if (bFlush)
+                                {
+                                        continue;
+                                }
+                        }
+
+                        break;
+                }
+                psQueue = psQueue->psNextKM;
+        }
+
+        if (bFlush)
+        {
+                PVRSRVSetDCState(DC_STATE_NO_FLUSH_COMMANDS);
+        }
+
+        
+        List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
+                                                                        &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 defined(SYS_USING_INTERRUPTS)
+        if(bScheduleMISR)
+        {
+                OSScheduleMISR(psSysData);
+        }
+#else
+        PVR_UNREFERENCED_PARAMETER(bScheduleMISR);
+#endif 
+}
+
+#endif 
+
+
+IMG_EXPORT
+IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE     hCmdCookie,
+                                                                 IMG_BOOL       bScheduleMISR)
+{
+        IMG_UINT32                              i;
+        COMMAND_COMPLETE_DATA   *psCmdCompleteData = (COMMAND_COMPLETE_DATA *)hCmdCookie;
+        SYS_DATA                                *psSysData;
+
+        SysAcquireData(&psSysData);
+
+        
+        for (i=0; i<psCmdCompleteData->ui32DstSyncCount; i++)
+        {
+                psCmdCompleteData->psDstSync[i].psKernelSyncInfoKM->psSyncData->ui32WriteOpsComplete++;
+
+                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->psDstSync[i].ui32WriteOpsPending));
+        }
+
+        
+        for (i=0; i<psCmdCompleteData->ui32SrcSyncCount; i++)
+        {
+                psCmdCompleteData->psSrcSync[i].psKernelSyncInfoKM->psSyncData->ui32ReadOpsComplete++;
+
+                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;
+
+        
+        PVRSRVScheduleDeviceCallbacks();
+
+#if defined(SYS_USING_INTERRUPTS)
+        if(bScheduleMISR)
+        {
+                OSScheduleMISR(psSysData);
+        }
+#else
+        PVR_UNREFERENCED_PARAMETER(bScheduleMISR);
+#endif 
+}
+
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32             ui32DevIndex,
+                                                                                 PFN_CMD_PROC   *ppfnCmdProcList,
+                                                                                 IMG_UINT32             ui32MaxSyncsPerCmd[][2],
+                                                                                 IMG_UINT32             ui32CmdCount)
+{
+        SYS_DATA                                *psSysData;
+        PVRSRV_ERROR                    eError;
+        IMG_UINT32                              i;
+        IMG_SIZE_T                              ui32AllocSize;
+        PFN_CMD_PROC                    *ppfnCmdProc;
+        COMMAND_COMPLETE_DATA   *psCmdCompleteData;
+
+        
+        if(ui32DevIndex >= SYS_DEVICE_COUNT)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                        "PVRSRVRegisterCmdProcListKM: invalid DeviceType 0x%x",
+                                        ui32DevIndex));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        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");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc CC data"));
+                goto ErrorExit;
+        }
+
+        for (i=0; i<ui32CmdCount; i++)
+        {
+                
+
+                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)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterCmdProcListKM: Failed to alloc cmd %d",i));
+                        goto ErrorExit;
+                }
+
+                
+                OSMemSet(psSysData->ppsCmdCompleteData[ui32DevIndex][i], 0x00, ui32AllocSize);
+
+                psCmdCompleteData = psSysData->ppsCmdCompleteData[ui32DevIndex][i];
+
+                
+                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;
+        }
+
+        return PVRSRV_OK;
+
+ErrorExit:
+
+        
+
+        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(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;
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32 ui32DevIndex,
+                                                                           IMG_UINT32 ui32CmdCount)
+{
+        SYS_DATA                *psSysData;
+        IMG_UINT32              i;
+
+        
+        if(ui32DevIndex >= SYS_DEVICE_COUNT)
+        {
+                PVR_DPF((PVR_DBG_ERROR,
+                                        "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
+        {
+                for(i=0; i<ui32CmdCount; i++)
+                {
+                        
+                        if(psSysData->ppsCmdCompleteData[ui32DevIndex][i] != IMG_NULL)
+                        {
+                                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                                 psSysData->ppsCmdCompleteData[ui32DevIndex][i]->ui32AllocSize,
+                                                 psSysData->ppsCmdCompleteData[ui32DevIndex][i],
+                                                 IMG_NULL);
+                                psSysData->ppsCmdCompleteData[ui32DevIndex][i] = 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;
+        }
+
+        return PVRSRV_OK;
+}
+
diff --git a/drivers/gpu/pvr/queue.h b/drivers/gpu/pvr/queue.h
new file mode 100644
index 00000000000..06aa200140f
--- /dev/null
+++ b/drivers/gpu/pvr/queue.h
@@ -0,0 +1,114 @@
+/**********************************************************************
+ *
+ * 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 QUEUE_H
+#define QUEUE_H
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define UPDATE_QUEUE_ROFF(psQueue, ui32Size)                                            \
+        (psQueue)->ui32ReadOffset = ((psQueue)->ui32ReadOffset + (ui32Size))    \
+        & ((psQueue)->ui32QueueSize - 1);
+
+ typedef struct _COMMAND_COMPLETE_DATA_
+ {
+        IMG_BOOL                        bInUse;
+                
+        IMG_UINT32                      ui32DstSyncCount;       
+        IMG_UINT32                      ui32SrcSyncCount;       
+        PVRSRV_SYNC_OBJECT      *psDstSync;                     
+        PVRSRV_SYNC_OBJECT      *psSrcSync;                     
+        IMG_UINT32                      ui32AllocSize;          
+ }COMMAND_COMPLETE_DATA, *PCOMMAND_COMPLETE_DATA;
+
+#if !defined(USE_CODE)
+IMG_VOID QueueDumpDebugInfo(IMG_VOID);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVProcessQueues (IMG_UINT32    ui32CallerID,
+                                                                  IMG_BOOL              bFlush);
+
+#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);
+
+void* ProcSeqOff2ElementQueue(struct seq_file * sfile, loff_t off);
+void ProcSeqShowQueue(struct seq_file *sfile,void* el);
+#endif
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateCommandQueueKM(IMG_SIZE_T ui32QueueSize,
+                                                                                                         PVRSRV_QUEUE_INFO **ppsQueueInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyCommandQueueKM(PVRSRV_QUEUE_INFO *psQueueInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVInsertCommandKM(PVRSRV_QUEUE_INFO       *psQueue,
+                                                                                                PVRSRV_COMMAND          **ppsCommand,
+                                                                                                IMG_UINT32                      ui32DevIndex,
+                                                                                                IMG_UINT16                      CommandType,
+                                                                                                IMG_UINT32                      ui32DstSyncCount,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO *apsDstSync[],
+                                                                                                IMG_UINT32                      ui32SrcSyncCount,
+                                                                                                PVRSRV_KERNEL_SYNC_INFO *apsSrcSync[],
+                                                                                                IMG_SIZE_T                      ui32DataByteSize );
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetQueueSpaceKM(PVRSRV_QUEUE_INFO *psQueue,
+                                                                                                IMG_SIZE_T ui32ParamSize,
+                                                                                                IMG_VOID **ppvSpace);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSubmitCommandKM(PVRSRV_QUEUE_INFO *psQueue,
+                                                                                                PVRSRV_COMMAND *psCommand);
+
+IMG_IMPORT
+IMG_VOID PVRSRVCommandCompleteKM(IMG_HANDLE hCmdCookie, IMG_BOOL bScheduleMISR);
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVRegisterCmdProcListKM(IMG_UINT32             ui32DevIndex,
+                                                                                 PFN_CMD_PROC   *ppfnCmdProcList,
+                                                                                 IMG_UINT32             ui32MaxSyncsPerCmd[][2],
+                                                                                 IMG_UINT32             ui32CmdCount);
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVRemoveCmdProcListKM(IMG_UINT32       ui32DevIndex,
+                                                                           IMG_UINT32   ui32CmdCount);
+
+#endif 
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/ra.c b/drivers/gpu/pvr/ra.c
new file mode 100644
index 00000000000..191be844004
--- /dev/null
+++ b/drivers/gpu/pvr/ra.c
@@ -0,0 +1,1725 @@
+/**********************************************************************
+ *
+ * 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 "hash.h"
+#include "ra.h"
+#include "buffer_manager.h"
+#include "osfunc.h"
+
+#ifdef __linux__
+#include <linux/kernel.h>
+#include "proc.h"
+#endif
+
+#ifdef USE_BM_FREESPACE_CHECK
+#include <stdio.h>
+#endif
+
+#define MINIMUM_HASH_SIZE (64)
+
+#if defined(VALIDATE_ARENA_TEST)
+
+typedef enum RESOURCE_DESCRIPTOR_TAG {
+
+        RESOURCE_SPAN_LIVE                              = 10,
+        RESOURCE_SPAN_FREE,
+        IMPORTED_RESOURCE_SPAN_START,
+        IMPORTED_RESOURCE_SPAN_LIVE,
+        IMPORTED_RESOURCE_SPAN_FREE,
+        IMPORTED_RESOURCE_SPAN_END,
+
+} RESOURCE_DESCRIPTOR;
+
+typedef enum RESOURCE_TYPE_TAG {
+
+        IMPORTED_RESOURCE_TYPE          = 20,
+        NON_IMPORTED_RESOURCE_TYPE
+
+} RESOURCE_TYPE;
+
+
+static IMG_UINT32 ui32BoundaryTagID = 0;
+
+IMG_UINT32 ValidateArena(RA_ARENA *pArena);
+#endif
+
+struct _BT_
+{
+        enum bt_type
+        {
+                btt_span,                               
+                btt_free,                               
+                btt_live                                
+        } type;
+
+        
+        IMG_UINTPTR_T base;
+        IMG_SIZE_T uSize;
+
+        
+        struct _BT_ *pNextSegment;
+        struct _BT_ *pPrevSegment;
+        
+        struct _BT_ *pNextFree;
+        struct _BT_ *pPrevFree;
+        
+        BM_MAPPING *psMapping;
+
+#if defined(VALIDATE_ARENA_TEST)
+        RESOURCE_DESCRIPTOR eResourceSpan;
+        RESOURCE_TYPE           eResourceType;
+
+        
+        IMG_UINT32                      ui32BoundaryTagID;
+#endif
+
+};
+typedef struct _BT_ BT;
+
+
+struct _RA_ARENA_
+{
+        
+        IMG_CHAR *name;
+
+        
+        IMG_SIZE_T uQuantum;
+
+        
+        IMG_BOOL (*pImportAlloc)(IMG_VOID *,
+                                                         IMG_SIZE_T uSize,
+                                                         IMG_SIZE_T *pActualSize,
+                                                         BM_MAPPING **ppsMapping,
+                                                         IMG_UINT32 uFlags,
+                                                         IMG_UINTPTR_T *pBase);
+        IMG_VOID (*pImportFree) (IMG_VOID *,
+                                                 IMG_UINTPTR_T,
+                                                 BM_MAPPING *psMapping);
+        IMG_VOID (*pBackingStoreFree) (IMG_VOID *, IMG_SIZE_T, IMG_SIZE_T, IMG_HANDLE);
+
+        
+        IMG_VOID *pImportHandle;
+
+        
+#define FREE_TABLE_LIMIT 32
+
+        
+        BT *aHeadFree [FREE_TABLE_LIMIT];
+
+        
+        BT *pHeadSegment;
+        BT *pTailSegment;
+
+        
+        HASH_TABLE *pSegmentHash;
+
+#ifdef RA_STATS
+        RA_STATISTICS sStatistics;
+#endif
+
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
+#define PROC_NAME_SIZE          32
+
+        struct proc_dir_entry* pProcInfo;
+        struct proc_dir_entry* pProcSegs;
+
+        IMG_BOOL bInitProcEntry;
+#endif
+};
+#if defined(ENABLE_RA_DUMP)
+IMG_VOID RA_Dump (RA_ARENA *pArena);
+#endif
+
+#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);
+
+#endif 
+
+#ifdef USE_BM_FREESPACE_CHECK
+IMG_VOID CheckBMFreespace(IMG_VOID);
+#endif
+
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
+static IMG_CHAR *ReplaceSpaces(IMG_CHAR * const pS)
+{
+        IMG_CHAR *pT;
+
+        for(pT = pS; *pT != 0; pT++)
+        {
+                if (*pT == ' ' || *pT == '\t')
+                {
+                        *pT = '_';
+                }
+        }
+
+        return pS;
+}
+#endif
+
+static IMG_BOOL
+_RequestAllocFail (IMG_VOID *_h,
+                                  IMG_SIZE_T _uSize,
+                                  IMG_SIZE_T *_pActualSize,
+                                  BM_MAPPING **_ppsMapping,
+                                  IMG_UINT32 _uFlags,
+                                  IMG_UINTPTR_T *_pBase)
+{
+        PVR_UNREFERENCED_PARAMETER (_h);
+        PVR_UNREFERENCED_PARAMETER (_uSize);
+        PVR_UNREFERENCED_PARAMETER (_pActualSize);
+        PVR_UNREFERENCED_PARAMETER (_ppsMapping);
+        PVR_UNREFERENCED_PARAMETER (_uFlags);
+        PVR_UNREFERENCED_PARAMETER (_pBase);
+
+        return IMG_FALSE;
+}
+
+static IMG_UINT32
+pvr_log2 (IMG_SIZE_T n)
+{
+        IMG_UINT32 l = 0;
+        n>>=1;
+        while (n>0)
+        {
+                n>>=1;
+                l++;
+        }
+        return l;
+}
+
+static PVRSRV_ERROR
+_SegmentListInsertAfter (RA_ARENA *pArena,
+                                                 BT *pInsertionPoint,
+                                                 BT *pBT)
+{
+        PVR_ASSERT (pArena != IMG_NULL);
+        PVR_ASSERT (pInsertionPoint != IMG_NULL);
+
+        if ((pInsertionPoint == IMG_NULL) || (pArena == IMG_NULL))
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_SegmentListInsertAfter: invalid parameters"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        pBT->pNextSegment = pInsertionPoint->pNextSegment;
+        pBT->pPrevSegment = pInsertionPoint;
+        if (pInsertionPoint->pNextSegment == IMG_NULL)
+                pArena->pTailSegment = pBT;
+        else
+                pInsertionPoint->pNextSegment->pPrevSegment = pBT;
+        pInsertionPoint->pNextSegment = pBT;
+
+        return PVRSRV_OK;
+}
+
+static PVRSRV_ERROR
+_SegmentListInsert (RA_ARENA *pArena, BT *pBT)
+{
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        
+        if (pArena->pHeadSegment == IMG_NULL)
+        {
+                pArena->pHeadSegment = pArena->pTailSegment = pBT;
+                pBT->pNextSegment = pBT->pPrevSegment = IMG_NULL;
+        }
+        else
+        {
+                BT *pBTScan;
+
+                if (pBT->base < pArena->pHeadSegment->base)
+                {
+                        
+                        pBT->pNextSegment = pArena->pHeadSegment;
+                        pArena->pHeadSegment->pPrevSegment = pBT;
+                        pArena->pHeadSegment = pBT;
+                        pBT->pPrevSegment = IMG_NULL;
+                }
+                else
+                {
+
+                        
+
+
+                        pBTScan = pArena->pHeadSegment;
+
+                        while ((pBTScan->pNextSegment != IMG_NULL)  && (pBT->base >= pBTScan->pNextSegment->base))
+                        {
+                                pBTScan = pBTScan->pNextSegment;
+                        }
+
+                        eError = _SegmentListInsertAfter (pArena, pBTScan, pBT);
+                        if (eError != PVRSRV_OK)
+                        {
+                                return eError;
+                        }
+                }
+        }
+        return eError;
+}
+
+static IMG_VOID
+_SegmentListRemove (RA_ARENA *pArena, BT *pBT)
+{
+        if (pBT->pPrevSegment == IMG_NULL)
+                pArena->pHeadSegment = pBT->pNextSegment;
+        else
+                pBT->pPrevSegment->pNextSegment = pBT->pNextSegment;
+
+        if (pBT->pNextSegment == IMG_NULL)
+                pArena->pTailSegment = pBT->pPrevSegment;
+        else
+                pBT->pNextSegment->pPrevSegment = pBT->pPrevSegment;
+}
+
+static BT *
+_SegmentSplit (RA_ARENA *pArena, BT *pBT, IMG_SIZE_T uSize)
+{
+        BT *pNeighbour;
+
+        PVR_ASSERT (pArena != IMG_NULL);
+
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_SegmentSplit: invalid parameter - pArena"));
+                return IMG_NULL;
+        }
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        sizeof(BT),
+                                        (IMG_VOID **)&pNeighbour, IMG_NULL,
+                                        "Boundary Tag") != PVRSRV_OK)
+        {
+                return IMG_NULL;
+        }
+
+        OSMemSet(pNeighbour, 0, sizeof(BT));
+
+#if defined(VALIDATE_ARENA_TEST)
+        pNeighbour->ui32BoundaryTagID = ++ui32BoundaryTagID;
+#endif
+
+        pNeighbour->pPrevSegment = pBT;
+        pNeighbour->pNextSegment = pBT->pNextSegment;
+        if (pBT->pNextSegment == IMG_NULL)
+                pArena->pTailSegment = pNeighbour;
+        else
+                pBT->pNextSegment->pPrevSegment = pNeighbour;
+        pBT->pNextSegment = pNeighbour;
+
+        pNeighbour->type = btt_free;
+        pNeighbour->uSize = pBT->uSize - uSize;
+        pNeighbour->base = pBT->base + uSize;
+        pNeighbour->psMapping = pBT->psMapping;
+        pBT->uSize = uSize;
+
+#if defined(VALIDATE_ARENA_TEST)
+        if (pNeighbour->pPrevSegment->eResourceType == IMPORTED_RESOURCE_TYPE)
+        {
+                pNeighbour->eResourceType = IMPORTED_RESOURCE_TYPE;
+                pNeighbour->eResourceSpan = IMPORTED_RESOURCE_SPAN_FREE;
+        }
+        else if (pNeighbour->pPrevSegment->eResourceType == NON_IMPORTED_RESOURCE_TYPE)
+        {
+                pNeighbour->eResourceType = NON_IMPORTED_RESOURCE_TYPE;
+                pNeighbour->eResourceSpan = RESOURCE_SPAN_FREE;
+        }
+        else
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_SegmentSplit: pNeighbour->pPrevSegment->eResourceType unrecognized"));
+                PVR_DBG_BREAK;
+        }
+#endif
+
+        return pNeighbour;
+}
+
+static IMG_VOID
+_FreeListInsert (RA_ARENA *pArena, BT *pBT)
+{
+        IMG_UINT32 uIndex;
+        uIndex = pvr_log2 (pBT->uSize);
+        pBT->type = btt_free;
+        pBT->pNextFree = pArena->aHeadFree [uIndex];
+        pBT->pPrevFree = IMG_NULL;
+        if (pArena->aHeadFree[uIndex] != IMG_NULL)
+                pArena->aHeadFree[uIndex]->pPrevFree = pBT;
+        pArena->aHeadFree [uIndex] = pBT;
+}
+
+static IMG_VOID
+_FreeListRemove (RA_ARENA *pArena, BT *pBT)
+{
+        IMG_UINT32 uIndex;
+        uIndex = pvr_log2 (pBT->uSize);
+        if (pBT->pNextFree != IMG_NULL)
+                pBT->pNextFree->pPrevFree = pBT->pPrevFree;
+        if (pBT->pPrevFree == IMG_NULL)
+                pArena->aHeadFree[uIndex] = pBT->pNextFree;
+        else
+                pBT->pPrevFree->pNextFree = pBT->pNextFree;
+}
+
+static BT *
+_BuildSpanMarker (IMG_UINTPTR_T base, IMG_SIZE_T uSize)
+{
+        BT *pBT;
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        sizeof(BT),
+                                        (IMG_VOID **)&pBT, IMG_NULL,
+                                        "Boundary Tag") != PVRSRV_OK)
+        {
+                return IMG_NULL;
+        }
+
+        OSMemSet(pBT, 0, sizeof(BT));
+
+#if defined(VALIDATE_ARENA_TEST)
+        pBT->ui32BoundaryTagID = ++ui32BoundaryTagID;
+#endif
+
+        pBT->type = btt_span;
+        pBT->base = base;
+        pBT->uSize = uSize;
+        pBT->psMapping = IMG_NULL;
+
+        return pBT;
+}
+
+static BT *
+_BuildBT (IMG_UINTPTR_T base, IMG_SIZE_T uSize)
+{
+        BT *pBT;
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                        sizeof(BT),
+                                        (IMG_VOID **)&pBT, IMG_NULL,
+                                        "Boundary Tag") != PVRSRV_OK)
+        {
+                return IMG_NULL;
+        }
+
+        OSMemSet(pBT, 0, sizeof(BT));
+
+#if defined(VALIDATE_ARENA_TEST)
+        pBT->ui32BoundaryTagID = ++ui32BoundaryTagID;
+#endif
+
+        pBT->type = btt_free;
+        pBT->base = base;
+        pBT->uSize = uSize;
+
+        return pBT;
+}
+
+static BT *
+_InsertResource (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_SIZE_T uSize)
+{
+        BT *pBT;
+        PVR_ASSERT (pArena!=IMG_NULL);
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_InsertResource: invalid parameter - pArena"));
+                return IMG_NULL;
+        }
+
+        pBT = _BuildBT (base, uSize);
+        if (pBT != IMG_NULL)
+        {
+
+#if defined(VALIDATE_ARENA_TEST)
+                pBT->eResourceSpan = RESOURCE_SPAN_FREE;
+                pBT->eResourceType = NON_IMPORTED_RESOURCE_TYPE;
+#endif
+
+                if (_SegmentListInsert (pArena, pBT) != PVRSRV_OK)
+                {
+                        PVR_DPF ((PVR_DBG_ERROR,"_InsertResource: call to _SegmentListInsert failed"));
+                        return IMG_NULL;
+                }
+                _FreeListInsert (pArena, pBT);
+#ifdef RA_STATS
+                pArena->sStatistics.uTotalResourceCount+=uSize;
+                pArena->sStatistics.uFreeResourceCount+=uSize;
+                pArena->sStatistics.uSpanCount++;
+#endif
+        }
+        return pBT;
+}
+
+static BT *
+_InsertResourceSpan (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_SIZE_T uSize)
+{
+        PVRSRV_ERROR eError;
+        BT *pSpanStart;
+        BT *pSpanEnd;
+        BT *pBT;
+
+        PVR_ASSERT (pArena != IMG_NULL);
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_InsertResourceSpan: invalid parameter - pArena"));
+                return IMG_NULL;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_InsertResourceSpan: arena='%s', base=0x%x, size=0x%x",
+                          pArena->name, base, uSize));
+
+        pSpanStart = _BuildSpanMarker (base, uSize);
+        if (pSpanStart == IMG_NULL)
+        {
+                goto fail_start;
+        }
+
+#if defined(VALIDATE_ARENA_TEST)
+        pSpanStart->eResourceSpan = IMPORTED_RESOURCE_SPAN_START;
+        pSpanStart->eResourceType = IMPORTED_RESOURCE_TYPE;
+#endif
+
+        pSpanEnd = _BuildSpanMarker (base + uSize, 0);
+        if (pSpanEnd == IMG_NULL)
+        {
+                goto fail_end;
+        }
+
+#if defined(VALIDATE_ARENA_TEST)
+        pSpanEnd->eResourceSpan = IMPORTED_RESOURCE_SPAN_END;
+        pSpanEnd->eResourceType = IMPORTED_RESOURCE_TYPE;
+#endif
+
+        pBT = _BuildBT (base, uSize);
+        if (pBT == IMG_NULL)
+        {
+                goto fail_bt;
+        }
+
+#if defined(VALIDATE_ARENA_TEST)
+        pBT->eResourceSpan = IMPORTED_RESOURCE_SPAN_FREE;
+        pBT->eResourceType = IMPORTED_RESOURCE_TYPE;
+#endif
+
+        eError = _SegmentListInsert (pArena, pSpanStart);
+        if (eError != PVRSRV_OK)
+        {
+                goto fail_SegListInsert;
+        }
+
+        eError = _SegmentListInsertAfter (pArena, pSpanStart, pBT);
+        if (eError != PVRSRV_OK)
+        {
+                goto fail_SegListInsert;
+        }
+
+        _FreeListInsert (pArena, pBT);
+
+        eError = _SegmentListInsertAfter (pArena, pBT, pSpanEnd);
+        if (eError != PVRSRV_OK)
+        {
+                goto fail_SegListInsert;
+        }
+
+#ifdef RA_STATS
+        pArena->sStatistics.uTotalResourceCount+=uSize;
+#endif
+        return pBT;
+
+  fail_SegListInsert:
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pBT, IMG_NULL);
+        
+  fail_bt:
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pSpanEnd, IMG_NULL);
+        
+  fail_end:
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pSpanStart, IMG_NULL);
+        
+  fail_start:
+        return IMG_NULL;
+}
+
+static IMG_VOID
+_FreeBT (RA_ARENA *pArena, BT *pBT, IMG_BOOL bFreeBackingStore)
+{
+        BT *pNeighbour;
+        IMG_UINTPTR_T uOrigBase;
+        IMG_SIZE_T uOrigSize;
+
+        PVR_ASSERT (pArena!=IMG_NULL);
+        PVR_ASSERT (pBT!=IMG_NULL);
+
+        if ((pArena == IMG_NULL) || (pBT == IMG_NULL))
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_FreeBT: invalid parameter"));
+                return;
+        }
+
+#ifdef RA_STATS
+        pArena->sStatistics.uLiveSegmentCount--;
+        pArena->sStatistics.uFreeSegmentCount++;
+        pArena->sStatistics.uFreeResourceCount+=pBT->uSize;
+#endif
+
+        uOrigBase = pBT->base;
+        uOrigSize = pBT->uSize;
+
+        
+        pNeighbour = pBT->pPrevSegment;
+        if (pNeighbour!=IMG_NULL
+                && pNeighbour->type == btt_free
+                && pNeighbour->base + pNeighbour->uSize == pBT->base)
+        {
+                _FreeListRemove (pArena, pNeighbour);
+                _SegmentListRemove (pArena, pNeighbour);
+                pBT->base = pNeighbour->base;
+                pBT->uSize += pNeighbour->uSize;
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pNeighbour, IMG_NULL);
+                
+#ifdef RA_STATS
+                pArena->sStatistics.uFreeSegmentCount--;
+#endif
+        }
+
+        
+        pNeighbour = pBT->pNextSegment;
+        if (pNeighbour!=IMG_NULL
+                && pNeighbour->type == btt_free
+                && pBT->base + pBT->uSize == pNeighbour->base)
+        {
+                _FreeListRemove (pArena, pNeighbour);
+                _SegmentListRemove (pArena, pNeighbour);
+                pBT->uSize += pNeighbour->uSize;
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pNeighbour, IMG_NULL);
+                
+#ifdef RA_STATS
+                pArena->sStatistics.uFreeSegmentCount--;
+#endif
+        }
+
+        
+        if (pArena->pBackingStoreFree != IMG_NULL && bFreeBackingStore)
+        {
+                IMG_UINTPTR_T   uRoundedStart, uRoundedEnd;
+
+                
+                uRoundedStart = (uOrigBase / pArena->uQuantum) * pArena->uQuantum;
+                
+                if (uRoundedStart < pBT->base)
+                {
+                        uRoundedStart += pArena->uQuantum;
+                }
+
+                
+                uRoundedEnd = ((uOrigBase + uOrigSize + pArena->uQuantum - 1) / pArena->uQuantum) * pArena->uQuantum;
+                
+                if (uRoundedEnd > (pBT->base + pBT->uSize))
+                {
+                        uRoundedEnd -= pArena->uQuantum;
+                }
+
+                if (uRoundedStart < uRoundedEnd)
+                {
+                        pArena->pBackingStoreFree(pArena->pImportHandle, (IMG_SIZE_T)uRoundedStart, (IMG_SIZE_T)uRoundedEnd, (IMG_HANDLE)0);
+                }
+        }
+
+        if (pBT->pNextSegment!=IMG_NULL && pBT->pNextSegment->type == btt_span
+                && pBT->pPrevSegment!=IMG_NULL && pBT->pPrevSegment->type == btt_span)
+        {
+                BT *next = pBT->pNextSegment;
+                BT *prev = pBT->pPrevSegment;
+                _SegmentListRemove (pArena, next);
+                _SegmentListRemove (pArena, prev);
+                _SegmentListRemove (pArena, pBT);
+                pArena->pImportFree (pArena->pImportHandle, pBT->base, pBT->psMapping);
+#ifdef RA_STATS
+                pArena->sStatistics.uSpanCount--;
+                pArena->sStatistics.uExportCount++;
+                pArena->sStatistics.uFreeSegmentCount--;
+                pArena->sStatistics.uFreeResourceCount-=pBT->uSize;
+                pArena->sStatistics.uTotalResourceCount-=pBT->uSize;
+#endif
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), next, IMG_NULL);
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), prev, IMG_NULL);
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pBT, IMG_NULL);
+                
+        }
+        else
+                _FreeListInsert (pArena, pBT);
+}
+
+
+static IMG_BOOL
+_AttemptAllocAligned (RA_ARENA *pArena,
+                                          IMG_SIZE_T uSize,
+                                          BM_MAPPING **ppsMapping,
+                                          IMG_UINT32 uFlags,
+                                          IMG_UINT32 uAlignment,
+                                          IMG_UINT32 uAlignmentOffset,
+                                          IMG_UINTPTR_T *base)
+{
+        IMG_UINT32 uIndex;
+        PVR_ASSERT (pArena!=IMG_NULL);
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"_AttemptAllocAligned: invalid parameter - pArena"));
+                return IMG_FALSE;
+        }
+
+        if (uAlignment>1)
+                uAlignmentOffset %= uAlignment;
+
+        
+
+        uIndex = pvr_log2 (uSize);
+
+#if 0
+        
+        if (1u<<uIndex < uSize)
+                uIndex++;
+#endif
+
+        while (uIndex < FREE_TABLE_LIMIT && pArena->aHeadFree[uIndex]==IMG_NULL)
+                uIndex++;
+
+        while (uIndex < FREE_TABLE_LIMIT)
+        {
+                if (pArena->aHeadFree[uIndex]!=IMG_NULL)
+                {
+                        
+                        BT *pBT;
+
+                        pBT = pArena->aHeadFree [uIndex];
+                        while (pBT!=IMG_NULL)
+                        {
+                                IMG_UINTPTR_T aligned_base;
+
+                                if (uAlignment>1)
+                                        aligned_base = (pBT->base + uAlignmentOffset + uAlignment - 1) / uAlignment * uAlignment - uAlignmentOffset;
+                                else
+                                        aligned_base = pBT->base;
+                                PVR_DPF ((PVR_DBG_MESSAGE,
+                                                  "RA_AttemptAllocAligned: pBT-base=0x%x "
+                                                  "pBT-size=0x%x alignedbase=0x%x size=0x%x",
+                                                pBT->base, pBT->uSize, aligned_base, uSize));
+
+                                if (pBT->base + pBT->uSize >= aligned_base + uSize)
+                                {
+                                        if(!pBT->psMapping || pBT->psMapping->ui32Flags == uFlags)
+                                        {
+                                                _FreeListRemove (pArena, pBT);
+
+                                                PVR_ASSERT (pBT->type == btt_free);
+
+#ifdef RA_STATS
+                                                pArena->sStatistics.uLiveSegmentCount++;
+                                                pArena->sStatistics.uFreeSegmentCount--;
+                                                pArena->sStatistics.uFreeResourceCount-=pBT->uSize;
+#endif
+
+                                                
+                                                if (aligned_base > pBT->base)
+                                                {
+                                                        BT *pNeighbour;
+                                                        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);
+                                                                return IMG_FALSE;
+                                                        }
+
+                                                        _FreeListInsert (pArena, pBT);
+        #ifdef RA_STATS
+                                                        pArena->sStatistics.uFreeSegmentCount++;
+                                                        pArena->sStatistics.uFreeResourceCount+=pBT->uSize;
+        #endif
+                                                        pBT = pNeighbour;
+                                                }
+
+                                                
+                                                if (pBT->uSize > uSize)
+                                                {
+                                                        BT *pNeighbour;
+                                                        pNeighbour = _SegmentSplit (pArena, pBT, uSize);
+                                                        
+                                                        if (pNeighbour==IMG_NULL)
+                                                        {
+                                                                PVR_DPF ((PVR_DBG_ERROR,"_AttemptAllocAligned: Back split failed"));
+                                                                
+                                                                _FreeListInsert (pArena, pBT);
+                                                                return IMG_FALSE;
+                                                        }
+
+                                                        _FreeListInsert (pArena, pNeighbour);
+        #ifdef RA_STATS
+                                                        pArena->sStatistics.uFreeSegmentCount++;
+                                                        pArena->sStatistics.uFreeResourceCount+=pNeighbour->uSize;
+        #endif
+                                                }
+
+                                                pBT->type = btt_live;
+
+#if defined(VALIDATE_ARENA_TEST)
+                                                if (pBT->eResourceType == IMPORTED_RESOURCE_TYPE)
+                                                {
+                                                        pBT->eResourceSpan = IMPORTED_RESOURCE_SPAN_LIVE;
+                                                }
+                                                else if (pBT->eResourceType == NON_IMPORTED_RESOURCE_TYPE)
+                                                {
+                                                        pBT->eResourceSpan = RESOURCE_SPAN_LIVE;
+                                                }
+                                                else
+                                                {
+                                                        PVR_DPF ((PVR_DBG_ERROR,"_AttemptAllocAligned ERROR: pBT->eResourceType unrecognized"));
+                                                        PVR_DBG_BREAK;
+                                                }
+#endif
+                                                if (!HASH_Insert (pArena->pSegmentHash, pBT->base, (IMG_UINTPTR_T) pBT))
+                                                {
+                                                        _FreeBT (pArena, pBT, IMG_FALSE);
+                                                        return IMG_FALSE;
+                                                }
+
+                                                if (ppsMapping!=IMG_NULL)
+                                                        *ppsMapping = pBT->psMapping;
+
+                                                *base = pBT->base;
+
+                                                return IMG_TRUE;
+                                        }
+                                        else
+                                        {
+                                                PVR_DPF ((PVR_DBG_MESSAGE,
+                                                                "AttemptAllocAligned: mismatch in flags. Import has %x, request was %x", pBT->psMapping->ui32Flags, uFlags));
+
+                                        }
+                                }
+                                pBT = pBT->pNextFree;
+                        }
+
+                }
+                uIndex++;
+        }
+
+        return IMG_FALSE;
+}
+
+
+
+RA_ARENA *
+RA_Create (IMG_CHAR *name,
+                   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,
+                                     BM_MAPPING **ppsMapping, IMG_UINT32 _flags, IMG_UINTPTR_T *pBase),
+                   IMG_VOID (*imp_free) (IMG_VOID *, IMG_UINTPTR_T, BM_MAPPING *),
+                   IMG_VOID (*backingstore_free) (IMG_VOID*, IMG_SIZE_T, IMG_SIZE_T, IMG_HANDLE),
+                   IMG_VOID *pImportHandle)
+{
+        RA_ARENA *pArena;
+        BT *pBT;
+        IMG_INT i;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_Create: name='%s', base=0x%x, uSize=0x%x, alloc=0x%x, free=0x%x",
+                          name, base, uSize, (IMG_UINTPTR_T)imp_alloc, (IMG_UINTPTR_T)imp_free));
+
+
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof (*pArena),
+                                         (IMG_VOID **)&pArena, IMG_NULL,
+                                         "Resource Arena") != PVRSRV_OK)
+        {
+                goto arena_fail;
+        }
+
+        pArena->name = name;
+        pArena->pImportAlloc = (imp_alloc!=IMG_NULL) ? imp_alloc : &_RequestAllocFail;
+        pArena->pImportFree = imp_free;
+        pArena->pBackingStoreFree = backingstore_free;
+        pArena->pImportHandle = pImportHandle;
+        for (i=0; i<FREE_TABLE_LIMIT; i++)
+                pArena->aHeadFree[i] = IMG_NULL;
+        pArena->pHeadSegment = IMG_NULL;
+        pArena->pTailSegment = IMG_NULL;
+        pArena->uQuantum = uQuantum;
+
+#ifdef RA_STATS
+        pArena->sStatistics.uSpanCount = 0;
+        pArena->sStatistics.uLiveSegmentCount = 0;
+        pArena->sStatistics.uFreeSegmentCount = 0;
+        pArena->sStatistics.uFreeResourceCount = 0;
+        pArena->sStatistics.uTotalResourceCount = 0;
+        pArena->sStatistics.uCumulativeAllocs = 0;
+        pArena->sStatistics.uCumulativeFrees = 0;
+        pArena->sStatistics.uImportCount = 0;
+        pArena->sStatistics.uExportCount = 0;
+#endif
+
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
+        if(strcmp(pArena->name,"") != 0)
+        {
+                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,
+                                                                                 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,
+                                                                                         RA_ProcSeqShowInfo, RA_ProcSeqOff2ElementInfo, NULL, NULL);
+                }
+                else
+                {
+                        pArena->pProcInfo = 0;
+                        PVR_DPF((PVR_DBG_ERROR, "RA_Create: couldn't create ra_info proc entry for arena %s", pArena->name));
+                }
+
+                ret = snprintf(szProcSegsName, sizeof(szProcSegsName), "ra_segs_%s", pArena->name);
+                if (ret > 0 && ret < sizeof(szProcInfoName))
+                {
+                        pArena->pProcSegs = pfnCreateProcEntrySeq(ReplaceSpaces(szProcSegsName), pArena, NULL,
+                                                                                         RA_ProcSeqShowRegs, RA_ProcSeqOff2ElementRegs, 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 
+
+        pArena->pSegmentHash = HASH_Create (MINIMUM_HASH_SIZE);
+        if (pArena->pSegmentHash==IMG_NULL)
+        {
+                goto hash_fail;
+        }
+        if (uSize>0)
+        {
+                uSize = (uSize + uQuantum - 1) / uQuantum * uQuantum;
+                pBT = _InsertResource (pArena, base, uSize);
+                if (pBT == IMG_NULL)
+                {
+                        goto insert_fail;
+                }
+                pBT->psMapping = psMapping;
+
+        }
+        return pArena;
+
+insert_fail:
+        HASH_Delete (pArena->pSegmentHash);
+hash_fail:
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RA_ARENA), pArena, IMG_NULL);
+        
+arena_fail:
+        return IMG_NULL;
+}
+
+IMG_VOID
+RA_Delete (RA_ARENA *pArena)
+{
+        IMG_UINT32 uIndex;
+
+        PVR_ASSERT(pArena != IMG_NULL);
+
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"RA_Delete: invalid parameter - pArena"));
+                return;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_Delete: name='%s'", pArena->name));
+
+        for (uIndex=0; uIndex<FREE_TABLE_LIMIT; uIndex++)
+                pArena->aHeadFree[uIndex] = IMG_NULL;
+
+        while (pArena->pHeadSegment != IMG_NULL)
+        {
+                BT *pBT = pArena->pHeadSegment;
+
+                if (pBT->type != btt_free)
+                {
+                        PVR_DPF ((PVR_DBG_ERROR,"RA_Delete: allocations still exist in the arena that is being destroyed"));
+                        PVR_DPF ((PVR_DBG_ERROR,"Likely Cause: client drivers not freeing alocations before destroying devmemcontext"));
+                        PVR_DPF ((PVR_DBG_ERROR,"RA_Delete: base = 0x%x size=0x%x", pBT->base, pBT->uSize));
+                }
+
+                _SegmentListRemove (pArena, pBT);
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BT), pBT, IMG_NULL);
+                
+#ifdef RA_STATS
+                pArena->sStatistics.uSpanCount--;
+#endif
+        }
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
+        {
+                IMG_VOID (*pfnRemoveProcEntrySeq)(struct proc_dir_entry*);
+
+                pfnRemoveProcEntrySeq = pArena->bInitProcEntry ? RemoveProcEntrySeq : RemovePerProcessProcEntrySeq;
+
+                if (pArena->pProcInfo != 0)
+                {
+                        pfnRemoveProcEntrySeq( pArena->pProcInfo );
+                }
+
+                if (pArena->pProcSegs != 0)
+                {
+                        pfnRemoveProcEntrySeq( pArena->pProcSegs );
+                }
+        }
+#endif
+        HASH_Delete (pArena->pSegmentHash);
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RA_ARENA), pArena, IMG_NULL);
+        
+}
+
+IMG_BOOL
+RA_TestDelete (RA_ARENA *pArena)
+{
+        PVR_ASSERT(pArena != IMG_NULL);
+
+        if (pArena != IMG_NULL)
+        {
+                while (pArena->pHeadSegment != IMG_NULL)
+                {
+                        BT *pBT = pArena->pHeadSegment;
+                        if (pBT->type != btt_free)
+                        {
+                                PVR_DPF ((PVR_DBG_ERROR,"RA_TestDelete: detected resource leak!"));
+                                PVR_DPF ((PVR_DBG_ERROR,"RA_TestDelete: base = 0x%x size=0x%x", pBT->base, pBT->uSize));
+                                return IMG_FALSE;
+                        }
+                }
+        }
+
+        return IMG_TRUE;
+}
+
+IMG_BOOL
+RA_Add (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_SIZE_T uSize)
+{
+        PVR_ASSERT (pArena != IMG_NULL);
+
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"RA_Add: invalid parameter - pArena"));
+                return IMG_FALSE;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_Add: name='%s', base=0x%x, size=0x%x", pArena->name, base, uSize));
+
+        uSize = (uSize + pArena->uQuantum - 1) / pArena->uQuantum * pArena->uQuantum;
+        return ((IMG_BOOL)(_InsertResource (pArena, base, uSize) != IMG_NULL));
+}
+
+IMG_BOOL
+RA_Alloc (RA_ARENA *pArena,
+                  IMG_SIZE_T uRequestSize,
+                  IMG_SIZE_T *pActualSize,
+                  BM_MAPPING **ppsMapping,
+                  IMG_UINT32 uFlags,
+                  IMG_UINT32 uAlignment,
+                  IMG_UINT32 uAlignmentOffset,
+                  IMG_UINTPTR_T *base)
+{
+        IMG_BOOL bResult;
+        IMG_SIZE_T uSize = uRequestSize;
+
+        PVR_ASSERT (pArena!=IMG_NULL);
+
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"RA_Alloc: invalid parameter - pArena"));
+                return IMG_FALSE;
+        }
+
+#if defined(VALIDATE_ARENA_TEST)
+        ValidateArena(pArena);
+#endif
+
+#ifdef USE_BM_FREESPACE_CHECK
+        CheckBMFreespace();
+#endif
+
+        if (pActualSize != IMG_NULL)
+        {
+                *pActualSize = uSize;
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_Alloc: arena='%s', size=0x%x(0x%x), alignment=0x%x, offset=0x%x",
+                   pArena->name, uSize, uRequestSize, uAlignment, uAlignmentOffset));
+
+        
+
+        bResult = _AttemptAllocAligned (pArena, uSize, ppsMapping, uFlags,
+                                                                        uAlignment, uAlignmentOffset, base);
+        if (!bResult)
+        {
+                BM_MAPPING *psImportMapping;
+                IMG_UINTPTR_T import_base;
+                IMG_SIZE_T uImportSize = uSize;
+
+                
+
+
+                if (uAlignment > pArena->uQuantum)
+                {
+                        uImportSize += (uAlignment - 1);
+                }
+
+                
+                uImportSize = ((uImportSize + pArena->uQuantum - 1)/pArena->uQuantum)*pArena->uQuantum;
+
+                bResult =
+                        pArena->pImportAlloc (pArena->pImportHandle, uImportSize, &uImportSize,
+                                                                 &psImportMapping, uFlags, &import_base);
+                if (bResult)
+                {
+                        BT *pBT;
+                        pBT = _InsertResourceSpan (pArena, import_base, uImportSize);
+                        
+                        if (pBT == IMG_NULL)
+                        {
+                                
+                                pArena->pImportFree(pArena->pImportHandle, import_base,
+                                                                        psImportMapping);
+                                PVR_DPF ((PVR_DBG_MESSAGE,
+                                                  "RA_Alloc: name='%s', size=0x%x failed!",
+                                                  pArena->name, uSize));
+                                
+                                return IMG_FALSE;
+                        }
+                        pBT->psMapping = psImportMapping;
+#ifdef RA_STATS
+                        pArena->sStatistics.uFreeSegmentCount++;
+                        pArena->sStatistics.uFreeResourceCount += uImportSize;
+                        pArena->sStatistics.uImportCount++;
+                        pArena->sStatistics.uSpanCount++;
+#endif
+                        bResult = _AttemptAllocAligned(pArena, uSize, ppsMapping, uFlags,
+                                                                                   uAlignment, uAlignmentOffset,
+                                                                                   base);
+                        if (!bResult)
+                        {
+                                PVR_DPF ((PVR_DBG_MESSAGE,
+                                                  "RA_Alloc: name='%s' uAlignment failed!",
+                                                  pArena->name));
+                        }
+                }
+        }
+#ifdef RA_STATS
+        if (bResult)
+                pArena->sStatistics.uCumulativeAllocs++;
+#endif
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                          "RA_Alloc: name='%s', size=0x%x, *base=0x%x = %d",
+                          pArena->name, uSize, *base, bResult));
+
+        
+
+#if defined(VALIDATE_ARENA_TEST)
+        ValidateArena(pArena);
+#endif
+
+        return bResult;
+}
+
+
+#if defined(VALIDATE_ARENA_TEST)
+
+IMG_UINT32 ValidateArena(RA_ARENA *pArena)
+{
+        BT* pSegment;
+        RESOURCE_DESCRIPTOR eNextSpan;
+
+        pSegment = pArena->pHeadSegment;
+
+        if (pSegment == IMG_NULL)
+        {
+                return 0;
+        }
+
+        if (pSegment->eResourceType == IMPORTED_RESOURCE_TYPE)
+        {
+                PVR_ASSERT(pSegment->eResourceSpan == IMPORTED_RESOURCE_SPAN_START);
+
+                while (pSegment->pNextSegment)
+                {
+                        eNextSpan = pSegment->pNextSegment->eResourceSpan;
+
+                        switch (pSegment->eResourceSpan)
+                        {
+                                case IMPORTED_RESOURCE_SPAN_LIVE:
+
+                                        if (!((eNextSpan == IMPORTED_RESOURCE_SPAN_LIVE) ||
+                                                  (eNextSpan == IMPORTED_RESOURCE_SPAN_FREE) ||
+                                                  (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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                                PVR_DBG_BREAK;
+                                        }
+                                break;
+
+                                case IMPORTED_RESOURCE_SPAN_FREE:
+
+                                        if (!((eNextSpan == IMPORTED_RESOURCE_SPAN_LIVE) ||
+                                                  (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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                                PVR_DBG_BREAK;
+                                        }
+                                break;
+
+                                case IMPORTED_RESOURCE_SPAN_END:
+
+                                        if ((eNextSpan == IMPORTED_RESOURCE_SPAN_LIVE) ||
+                                                (eNextSpan == IMPORTED_RESOURCE_SPAN_FREE) ||
+                                                (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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                                PVR_DBG_BREAK;
+                                        }
+                                break;
+
+
+                                case IMPORTED_RESOURCE_SPAN_START:
+
+                                        if (!((eNextSpan == IMPORTED_RESOURCE_SPAN_LIVE) ||
+                                                  (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)",
+                                                                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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                        PVR_DBG_BREAK;
+                                break;
+                        }
+                        pSegment = pSegment->pNextSegment;
+                }
+        }
+        else if (pSegment->eResourceType == NON_IMPORTED_RESOURCE_TYPE)
+        {
+                PVR_ASSERT((pSegment->eResourceSpan == RESOURCE_SPAN_FREE) || (pSegment->eResourceSpan == RESOURCE_SPAN_LIVE));
+
+                while (pSegment->pNextSegment)
+                {
+                        eNextSpan = pSegment->pNextSegment->eResourceSpan;
+
+                        switch (pSegment->eResourceSpan)
+                        {
+                                case RESOURCE_SPAN_LIVE:
+
+                                        if (!((eNextSpan == RESOURCE_SPAN_FREE) ||
+                                                  (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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                                PVR_DBG_BREAK;
+                                        }
+                                break;
+
+                                case RESOURCE_SPAN_FREE:
+
+                                        if (!((eNextSpan == RESOURCE_SPAN_FREE) ||
+                                                  (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)",
+                                                                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)",
+                                                                pSegment->ui32BoundaryTagID, pSegment->base, pSegment->pNextSegment->ui32BoundaryTagID, pSegment->pNextSegment->base, pArena->name));
+
+                                        PVR_DBG_BREAK;
+                                break;
+                        }
+                        pSegment = pSegment->pNextSegment;
+                }
+
+        }
+        else
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"ValidateArena ERROR: pSegment->eResourceType unrecognized"));
+
+                PVR_DBG_BREAK;
+        }
+
+        return 0;
+}
+
+#endif
+
+
+IMG_VOID
+RA_Free (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_BOOL bFreeBackingStore)
+{
+        BT *pBT;
+
+        PVR_ASSERT (pArena != IMG_NULL);
+
+        if (pArena == IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_ERROR,"RA_Free: invalid parameter - pArena"));
+                return;
+        }
+
+#ifdef USE_BM_FREESPACE_CHECK
+        CheckBMFreespace();
+#endif
+
+        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)
+        {
+                PVR_ASSERT (pBT->base == base);
+
+#ifdef RA_STATS
+                pArena->sStatistics.uCumulativeFrees++;
+#endif
+
+#ifdef USE_BM_FREESPACE_CHECK
+{
+        IMG_BYTE* p;
+        IMG_BYTE* endp;
+
+        p = (IMG_BYTE*)pBT->base + SysGetDevicePhysOffset();
+        endp = (IMG_BYTE*)((IMG_UINT32)(p + pBT->uSize));
+        while ((IMG_UINT32)p & 3)
+        {
+                *p++ = 0xAA;
+        }
+        while (p < (IMG_BYTE*)((IMG_UINT32)endp & 0xfffffffc))
+        {
+                *(IMG_UINT32*)p = 0xAAAAAAAA;
+                p += sizeof(IMG_UINT32);
+        }
+        while (p < endp)
+        {
+                *p++ = 0xAA;
+        }
+        PVR_DPF((PVR_DBG_MESSAGE,"BM_FREESPACE_CHECK: RA_Free Cleared %08X to %08X (size=0x%x)",(IMG_BYTE*)pBT->base + SysGetDevicePhysOffset(),endp-1,pBT->uSize));
+}
+#endif
+                _FreeBT (pArena, pBT, bFreeBackingStore);
+        }
+}
+
+
+IMG_BOOL RA_GetNextLiveSegment(IMG_HANDLE hArena, RA_SEGMENT_DETAILS *psSegDetails)
+{
+        BT        *pBT;
+
+        if (psSegDetails->hSegment)
+        {
+                pBT = (BT *)psSegDetails->hSegment;
+        }
+        else
+        {
+                RA_ARENA *pArena = (RA_ARENA *)hArena;
+
+                pBT = pArena->pHeadSegment;
+        }
+        
+        while (pBT != IMG_NULL)
+        {
+                if (pBT->type == btt_live)
+                {
+                        psSegDetails->uiSize = pBT->uSize;
+                        psSegDetails->sCpuPhyAddr.uiAddr = pBT->base;
+                        psSegDetails->hSegment = (IMG_HANDLE)pBT->pNextSegment;
+
+                        return IMG_TRUE;
+                }
+
+                pBT = pBT->pNextSegment;
+        }
+
+        psSegDetails->uiSize = 0;
+        psSegDetails->sCpuPhyAddr.uiAddr = 0;
+        psSegDetails->hSegment = (IMG_HANDLE)IMG_UNDEF;
+
+        return IMG_FALSE;
+}
+
+
+#ifdef USE_BM_FREESPACE_CHECK
+RA_ARENA* pJFSavedArena = IMG_NULL;
+
+IMG_VOID CheckBMFreespace(IMG_VOID)
+{
+        BT *pBT;
+        IMG_BYTE* p;
+        IMG_BYTE* endp;
+
+        if (pJFSavedArena != IMG_NULL)
+        {
+                for (pBT=pJFSavedArena->pHeadSegment; pBT!=IMG_NULL; pBT=pBT->pNextSegment)
+                {
+                        if (pBT->type == btt_free)
+                        {
+                                p = (IMG_BYTE*)pBT->base + SysGetDevicePhysOffset();
+                                endp = (IMG_BYTE*)((IMG_UINT32)(p + pBT->uSize) & 0xfffffffc);
+
+                                while ((IMG_UINT32)p & 3)
+                                {
+                                        if (*p++ != 0xAA)
+                                        {
+                                                fprintf(stderr,"BM_FREESPACE_CHECK: Blank space at %08X has changed to 0x%x\n",p,*(IMG_UINT32*)p);
+                                                for (;;);
+                                                break;
+                                        }
+                                }
+                                while (p < endp)
+                                {
+                                        if (*(IMG_UINT32*)p != 0xAAAAAAAA)
+                                        {
+                                                fprintf(stderr,"BM_FREESPACE_CHECK: Blank space at %08X has changed to 0x%x\n",p,*(IMG_UINT32*)p);
+                                                for (;;);
+                                                break;
+                                        }
+                                        p += 4;
+                                }
+                        }
+                }
+        }
+}
+#endif
+
+
+#if (defined(CONFIG_PROC_FS) && defined(DEBUG)) || defined (RA_STATS)
+static IMG_CHAR *
+_BTType (IMG_INT eType)
+{
+        switch (eType)
+        {
+        case btt_span: return "span";
+        case btt_free: return "free";
+        case btt_live: return "live";
+        }
+        return "junk";
+}
+#endif 
+
+#if defined(ENABLE_RA_DUMP)
+IMG_VOID
+RA_Dump (RA_ARENA *pArena)
+{
+        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",
+                         pArena->pImportAlloc, pArena->pImportFree, pArena->pImportHandle,
+                         pArena->uQuantum));
+        PVR_DPF ((PVR_DBG_MESSAGE,"  segment Chain:"));
+        if (pArena->pHeadSegment != IMG_NULL &&
+            pArena->pHeadSegment->pPrevSegment != IMG_NULL)
+                PVR_DPF ((PVR_DBG_MESSAGE,"  error: head boundary tag has invalid pPrevSegment"));
+        if (pArena->pTailSegment != IMG_NULL &&
+            pArena->pTailSegment->pNextSegment != IMG_NULL)
+                PVR_DPF ((PVR_DBG_MESSAGE,"  error: tail boundary tag has invalid pNextSegment"));
+
+        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",
+                                 (IMG_UINT32) pBT->base, pBT->uSize, _BTType (pBT->type),
+                                 pBT->pRef));
+        }
+
+#ifdef HASH_TRACE
+        HASH_Dump (pArena->pSegmentHash);
+#endif
+}
+#endif 
+
+
+#if defined(CONFIG_PROC_FS) && defined(DEBUG)
+
+
+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;
+        IMG_INT off = (IMG_INT)el;
+
+        switch (off)
+        {
+        case 1:
+                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%u\n", pArena->sStatistics.uSpanCount);
+                break;
+        case 4:
+                seq_printf(sfile, "live segment count\t%u\n", pArena->sStatistics.uLiveSegmentCount);
+                break;
+        case 5:
+                seq_printf(sfile, "free segment count\t%u\n", pArena->sStatistics.uFreeSegmentCount);
+                break;
+        case 6:
+                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%u\n", pArena->sStatistics.uCumulativeAllocs);
+                break;
+        case 8:
+                seq_printf(sfile, "total frees\t\t%u\n", pArena->sStatistics.uCumulativeFrees);
+                break;
+        case 9:
+                seq_printf(sfile, "import count\t\t%u\n", pArena->sStatistics.uImportCount);
+                break;
+        case 10:
+                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)
+#else
+        if(off <= 1)
+#endif
+                return (void*)(IMG_INT)(off+1);
+        return 0;
+}
+
+static void RA_ProcSeqShowRegs(struct seq_file *sfile, void* el)
+{
+        PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)sfile->private;
+        RA_ARENA *pArena = (RA_ARENA *)handlers->data;
+        BT *pBT = (BT*)el;
+
+        if (el == PVR_PROC_SEQ_START_TOKEN)
+        {
+                seq_printf(sfile, "Arena \"%s\"\nBase         Size Type Ref\n", pArena->name);
+                return;
+        }
+
+        if (pBT)
+        {
+                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)
+{
+        PVR_PROC_SEQ_HANDLERS *handlers = (PVR_PROC_SEQ_HANDLERS*)sfile->private;
+        RA_ARENA *pArena = (RA_ARENA *)handlers->data;
+        BT *pBT = 0;
+
+        if(off == 0)
+                return PVR_PROC_SEQ_START_TOKEN;
+
+        for (pBT=pArena->pHeadSegment; --off && pBT; pBT=pBT->pNextSegment);
+
+        return (void*)pBT;
+}
+
+#endif 
+
+
+#ifdef RA_STATS
+PVRSRV_ERROR RA_GetStats(RA_ARENA *pArena,
+                                                        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=%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%u\n", pArena->sStatistics.uSpanCount);
+        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+
+        CHECK_SPACE(ui32StrLen);
+        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%u\n", pArena->sStatistics.uFreeSegmentCount);
+        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+
+        CHECK_SPACE(ui32StrLen);
+        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%u\n", pArena->sStatistics.uCumulativeAllocs);
+        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+
+        CHECK_SPACE(ui32StrLen);
+        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%u\n", pArena->sStatistics.uImportCount);
+        UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+
+        CHECK_SPACE(ui32StrLen);
+        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)
+        {
+                CHECK_SPACE(ui32StrLen);
+                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)
+        {
+                CHECK_SPACE(ui32StrLen);
+                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=%p\n",
+                                                                                         (IMG_UINT32) pBT->base,
+                                                                                         pBT->uSize,
+                                                                                         _BTType(pBT->type),
+                                                                                         pBT->psMapping);
+                UPDATE_SPACE(pszStr, i32Count, ui32StrLen);
+        }
+
+        *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;
+}
+#endif
+
diff --git a/drivers/gpu/pvr/ra.h b/drivers/gpu/pvr/ra.h
new file mode 100644
index 00000000000..f28ce4cd755
--- /dev/null
+++ b/drivers/gpu/pvr/ra.h
@@ -0,0 +1,159 @@
+/**********************************************************************
+ *
+ * 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 _RA_H_
+#define _RA_H_
+
+#include "img_types.h"
+#include "hash.h"
+#include "osfunc.h"
+
+typedef struct _RA_ARENA_ RA_ARENA;                     
+typedef struct _BM_MAPPING_ BM_MAPPING;
+
+
+
+#define RA_STATS 
+
+
+struct _RA_STATISTICS_
+{
+    
+    IMG_SIZE_T uSpanCount;
+
+    
+    IMG_SIZE_T uLiveSegmentCount;
+
+    
+    IMG_SIZE_T uFreeSegmentCount;
+
+    
+    IMG_SIZE_T uTotalResourceCount;
+    
+    
+    IMG_SIZE_T uFreeResourceCount;
+
+    
+    IMG_SIZE_T uCumulativeAllocs;
+
+    
+    IMG_SIZE_T uCumulativeFrees;
+
+    
+    IMG_SIZE_T uImportCount;
+
+    
+    IMG_SIZE_T uExportCount;
+};
+typedef struct _RA_STATISTICS_ RA_STATISTICS;
+
+struct _RA_SEGMENT_DETAILS_
+{
+        IMG_SIZE_T      uiSize;
+        IMG_CPU_PHYADDR sCpuPhyAddr;
+        IMG_HANDLE      hSegment;
+};
+typedef struct _RA_SEGMENT_DETAILS_ RA_SEGMENT_DETAILS;
+
+RA_ARENA *
+RA_Create (IMG_CHAR *name,
+           IMG_UINTPTR_T base,
+           IMG_SIZE_T uSize,
+           BM_MAPPING *psMapping,
+           IMG_SIZE_T uQuantum, 
+           IMG_BOOL (*imp_alloc)(IMG_VOID *_h,
+                                IMG_SIZE_T uSize,
+                                IMG_SIZE_T *pActualSize,
+                                BM_MAPPING **ppsMapping,
+                                IMG_UINT32 uFlags,
+                                IMG_UINTPTR_T *pBase),
+           IMG_VOID (*imp_free) (IMG_VOID *,
+                                IMG_UINTPTR_T,
+                                BM_MAPPING *),
+           IMG_VOID (*backingstore_free) (IMG_VOID *,
+                                          IMG_SIZE_T,
+                                          IMG_SIZE_T,
+                                          IMG_HANDLE),
+           IMG_VOID *import_handle);
+
+IMG_VOID
+RA_Delete (RA_ARENA *pArena);
+
+IMG_BOOL
+RA_TestDelete (RA_ARENA *pArena);
+
+IMG_BOOL
+RA_Add (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_SIZE_T uSize);
+
+IMG_BOOL
+RA_Alloc (RA_ARENA *pArena, 
+          IMG_SIZE_T uSize,
+          IMG_SIZE_T *pActualSize,
+          BM_MAPPING **ppsMapping, 
+          IMG_UINT32 uFlags,
+          IMG_UINT32 uAlignment,
+                  IMG_UINT32 uAlignmentOffset,
+          IMG_UINTPTR_T *pBase);
+
+IMG_VOID 
+RA_Free (RA_ARENA *pArena, IMG_UINTPTR_T base, IMG_BOOL bFreeBackingStore);
+
+
+#ifdef RA_STATS
+
+#define CHECK_SPACE(total)                                      \
+{                                                                                       \
+        if((total)<100)                                                         \
+                return PVRSRV_ERROR_INVALID_PARAMS;     \
+}
+
+#define UPDATE_SPACE(str, count, total)         \
+{                                                                                       \
+        if((count) == -1)                                                       \
+                return PVRSRV_ERROR_INVALID_PARAMS;     \
+        else                                                                    \
+        {                                                                               \
+                (str) += (count);                                               \
+                (total) -= (count);                                             \
+        }                                                                               \
+}
+
+
+IMG_BOOL RA_GetNextLiveSegment(IMG_HANDLE hArena, RA_SEGMENT_DETAILS *psSegDetails);
+
+
+PVRSRV_ERROR RA_GetStats(RA_ARENA *pArena,
+                                                        IMG_CHAR **ppszStr, 
+                                                        IMG_UINT32 *pui32StrLen);
+
+PVRSRV_ERROR RA_GetStatsFreeMem(RA_ARENA *pArena,
+                                                                IMG_CHAR **ppszStr, 
+                                                                IMG_UINT32 *pui32StrLen);
+
+#endif 
+
+#endif
+
diff --git a/drivers/gpu/pvr/regpaths.h b/drivers/gpu/pvr/regpaths.h
new file mode 100644
index 00000000000..a551eff4e76
--- /dev/null
+++ b/drivers/gpu/pvr/regpaths.h
@@ -0,0 +1,43 @@
+/**********************************************************************
+ *
+ * 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 __REGPATHS_H__
+#define __REGPATHS_H__
+
+#define POWERVR_REG_ROOT                                "Drivers\\Display\\PowerVR"
+#define POWERVR_CHIP_KEY                                "\\SGX1\\"
+
+#define POWERVR_EURASIA_KEY                             "PowerVREurasia\\"
+
+#define POWERVR_SERVICES_KEY                    "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\PowerVR\\"
+
+#define PVRSRV_REGISTRY_ROOT                    POWERVR_EURASIA_KEY "HWSettings\\PVRSRVKM"
+
+
+#define MAX_REG_STRING_SIZE 128
+
+
+#endif 
diff --git a/drivers/gpu/pvr/resman.c b/drivers/gpu/pvr/resman.c
new file mode 100644
index 00000000000..5d865a7d2c1
--- /dev/null
+++ b/drivers/gpu/pvr/resman.c
@@ -0,0 +1,736 @@
+/**********************************************************************
+ *
+ * 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 "resman.h"
+
+#ifdef __linux__
+#ifndef AUTOCONF_INCLUDED
+ #include <linux/config.h>
+#endif
+
+#include <linux/version.h>
+#include <linux/sched.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
+#include <linux/hardirq.h>
+#else
+#include <asm/hardirq.h>
+#endif
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+#include <linux/semaphore.h>
+#else
+#include <asm/semaphore.h>
+#endif
+
+static DECLARE_MUTEX(lock);
+
+#define ACQUIRE_SYNC_OBJ  do {                                                  \
+                if (in_interrupt()) {                                                   \
+                        printk ("ISR cannot take RESMAN mutex\n");      \
+                        BUG();                                                                          \
+                }                                                                                               \
+                else down (&lock);                                                              \
+} while (0)
+#define RELEASE_SYNC_OBJ up (&lock)
+
+#else
+
+#define ACQUIRE_SYNC_OBJ
+#define RELEASE_SYNC_OBJ
+
+#endif
+
+#define RESMAN_SIGNATURE 0x12345678
+
+typedef struct _RESMAN_ITEM_
+{
+#ifdef DEBUG
+        IMG_UINT32                              ui32Signature;
+#endif
+        struct _RESMAN_ITEM_    **ppsThis;      
+        struct _RESMAN_ITEM_    *psNext;        
+
+        IMG_UINT32                              ui32Flags;      
+        IMG_UINT32                              ui32ResType;
+
+        IMG_PVOID                               pvParam;        
+        IMG_UINT32                              ui32Param;      
+
+        RESMAN_FREE_FN                  pfnFreeResource;
+} RESMAN_ITEM;
+
+
+typedef struct _RESMAN_CONTEXT_
+{
+#ifdef DEBUG
+        IMG_UINT32                                      ui32Signature;
+#endif
+        struct  _RESMAN_CONTEXT_        **ppsThis;
+        struct  _RESMAN_CONTEXT_        *psNext;
+
+        PVRSRV_PER_PROCESS_DATA         *psPerProc; 
+
+        RESMAN_ITEM                                     *psResItemList;
+
+} RESMAN_CONTEXT;
+
+
+typedef struct
+{
+        RESMAN_CONTEXT  *psContextList; 
+
+} RESMAN_LIST, *PRESMAN_LIST;   
+
+
+PRESMAN_LIST    gpsResList = IMG_NULL;
+
+#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)
+
+
+#define PRINT_RESLIST(x, y, z)
+
+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_BOOL                     bExecuteCallback);
+
+
+#ifdef DEBUG
+        static IMG_VOID ValidateResList(PRESMAN_LIST psResList);
+        #define VALIDATERESLIST() ValidateResList(gpsResList)
+#else
+        #define VALIDATERESLIST()
+#endif
+
+
+
+
+
+
+PVRSRV_ERROR ResManInit(IMG_VOID)
+{
+        if (gpsResList == IMG_NULL)
+        {
+                
+                if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(*gpsResList),
+                                                (IMG_VOID **)&gpsResList, IMG_NULL,
+                                                "Resource Manager List") != PVRSRV_OK)
+                {
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+
+                
+                gpsResList->psContextList = IMG_NULL;
+
+                
+                VALIDATERESLIST();
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_VOID ResManDeInit(IMG_VOID)
+{
+        if (gpsResList != IMG_NULL)
+        {
+                
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*gpsResList), gpsResList, IMG_NULL);
+                gpsResList = IMG_NULL;
+        }
+}
+
+
+PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE                     hPerProc,
+                                                                 PRESMAN_CONTEXT        *phResManContext)
+{
+        PVRSRV_ERROR    eError;
+        PRESMAN_CONTEXT psResManContext;
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        VALIDATERESLIST();
+
+        
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psResManContext),
+                                                (IMG_VOID **)&psResManContext, IMG_NULL,
+                                                "Resource Manager Context");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PVRSRVResManConnect: ERROR allocating new RESMAN context struct"));
+
+                
+                VALIDATERESLIST();
+
+                
+                RELEASE_SYNC_OBJ;
+
+                return eError;
+        }
+
+#ifdef DEBUG
+        psResManContext->ui32Signature = RESMAN_SIGNATURE;
+#endif 
+        psResManContext->psResItemList  = IMG_NULL;
+        psResManContext->psPerProc = hPerProc;
+
+        
+        List_RESMAN_CONTEXT_Insert(&gpsResList->psContextList, psResManContext);
+
+        
+        VALIDATERESLIST();
+
+        
+        RELEASE_SYNC_OBJ;
+
+        *phResManContext = psResManContext;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext,
+                                                                IMG_BOOL                bKernelContext)
+{
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        VALIDATERESLIST();
+
+        
+        PRINT_RESLIST(gpsResList, psResManContext, IMG_TRUE);
+
+        
+
+        if (!bKernelContext)
+        {
+                
+                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_OS_USERMODE_MAPPING, 0, 0, IMG_TRUE);
+
+                
+                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_EVENT_OBJECT, 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_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_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);
+
+        
+        List_RESMAN_CONTEXT_Remove(psResManContext);
+
+        
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_CONTEXT), psResManContext, IMG_NULL);
+        
+
+
+        
+        VALIDATERESLIST();
+
+        
+        PRINT_RESLIST(gpsResList, psResManContext, IMG_FALSE);
+
+        
+        RELEASE_SYNC_OBJ;
+}
+
+
+PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT  psResManContext,
+                                                           IMG_UINT32           ui32ResType,
+                                                           IMG_PVOID            pvParam,
+                                                           IMG_UINT32           ui32Param,
+                                                           RESMAN_FREE_FN       pfnFreeResource)
+{
+        PRESMAN_ITEM    psNewResItem;
+
+        PVR_ASSERT(psResManContext != IMG_NULL);
+        PVR_ASSERT(ui32ResType != 0);
+
+        if (psResManContext == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "ResManRegisterRes: invalid parameter - psResManContext"));
+                return (PRESMAN_ITEM) IMG_NULL;
+        }
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        VALIDATERESLIST();
+
+        PVR_DPF((PVR_DBG_MESSAGE, "ResManRegisterRes: register resource "
+                        "Context 0x%x, ResType 0x%x, pvParam 0x%x, ui32Param 0x%x, "
+                        "FreeFunc %08X",
+                        (IMG_UINTPTR_T)psResManContext,
+                        ui32ResType,
+                        (IMG_UINTPTR_T)pvParam,
+                        ui32Param,
+                        (IMG_UINTPTR_T)pfnFreeResource));
+
+        
+        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                   sizeof(RESMAN_ITEM), (IMG_VOID **)&psNewResItem,
+                                   IMG_NULL,
+                                   "Resource Manager Item") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "ResManRegisterRes: "
+                                "ERROR allocating new resource item"));
+
+                
+                RELEASE_SYNC_OBJ;
+
+                return((PRESMAN_ITEM)IMG_NULL);
+        }
+
+        
+#ifdef DEBUG
+        psNewResItem->ui32Signature             = RESMAN_SIGNATURE;
+#endif 
+        psNewResItem->ui32ResType               = ui32ResType;
+        psNewResItem->pvParam                   = pvParam;
+        psNewResItem->ui32Param                 = ui32Param;
+        psNewResItem->pfnFreeResource   = pfnFreeResource;
+        psNewResItem->ui32Flags             = 0;
+
+        
+        List_RESMAN_ITEM_Insert(&psResManContext->psResItemList, psNewResItem);
+
+        
+        VALIDATERESLIST();
+
+        
+        RELEASE_SYNC_OBJ;
+
+        return(psNewResItem);
+}
+
+PVRSRV_ERROR ResManFreeResByPtr(RESMAN_ITEM     *psResItem)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(psResItem != IMG_NULL);
+
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: NULL ptr - nothing to do"));
+                return PVRSRV_OK;
+        }
+
+        PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: freeing resource at %08X",
+                        (IMG_UINTPTR_T)psResItem));
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        VALIDATERESLIST();
+
+        
+        eError = FreeResourceByPtr(psResItem, IMG_TRUE);
+
+        
+        VALIDATERESLIST();
+
+        
+        RELEASE_SYNC_OBJ;
+
+        return(eError);
+}
+
+
+PVRSRV_ERROR ResManFreeResByCriteria(PRESMAN_CONTEXT    psResManContext,
+                                                                         IMG_UINT32                     ui32SearchCriteria,
+                                                                         IMG_UINT32                     ui32ResType,
+                                                                         IMG_PVOID                      pvParam,
+                                                                         IMG_UINT32                     ui32Param)
+{
+        PVRSRV_ERROR    eError;
+
+        PVR_ASSERT(psResManContext != IMG_NULL);
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        VALIDATERESLIST();
+
+        PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByCriteria: "
+                        "Context 0x%x, Criteria 0x%x, Type 0x%x, Addr 0x%x, Param 0x%x",
+                        (IMG_UINTPTR_T)psResManContext, ui32SearchCriteria, ui32ResType,
+                        (IMG_UINTPTR_T)pvParam, ui32Param));
+
+        
+        eError = FreeResourceByCriteria(psResManContext, ui32SearchCriteria,
+                                                                        ui32ResType, pvParam, ui32Param,
+                                                                        IMG_TRUE);
+
+        
+        VALIDATERESLIST();
+
+        
+        RELEASE_SYNC_OBJ;
+
+        return eError;
+}
+
+
+PVRSRV_ERROR ResManDissociateRes(RESMAN_ITEM            *psResItem,
+                                                         PRESMAN_CONTEXT        psNewResManContext)
+{
+        PVRSRV_ERROR eError = PVRSRV_OK;
+
+        PVR_ASSERT(psResItem != IMG_NULL);
+
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "ResManDissociateRes: invalid parameter - psResItem"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+#ifdef DEBUG 
+        PVR_ASSERT(psResItem->ui32Signature == RESMAN_SIGNATURE);
+#endif
+
+        if (psNewResManContext != IMG_NULL)
+        {
+                
+                List_RESMAN_ITEM_Remove(psResItem);
+
+                
+                List_RESMAN_ITEM_Insert(&psNewResManContext->psResItemList, psResItem);
+
+        }
+        else
+        {
+                eError = FreeResourceByPtr(psResItem, IMG_FALSE);
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "ResManDissociateRes: failed to free resource by pointer"));
+                        return eError;
+                }
+        }
+
+        return eError;
+}
+
+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);
+}
+
+
+IMG_INTERNAL PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT       psResManContext,
+                                                                                                  RESMAN_ITEM           *psItem)
+{
+        PVRSRV_ERROR    eResult;
+
+        PVR_ASSERT(psResManContext != IMG_NULL);
+        PVR_ASSERT(psItem != IMG_NULL);
+
+        if ((psItem == IMG_NULL) || (psResManContext == IMG_NULL))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "ResManFindResourceByPtr: invalid parameter"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+#ifdef DEBUG    
+        PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
+#endif
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        PVR_DPF((PVR_DBG_MESSAGE,
+                        "FindResourceByPtr: psItem=%08X, psItem->psNext=%08X",
+                        (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",
+                        (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,
+                                                                                psItem))
+        {
+                eResult = PVRSRV_OK;
+        }
+        else
+        {
+                eResult = PVRSRV_ERROR_NOT_OWNER;
+        }
+
+        
+        RELEASE_SYNC_OBJ;
+
+        return eResult;
+}
+
+static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM       *psItem,
+                                                                          IMG_BOOL              bExecuteCallback)
+{
+        PVRSRV_ERROR eError;
+
+        PVR_ASSERT(psItem != IMG_NULL);
+
+        if (psItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+#ifdef DEBUG    
+        PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
+#endif
+
+        PVR_DPF((PVR_DBG_MESSAGE,
+                        "FreeResourceByPtr: psItem=%08X, psItem->psNext=%08X",
+                        (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_UINTPTR_T)psItem->pvParam, psItem->ui32Param,
+                        (IMG_UINTPTR_T)psItem->pfnFreeResource, psItem->ui32Flags));
+
+        
+        List_RESMAN_ITEM_Remove(psItem);
+
+
+        
+        RELEASE_SYNC_OBJ;
+
+        
+        if (bExecuteCallback)
+        {
+                eError = psItem->pfnFreeResource(psItem->pvParam, psItem->ui32Param);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: ERROR calling FreeResource function"));
+                }
+        }
+
+        
+        ACQUIRE_SYNC_OBJ;
+
+        
+        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"));
+        }
+
+        return(eError);
+}
+
+static IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
+{
+        IMG_UINT32 ui32SearchCriteria;
+        IMG_UINT32 ui32ResType;
+        IMG_PVOID pvParam;
+        IMG_UINT32 ui32Param;
+
+        ui32SearchCriteria = va_arg(va, IMG_UINT32);
+        ui32ResType = va_arg(va, IMG_UINT32);
+        pvParam = va_arg(va, IMG_PVOID);
+        ui32Param = va_arg(va, IMG_UINT32);
+
+        
+        if(
+        
+                (((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) == 0UL) ||
+                (psCurItem->ui32ResType == ui32ResType))
+        &&
+        
+                (((ui32SearchCriteria & RESMAN_CRITERIA_PVOID_PARAM) == 0UL) ||
+                         (psCurItem->pvParam == pvParam))
+        &&
+        
+                (((ui32SearchCriteria & RESMAN_CRITERIA_UI32_PARAM) == 0UL) ||
+                         (psCurItem->ui32Param == ui32Param))
+                )
+        {
+                return psCurItem;
+        }
+        else
+        {
+                return IMG_NULL;
+        }
+}
+
+static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT      psResManContext,
+                                                                                   IMG_UINT32           ui32SearchCriteria,
+                                                                                   IMG_UINT32           ui32ResType,
+                                                                                   IMG_PVOID            pvParam,
+                                                                                   IMG_UINT32           ui32Param,
+                                                                                   IMG_BOOL                     bExecuteCallback)
+{
+        PRESMAN_ITEM    psCurItem;
+        PVRSRV_ERROR    eError = PVRSRV_OK;
+
+        
+        
+        while((psCurItem = (PRESMAN_ITEM)
+                                List_RESMAN_ITEM_Any_va(psResManContext->psResItemList,
+                                                                                &FreeResourceByCriteria_AnyVaCb,
+                                                                                ui32SearchCriteria,
+                                                                                ui32ResType,
+                                                                                pvParam,
+                                                                                ui32Param)) != IMG_NULL
+                        && eError == PVRSRV_OK)
+        {
+                eError = FreeResourceByPtr(psCurItem, bExecuteCallback);
+        }
+
+        return eError;
+}
+
+
+#ifdef DEBUG
+static IMG_VOID ValidateResList(PRESMAN_LIST psResList)
+{
+        PRESMAN_ITEM    psCurItem, *ppsThisItem;
+        PRESMAN_CONTEXT psCurContext, *ppsThisContext;
+
+        
+        if (psResList == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "ValidateResList: resman not initialised yet"));
+                return;
+        }
+
+        psCurContext = psResList->psContextList;
+        ppsThisContext = &psResList->psContextList;
+
+        
+        while(psCurContext != IMG_NULL)
+        {
+                
+                PVR_ASSERT(psCurContext->ui32Signature == RESMAN_SIGNATURE);
+                if (psCurContext->ppsThis != ppsThisContext)
+                {
+                        PVR_DPF((PVR_DBG_WARNING,
+                                        "psCC=%08X psCC->ppsThis=%08X psCC->psNext=%08X ppsTC=%08X",
+                                        (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;
+                while(psCurItem != IMG_NULL)
+                {
+                        
+                        PVR_ASSERT(psCurItem->ui32Signature == RESMAN_SIGNATURE);
+                        if (psCurItem->ppsThis != ppsThisItem)
+                        {
+                                PVR_DPF((PVR_DBG_WARNING,
+                                                "psCurItem=%08X psCurItem->ppsThis=%08X psCurItem->psNext=%08X ppsThisItem=%08X",
+                                                (IMG_UINTPTR_T)psCurItem,
+                                                (IMG_UINTPTR_T)psCurItem->ppsThis,
+                                                (IMG_UINTPTR_T)psCurItem->psNext,
+                                                (IMG_UINTPTR_T)ppsThisItem));
+                                PVR_ASSERT(psCurItem->ppsThis == ppsThisItem);
+                        }
+
+                        
+                        ppsThisItem = &psCurItem->psNext;
+                        psCurItem = psCurItem->psNext;
+                }
+
+                
+                ppsThisContext = &psCurContext->psNext;
+                psCurContext = psCurContext->psNext;
+        }
+}
+#endif 
+
+
diff --git a/drivers/gpu/pvr/resman.h b/drivers/gpu/pvr/resman.h
new file mode 100644
index 00000000000..eebec57c9d6
--- /dev/null
+++ b/drivers/gpu/pvr/resman.h
@@ -0,0 +1,114 @@
+/**********************************************************************
+ *
+ * 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 __RESMAN_H__
+#define __RESMAN_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+enum {
+        
+        RESMAN_TYPE_SHARED_PB_DESC = 1,                                 
+        RESMAN_TYPE_SHARED_PB_DESC_CREATE_LOCK,                         
+        RESMAN_TYPE_HW_RENDER_CONTEXT,                                  
+        RESMAN_TYPE_HW_TRANSFER_CONTEXT,                                
+        RESMAN_TYPE_HW_2D_CONTEXT,                                              
+        RESMAN_TYPE_TRANSFER_CONTEXT,                                   
+
+        
+        
+        
+        
+        RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN_REF,                 
+        RESMAN_TYPE_DISPLAYCLASS_DEVICE,                                
+
+        
+        RESMAN_TYPE_BUFFERCLASS_DEVICE,                                 
+        
+        
+        RESMAN_TYPE_OS_USERMODE_MAPPING,                                
+        
+        
+        RESMAN_TYPE_DEVICEMEM_CONTEXT,                                  
+        RESMAN_TYPE_DEVICECLASSMEM_MAPPING,                             
+        RESMAN_TYPE_DEVICEMEM_MAPPING,                                  
+        RESMAN_TYPE_DEVICEMEM_WRAP,                                             
+        RESMAN_TYPE_DEVICEMEM_ALLOCATION,                               
+        RESMAN_TYPE_EVENT_OBJECT,                                               
+    RESMAN_TYPE_SHARED_MEM_INFO,                    
+    RESMAN_TYPE_MODIFY_SYNC_OPS,                                        
+    RESMAN_TYPE_SYNC_INFO,                                              
+        
+        
+        RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION                 
+};
+
+#define RESMAN_CRITERIA_ALL                             0x00000000      
+#define RESMAN_CRITERIA_RESTYPE                 0x00000001      
+#define RESMAN_CRITERIA_PVOID_PARAM             0x00000002      
+#define RESMAN_CRITERIA_UI32_PARAM              0x00000004      
+
+typedef PVRSRV_ERROR (*RESMAN_FREE_FN)(IMG_PVOID pvParam, IMG_UINT32 ui32Param); 
+
+typedef struct _RESMAN_ITEM_ *PRESMAN_ITEM;
+typedef struct _RESMAN_CONTEXT_ *PRESMAN_CONTEXT;
+
+PVRSRV_ERROR ResManInit(IMG_VOID);
+IMG_VOID ResManDeInit(IMG_VOID);
+
+PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT  hResManContext,
+                                                           IMG_UINT32           ui32ResType, 
+                                                           IMG_PVOID            pvParam, 
+                                                           IMG_UINT32           ui32Param, 
+                                                           RESMAN_FREE_FN       pfnFreeResource);
+
+PVRSRV_ERROR ResManFreeResByPtr(PRESMAN_ITEM    psResItem);
+
+PVRSRV_ERROR ResManFreeResByCriteria(PRESMAN_CONTEXT    hResManContext,
+                                                                         IMG_UINT32                     ui32SearchCriteria, 
+                                                                         IMG_UINT32                     ui32ResType, 
+                                                                         IMG_PVOID                      pvParam, 
+                                                                         IMG_UINT32                     ui32Param);
+
+PVRSRV_ERROR ResManDissociateRes(PRESMAN_ITEM           psResItem,
+                                                         PRESMAN_CONTEXT        psNewResManContext);
+
+PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT    hResManContext,
+                                                                         PRESMAN_ITEM           psItem);
+
+PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE                     hPerProc,
+                                                                 PRESMAN_CONTEXT        *phResManContext);
+IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT hResManContext,
+                                                                IMG_BOOL                bKernelContext);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/services.h b/drivers/gpu/pvr/services.h
new file mode 100644
index 00000000000..71fb4efb7fc
--- /dev/null
+++ b/drivers/gpu/pvr/services.h
@@ -0,0 +1,991 @@
+/**********************************************************************
+ *
+ * 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_H__
+#define __SERVICES_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "img_defs.h"
+#include "servicesext.h"
+#include "pdumpdefs.h"
+
+
+#define PVRSRV_4K_PAGE_SIZE             4096UL
+
+#define PVRSRV_MAX_CMD_SIZE             1024
+
+#define PVRSRV_MAX_DEVICES              16      
+
+#define EVENTOBJNAME_MAXLENGTH (50)
+
+#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                          (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 \
+                                            |PVRSRV_HAP_FROM_EXISTING_PROCESS \
+                                            |PVRSRV_HAP_NO_CPU_VIRTUAL)
+
+#define PVRSRV_MEM_CACHED                                       PVRSRV_HAP_CACHED
+#define PVRSRV_MEM_UNCACHED                                     PVRSRV_HAP_UNCACHED
+#define PVRSRV_MEM_WRITECOMBINE                         PVRSRV_HAP_WRITECOMBINE
+
+#define PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT     (24)
+
+#define PVRSRV_MAP_NOUSERVIRTUAL            (1UL<<27)
+
+#define PVRSRV_NO_CONTEXT_LOSS                                  0               
+#define PVRSRV_SEVERE_LOSS_OF_CONTEXT                   1               
+#define PVRSRV_PRE_STATE_CHANGE_MASK                    0x80    
+
+
+#define PVRSRV_DEFAULT_DEV_COOKIE                       (1)      
+
+
+#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_CHANGEDEVMEM_ATTRIBS_CACHECOHERENT               0x00000001
+
+#define PVRSRV_MAPEXTMEMORY_FLAGS_ALTERNATEVA                   0x00000001
+#define PVRSRV_MAPEXTMEMORY_FLAGS_PHYSCONTIG                    0x00000002
+
+#define PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC                       0x00000001
+#define PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC                       0x00000002
+
+#define SRV_FLAGS_PERSIST               0x1
+
+typedef enum _PVRSRV_DEVICE_TYPE_
+{
+        PVRSRV_DEVICE_TYPE_UNKNOWN                      = 0 ,
+        PVRSRV_DEVICE_TYPE_MBX1                         = 1 ,
+        PVRSRV_DEVICE_TYPE_MBX1_LITE            = 2 ,
+
+        PVRSRV_DEVICE_TYPE_M24VA                        = 3,
+        PVRSRV_DEVICE_TYPE_MVDA2                        = 4,
+        PVRSRV_DEVICE_TYPE_MVED1                        = 5,
+        PVRSRV_DEVICE_TYPE_MSVDX                        = 6,
+
+        PVRSRV_DEVICE_TYPE_SGX                          = 7,
+
+        PVRSRV_DEVICE_TYPE_VGX                          = 8,
+
+        
+        PVRSRV_DEVICE_TYPE_EXT                          = 9,
+
+    PVRSRV_DEVICE_TYPE_LAST             = 9,
+
+        PVRSRV_DEVICE_TYPE_FORCE_I32            = 0x7fffffff
+
+} PVRSRV_DEVICE_TYPE;
+
+#define HEAP_ID( _dev_ , _dev_heap_idx_ )       (  ((_dev_)<<24) | ((_dev_heap_idx_)&((1<<24)-1))  )
+#define HEAP_IDX( _heap_id_ )                           ( (_heap_id_)&((1<<24) - 1 ) )
+#define HEAP_DEV( _heap_id_ )                           ( (_heap_id_)>>24 )
+
+#define PVRSRV_UNDEFINED_HEAP_ID                        (~0LU)
+
+typedef enum
+{
+        IMG_EGL                         = 0x00000001,
+        IMG_OPENGLES1           = 0x00000002,
+        IMG_OPENGLES2           = 0x00000003,
+        IMG_D3DM                        = 0x00000004,
+        IMG_SRV_UM                      = 0x00000005,
+        IMG_OPENVG                      = 0x00000006,
+        IMG_SRVCLIENT           = 0x00000007,
+        IMG_VISTAKMD            = 0x00000008,
+        IMG_VISTA3DNODE         = 0x00000009,
+        IMG_VISTAMVIDEONODE     = 0x0000000A,
+        IMG_VISTAVPBNODE        = 0x0000000B,
+        IMG_OPENGL                      = 0x0000000C,
+        IMG_D3D                         = 0x0000000D,
+#if defined(SUPPORT_GRAPHICS_HAL)
+        IMG_GRAPHICS_HAL        = 0x0000000E
+#endif
+
+} IMG_MODULE_ID;
+
+
+#define APPHINT_MAX_STRING_SIZE 256
+
+typedef enum
+{
+        IMG_STRING_TYPE         = 1,
+        IMG_FLOAT_TYPE          ,
+        IMG_UINT_TYPE           ,
+        IMG_INT_TYPE            ,
+        IMG_FLAG_TYPE
+}IMG_DATA_TYPE;
+
+
+typedef struct _PVRSRV_DEV_DATA_ *PPVRSRV_DEV_DATA;
+
+typedef struct _PVRSRV_DEVICE_IDENTIFIER_
+{
+        PVRSRV_DEVICE_TYPE              eDeviceType;            
+        PVRSRV_DEVICE_CLASS             eDeviceClass;           
+        IMG_UINT32                              ui32DeviceIndex;        
+        IMG_CHAR                                *pszPDumpDevName;       
+        IMG_CHAR                                *pszPDumpRegName;       
+
+} PVRSRV_DEVICE_IDENTIFIER;
+
+
+typedef struct _PVRSRV_CLIENT_DEV_DATA_
+{
+        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_UINTPTR_T ui32ProcessID;                    
+        PVRSRV_CLIENT_DEV_DATA  sClientDevData; 
+        IMG_UINT32 ui32SrvFlags;                                
+}PVRSRV_CONNECTION;
+
+
+typedef struct _PVRSRV_DEV_DATA_
+{
+        IMG_CONST PVRSRV_CONNECTION      *psConnection; 
+        IMG_HANDLE                      hDevCookie;                             
+
+} PVRSRV_DEV_DATA;
+
+typedef struct _PVRSRV_MEMUPDATE_
+{
+        IMG_UINTPTR_T           ui32UpdateAddr;         
+        IMG_UINT32                      ui32UpdateVal;          
+} PVRSRV_MEMUPDATE;
+
+typedef struct _PVRSRV_HWREG_
+{
+        IMG_UINT32                      ui32RegAddr;    
+        IMG_UINT32                      ui32RegVal;             
+} PVRSRV_HWREG;
+
+typedef struct _PVRSRV_MEMBLK_
+{
+        IMG_DEV_VIRTADDR        sDevVirtAddr;                   
+        IMG_HANDLE                      hOSMemHandle;                   
+        IMG_HANDLE                      hOSWrapMem;                             
+        IMG_HANDLE                      hBuffer;                                
+        IMG_HANDLE                      hResItem;                               
+        IMG_SYS_PHYADDR         *psIntSysPAddr;
+
+} PVRSRV_MEMBLK;
+
+typedef struct _PVRSRV_KERNEL_MEM_INFO_ *PPVRSRV_KERNEL_MEM_INFO;
+
+typedef struct _PVRSRV_CLIENT_MEM_INFO_
+{
+        
+        IMG_PVOID                               pvLinAddr;
+
+        
+        IMG_PVOID                               pvLinAddrKM;
+
+        
+        IMG_DEV_VIRTADDR                sDevVAddr;
+
+        
+
+
+
+
+        IMG_CPU_PHYADDR                 sCpuPAddr;
+
+        
+        IMG_UINT32                              ui32Flags;
+
+        
+
+
+        IMG_UINT32                              ui32ClientFlags;
+
+        
+        IMG_SIZE_T                              ui32AllocSize;
+
+
+        
+        struct _PVRSRV_CLIENT_SYNC_INFO_        *psClientSyncInfo;
+
+        
+        IMG_HANDLE                                                      hMappingInfo;
+
+        
+        IMG_HANDLE                                                      hKernelMemInfo;
+
+        
+        IMG_HANDLE                                                      hResItem;
+
+#if defined(SUPPORT_MEMINFO_IDS)
+        #if !defined(USE_CODE)
+        
+        IMG_UINT64                                                      ui64Stamp;
+        #else 
+        IMG_UINT32                                                      dummy1;
+        IMG_UINT32                                                      dummy2;
+        #endif 
+#endif 
+
+        
+
+
+        struct _PVRSRV_CLIENT_MEM_INFO_         *psNext;
+
+} PVRSRV_CLIENT_MEM_INFO, *PPVRSRV_CLIENT_MEM_INFO;
+
+
+#define PVRSRV_MAX_CLIENT_HEAPS (32)
+typedef struct _PVRSRV_HEAP_INFO_
+{
+        IMG_UINT32                      ui32HeapID;
+        IMG_HANDLE                      hDevMemHeap;
+        IMG_DEV_VIRTADDR        sDevVAddrBase;
+        IMG_UINT32                      ui32HeapByteSize;
+        IMG_UINT32                      ui32Attribs;
+        IMG_UINT32                      ui32XTileStride;
+}PVRSRV_HEAP_INFO;
+
+
+
+
+typedef struct _PVRSRV_EVENTOBJECT_
+{
+        
+        IMG_CHAR        szName[EVENTOBJNAME_MAXLENGTH];
+        
+        IMG_HANDLE      hOSEventKM;
+
+} 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_UINT32      ui32StatePresent;               
+
+        
+        IMG_VOID        *pvSOCTimerRegisterKM;
+        IMG_VOID        *pvSOCTimerRegisterUM;
+        IMG_HANDLE      hSOCTimerRegisterOSMemHandle;
+        IMG_HANDLE      hSOCTimerRegisterMappingInfo;
+
+        
+        IMG_VOID        *pvSOCClockGateRegs;
+        IMG_UINT32      ui32SOCClockGateRegsSize;
+
+        
+        IMG_CHAR        *pszMemoryStr;
+        IMG_UINT32      ui32MemoryStrLen;
+
+        
+        PVRSRV_EVENTOBJECT      sGlobalEventObject;
+        IMG_HANDLE                      hOSGlobalEvent;
+
+        
+        IMG_UINT32      aui32DDKVersion[4];
+
+        
+        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 **ppsConnection, IMG_UINT32 ui32SrvFlags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDisconnect(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevices(IMG_CONST PVRSRV_CONNECTION                    *psConnection,
+                                                                                                        IMG_UINT32                                      *puiNumDevices,
+                                                                                                        PVRSRV_DEVICE_IDENTIFIER        *puiDevIDs);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAcquireDeviceData(IMG_CONST PVRSRV_CONNECTION   *psConnection,
+                                                                                                        IMG_UINT32                      uiDevIndex,
+                                                                                                        PVRSRV_DEV_DATA         *psDevData,
+                                                                                                        PVRSRV_DEVICE_TYPE      eDeviceType);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfo (IMG_CONST PVRSRV_CONNECTION *psConnection, PVRSRV_MISC_INFO *psMiscInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReleaseMiscInfo (IMG_CONST PVRSRV_CONNECTION *psConnection, PVRSRV_MISC_INFO *psMiscInfo);
+
+#if 1
+IMG_IMPORT
+IMG_UINT32 ReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset);
+
+IMG_IMPORT
+IMG_VOID WriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value);
+
+IMG_IMPORT IMG_VOID WriteHWRegs(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Count, PVRSRV_HWREG *psHWRegs);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVPollForValue ( const PVRSRV_CONNECTION *psConnection,
+                                                        IMG_HANDLE hOSEvent,
+                                                        volatile IMG_UINT32 *pui32LinMemAddr,
+                                                        IMG_UINT32 ui32Value,
+                                                        IMG_UINT32 ui32Mask,
+                                                        IMG_UINT32 ui32Waitus,
+                                                        IMG_UINT32 ui32Tries);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDeviceMemContext(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_HANDLE *phDevMemContext,
+                                                                                        IMG_UINT32 *pui32SharedHeapCount,
+                                                                                        PVRSRV_HEAP_INFO *psHeapInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDeviceMemContext(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_HANDLE                      hDevMemContext);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfo(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_HANDLE hDevMemContext,
+                                                                                        IMG_UINT32 *pui32SharedHeapCount,
+                                                                                        PVRSRV_HEAP_INFO *psHeapInfo);
+
+#if defined(PVRSRV_LOG_MEMORY_ALLOCS)
+        #define PVRSRVAllocDeviceMem_log(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo, logStr) \
+                (PVR_TRACE(("PVRSRVAllocDeviceMem(" #psDevData "," #hDevMemHeap "," #ui32Attribs "," #ui32Size "," #ui32Alignment "," #ppsMemInfo ")" \
+                        ": " logStr " (size = 0x%lx)", ui32Size)), \
+                PVRSRVAllocDeviceMem(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo))
+#else
+        #define PVRSRVAllocDeviceMem_log(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo, logStr) \
+                PVRSRVAllocDeviceMem(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo)
+#endif
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMem(IMG_CONST PVRSRV_DEV_DATA        *psDevData,
+                                                                        IMG_HANDLE              hDevMemHeap,
+                                                                        IMG_UINT32              ui32Attribs,
+                                                                        IMG_SIZE_T              ui32Size,
+                                                                        IMG_SIZE_T              ui32Alignment,
+                                                                        PVRSRV_CLIENT_MEM_INFO  **ppsMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMem(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                PVRSRV_CLIENT_MEM_INFO          *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVExportDeviceMem(IMG_CONST PVRSRV_DEV_DATA       *psDevData,
+                                                                                                PVRSRV_CLIENT_MEM_INFO          *psMemInfo,
+                                                                                                IMG_HANDLE                                      *phMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReserveDeviceVirtualMem(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_HANDLE                      hDevMemHeap,
+                                                                                        IMG_DEV_VIRTADDR        *psDevVAddr,
+                                                                                        IMG_SIZE_T                      ui32Size,
+                                                                                        IMG_SIZE_T                      ui32Alignment,
+                                                                                        PVRSRV_CLIENT_MEM_INFO          **ppsMemInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceVirtualMem(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                                        PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                        IMG_HANDLE hKernelMemInfo,
+                                                                        IMG_HANDLE hDstDevMemHeap,
+                                                                        PVRSRV_CLIENT_MEM_INFO **ppsDstMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapExtMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                        PVRSRV_CLIENT_MEM_INFO          *psMemInfo,
+                                                                        IMG_SYS_PHYADDR                         *psSysPAddr,
+                                                                        IMG_UINT32                                      ui32Flags);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapExtMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                        PVRSRV_CLIENT_MEM_INFO          *psMemInfo,
+                                                                        IMG_UINT32                                      ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemory(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                                IMG_HANDLE                              hDevMemContext,
+                                                                                                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,
+                                                                                                PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+PVRSRV_ERROR PVRSRVChangeDeviceMemoryAttributes(IMG_CONST PVRSRV_DEV_DATA                       *psDevData,
+                                                                                                PVRSRV_CLIENT_MEM_INFO  *psClientMemInfo,
+                                                                                                IMG_UINT32                              ui32Attribs);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                IMG_HANDLE hDevMemContext,
+                                                                                IMG_HANDLE hDeviceClassBuffer,
+                                                                                PVRSRV_CLIENT_MEM_INFO **ppsMemInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceClassMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapPhysToUserSpace(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                          IMG_SYS_PHYADDR sSysPhysAddr,
+                                                                          IMG_UINT32 uiSizeInBytes,
+                                                                          IMG_PVOID *ppvUserAddr,
+                                                                          IMG_UINT32 *puiActualSize,
+                                                                          IMG_PVOID *ppvProcess);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapPhysToUserSpace(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                IMG_PVOID pvUserAddr,
+                                                                                IMG_PVOID pvProcess);
+
+typedef enum _PVRSRV_SYNCVAL_MODE_
+{
+        PVRSRV_SYNCVAL_READ                             = IMG_TRUE,
+        PVRSRV_SYNCVAL_WRITE                    = IMG_FALSE,
+
+} PVRSRV_SYNCVAL_MODE, *PPVRSRV_SYNCVAL_MODE;
+
+typedef IMG_UINT32 PVRSRV_SYNCVAL;
+
+IMG_IMPORT PVRSRV_ERROR PVRSRVWaitForOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT PVRSRV_ERROR PVRSRVWaitForAllOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestAllOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestOpsNotComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestAllOpsNotComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT PVRSRV_SYNCVAL PVRSRVGetPendingOpSyncVal(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+        PVRSRV_SYNCVAL_MODE eMode);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDeviceClass(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                        PVRSRV_DEVICE_CLASS DeviceClass,
+                                                                                                        IMG_UINT32 *pui32DevCount,
+                                                                                                        IMG_UINT32 *pui32DevID);
+
+IMG_IMPORT
+IMG_HANDLE IMG_CALLCONV PVRSRVOpenDCDevice(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_UINT32 ui32DeviceID);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCloseDCDevice(IMG_CONST PVRSRV_CONNECTION       *psConnection, IMG_HANDLE hDevice);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCFormats (IMG_HANDLE hDevice,
+                                                                                        IMG_UINT32              *pui32Count,
+                                                                                        DISPLAY_FORMAT  *psFormat);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCDims (IMG_HANDLE hDevice,
+                                                                                IMG_UINT32              *pui32Count,
+                                                                                DISPLAY_FORMAT  *psFormat,
+                                                                                DISPLAY_DIMS    *psDims);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCSystemBuffer(IMG_HANDLE hDevice,
+                                                                                IMG_HANDLE *phBuffer);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCInfo(IMG_HANDLE hDevice,
+                                                                                DISPLAY_INFO* psDisplayInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDCSwapChain (IMG_HANDLE                           hDevice,
+                                                                                                        IMG_UINT32                              ui32Flags,
+                                                                                                        DISPLAY_SURF_ATTRIBUTES *psDstSurfAttrib,
+                                                                                                        DISPLAY_SURF_ATTRIBUTES *psSrcSurfAttrib,
+                                                                                                        IMG_UINT32                              ui32BufferCount,
+                                                                                                        IMG_UINT32                              ui32OEMFlags,
+                                                                                                        IMG_UINT32                              *pui32SwapChainID,
+                                                                                                        IMG_HANDLE                              *phSwapChain);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDCSwapChain (IMG_HANDLE hDevice,
+                                                                                        IMG_HANDLE              hSwapChain);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCDstRect (IMG_HANDLE hDevice,
+                                                                                IMG_HANDLE      hSwapChain,
+                                                                                IMG_RECT        *psDstRect);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCSrcRect (IMG_HANDLE hDevice,
+                                                                                IMG_HANDLE      hSwapChain,
+                                                                                IMG_RECT        *psSrcRect);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCDstColourKey (IMG_HANDLE hDevice,
+                                                                                        IMG_HANDLE      hSwapChain,
+                                                                                        IMG_UINT32      ui32CKColour);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCSrcColourKey (IMG_HANDLE hDevice,
+                                                                                        IMG_HANDLE      hSwapChain,
+                                                                                        IMG_UINT32      ui32CKColour);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCBuffers(IMG_HANDLE hDevice,
+                                                                        IMG_HANDLE hSwapChain,
+                                                                        IMG_HANDLE *phBuffer);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSwapToDCBuffer (IMG_HANDLE hDevice,
+                                                                                IMG_HANDLE hBuffer,
+                                                                                IMG_UINT32 ui32ClipRectCount,
+                                                                                IMG_RECT *psClipRect,
+                                                                                IMG_UINT32 ui32SwapInterval,
+                                                                                IMG_HANDLE hPrivateTag);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSwapToDCSystem (IMG_HANDLE hDevice,
+                                                                                IMG_HANDLE hSwapChain);
+
+
+IMG_IMPORT
+IMG_HANDLE IMG_CALLCONV PVRSRVOpenBCDevice(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_UINT32 ui32DeviceID);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCloseBCDevice(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                IMG_HANDLE hDevice);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetBCBufferInfo(IMG_HANDLE hDevice,
+                                                                                                BUFFER_INFO     *psBuffer);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetBCBuffer(IMG_HANDLE hDevice,
+                                                                                                IMG_UINT32 ui32BufferIndex,
+                                                                                                IMG_HANDLE *phBuffer);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpInit(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpStartInitPhase(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpStopInitPhase(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpMemPol(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                  PVRSRV_CLIENT_MEM_INFO *psMemInfo,
+                                                                                  IMG_UINT32 ui32Offset,
+                                                                                  IMG_UINT32 ui32Value,
+                                                                                  IMG_UINT32 ui32Mask,
+                                                                                  PDUMP_POLL_OPERATOR eOperator,
+                                                                                  IMG_UINT32 ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSyncPol(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                  PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+                                                                                  IMG_BOOL bIsRead,
+                                                                                  IMG_UINT32 ui32Value,
+                                                                                  IMG_UINT32 ui32Mask);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpMem(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                        IMG_PVOID pvAltLinAddr,
+                                                                        PVRSRV_CLIENT_MEM_INFO *psMemInfo,
+                                                                        IMG_UINT32 ui32Offset,
+                                                                        IMG_UINT32 ui32Bytes,
+                                                                        IMG_UINT32 ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSync(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                IMG_PVOID pvAltLinAddr,
+                                                                                PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+                                                                                IMG_UINT32 ui32Offset,
+                                                                                IMG_UINT32 ui32Bytes);
+
+IMG_IMPORT
+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(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(const PVRSRV_DEV_DATA *psDevData,
+                                                                                        IMG_CHAR *pszRegRegion,
+                                                                                        IMG_UINT32 ui32RegAddr,
+                                                                                        IMG_UINT32 ui32RegValue,
+                                                                                        IMG_UINT32 ui32Mask);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpPDReg(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                        IMG_UINT32 ui32RegAddr,
+                                                                                        IMG_UINT32 ui32RegValue);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpPDDevPAddr(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                PVRSRV_CLIENT_MEM_INFO *psMemInfo,
+                                                                                                IMG_UINT32 ui32Offset,
+                                                                                                IMG_DEV_PHYADDR sPDDevPAddr);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpMemPages(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                IMG_HANDLE                      hKernelMemInfo,
+                                                                                                IMG_DEV_PHYADDR         *pPages,
+                                                                                                IMG_UINT32                      ui32NumPages,
+                                                                                                IMG_DEV_VIRTADDR        sDevAddr,
+                                                                                                IMG_UINT32                      ui32Start,
+                                                                                                IMG_UINT32                      ui32Length,
+                                                                                                IMG_BOOL                        bContinuous);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSetFrame(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                          IMG_UINT32 ui32Frame);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpComment(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                         IMG_CONST IMG_CHAR *pszComment,
+                                                                                         IMG_BOOL bContinuous);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCommentf(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                          IMG_BOOL bContinuous,
+                                                                                          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, ...)
+#if !defined(USE_CODE)
+                                                                                                           IMG_FORMAT_PRINTF(3, 4)
+#endif
+;
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpDriverInfo(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                IMG_CHAR *pszString,
+                                                                                                IMG_BOOL bContinuous);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpIsCapturing(IMG_CONST PVRSRV_CONNECTION *psConnection,
+                                                                                                IMG_BOOL *pbIsCapturing);
+
+IMG_IMPORT
+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_DEV_DATA *psDevData,
+                                                                                        IMG_CONST IMG_CHAR *pszRegRegion,
+                                                                                        IMG_CONST IMG_CHAR *pszFileName,
+                                                                                        IMG_UINT32 ui32FileOffset,
+                                                                                        IMG_UINT32 ui32Address,
+                                                                                        IMG_UINT32 ui32Size,
+                                                                                        IMG_UINT32 ui32PDumpFlags);
+
+
+IMG_IMPORT
+IMG_BOOL IMG_CALLCONV PVRSRVPDumpIsCapturingTest(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCycleCountRegRead(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+                                                                                                                IMG_UINT32 ui32RegOffset,
+                                                                                                                IMG_BOOL bLastFrame);
+
+IMG_IMPORT IMG_HANDLE   PVRSRVLoadLibrary(const IMG_CHAR *pszLibraryName);
+IMG_IMPORT PVRSRV_ERROR PVRSRVUnloadLibrary(IMG_HANDLE hExtDrv);
+IMG_IMPORT PVRSRV_ERROR PVRSRVGetLibFuncAddr(IMG_HANDLE hExtDrv, const IMG_CHAR *pszFunctionName, IMG_VOID **ppvFuncAddr);
+
+IMG_IMPORT IMG_UINT32 PVRSRVClockus (void);
+IMG_IMPORT IMG_VOID PVRSRVWaitus (IMG_UINT32 ui32Timeus);
+IMG_IMPORT IMG_VOID PVRSRVReleaseThreadQuanta (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 PVRSRVCreateAppHintState(IMG_MODULE_ID eModuleID,
+                                                                                                                const IMG_CHAR *pszAppName,
+                                                                                                                IMG_VOID **ppvState);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVFreeAppHintState(IMG_MODULE_ID eModuleID,
+                                                                                 IMG_VOID *pvHintState);
+
+IMG_IMPORT IMG_BOOL IMG_CALLCONV PVRSRVGetAppHint(IMG_VOID                      *pvHintState,
+                                                                                                  const IMG_CHAR        *pszHintName,
+                                                                                                  IMG_DATA_TYPE         eDataType,
+                                                                                                  const IMG_VOID        *pvDefault,
+                                                                                                  IMG_VOID                      *pvReturn);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVAllocUserModeMem (IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVCallocUserModeMem (IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVReallocUserModeMem (IMG_PVOID pvBase, IMG_SIZE_T uNewSize);
+IMG_IMPORT IMG_VOID  IMG_CALLCONV PVRSRVFreeUserModeMem (IMG_PVOID pvMem);
+IMG_IMPORT IMG_VOID PVRSRVMemCopy(IMG_VOID *pvDst, const IMG_VOID *pvSrc, IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_VOID PVRSRVMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_SIZE_T ui32Size);
+
+struct _PVRSRV_MUTEX_OPAQUE_STRUCT_;
+typedef struct  _PVRSRV_MUTEX_OPAQUE_STRUCT_ *PVRSRV_MUTEX_HANDLE;
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateMutex(PVRSRV_MUTEX_HANDLE *phMutex);
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyMutex(PVRSRV_MUTEX_HANDLE hMutex);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVLockMutex(PVRSRV_MUTEX_HANDLE hMutex);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVUnlockMutex(PVRSRV_MUTEX_HANDLE hMutex);
+
+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_HANDLE hOSEvent);
+
+IMG_IMPORT
+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(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))
+
+#if defined (__cplusplus)
+}
+#endif
+#endif 
+
diff --git a/drivers/gpu/pvr/services_headers.h b/drivers/gpu/pvr/services_headers.h
new file mode 100644
index 00000000000..eb00dbb30f3
--- /dev/null
+++ b/drivers/gpu/pvr/services_headers.h
@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * 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_HEADERS_H
+#define SERVICES_HEADERS_H
+
+#ifdef DEBUG_RELEASE_BUILD
+#pragma optimize( "", off )
+#define DEBUG           1
+#endif
+
+#include "img_defs.h"
+#include "services.h"
+#include "servicesint.h"
+#include "power.h"
+#include "resman.h"
+#include "queue.h"
+#include "srvkm.h"
+#include "kerneldisplay.h"
+#include "syscommon.h"
+#include "pvr_debug.h"
+#include "metrics.h"
+#include "osfunc.h"
+
+#endif 
+
diff --git a/drivers/gpu/pvr/servicesext.h b/drivers/gpu/pvr/servicesext.h
new file mode 100644
index 00000000000..759cffe2e15
--- /dev/null
+++ b/drivers/gpu/pvr/servicesext.h
@@ -0,0 +1,850 @@
+/**********************************************************************
+ *
+ * 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 (__SERVICESEXT_H__)
+#define __SERVICESEXT_H__
+
+#define PVRSRV_LOCKFLG_READONLY         (1)             
+
+typedef enum _PVRSRV_ERROR_
+{
+        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_ERROR;
+
+
+typedef enum _PVRSRV_DEVICE_CLASS_
+{
+        PVRSRV_DEVICE_CLASS_3D                          = 0 ,
+        PVRSRV_DEVICE_CLASS_DISPLAY                     = 1 ,
+        PVRSRV_DEVICE_CLASS_BUFFER                      = 2 ,
+        PVRSRV_DEVICE_CLASS_VIDEO                       = 3 ,
+
+        PVRSRV_DEVICE_CLASS_FORCE_I32           = 0x7fffffff
+
+} PVRSRV_DEVICE_CLASS;
+
+
+typedef enum _PVRSRV_SYS_POWER_STATE_
+{
+        PVRSRV_SYS_POWER_STATE_Unspecified              = -1,   
+        PVRSRV_SYS_POWER_STATE_D0                               = 0,    
+        PVRSRV_SYS_POWER_STATE_D1                               = 1,    
+        PVRSRV_SYS_POWER_STATE_D2                               = 2,    
+        PVRSRV_SYS_POWER_STATE_D3                               = 3,    
+        PVRSRV_SYS_POWER_STATE_D4                               = 4,    
+
+        PVRSRV_SYS_POWER_STATE_FORCE_I32 = 0x7fffffff
+
+} PVRSRV_SYS_POWER_STATE, *PPVRSRV_SYS_POWER_STATE;
+
+
+typedef enum _PVRSRV_DEV_POWER_STATE_
+{
+        PVRSRV_DEV_POWER_STATE_DEFAULT  = -1,   
+        PVRSRV_DEV_POWER_STATE_ON               = 0,    
+        PVRSRV_DEV_POWER_STATE_IDLE             = 1,    
+        PVRSRV_DEV_POWER_STATE_OFF              = 2,    
+
+        PVRSRV_DEV_POWER_STATE_FORCE_I32 = 0x7fffffff
+
+} PVRSRV_DEV_POWER_STATE, *PPVRSRV_DEV_POWER_STATE;     
+
+
+typedef PVRSRV_ERROR (*PFN_PRE_POWER) (IMG_HANDLE                               hDevHandle,
+                                                                           PVRSRV_DEV_POWER_STATE       eNewPowerState,
+                                                                           PVRSRV_DEV_POWER_STATE       eCurrentPowerState);
+typedef PVRSRV_ERROR (*PFN_POST_POWER) (IMG_HANDLE                              hDevHandle,
+                                                                                PVRSRV_DEV_POWER_STATE  eNewPowerState,
+                                                                                PVRSRV_DEV_POWER_STATE  eCurrentPowerState);
+
+typedef PVRSRV_ERROR (*PFN_PRE_CLOCKSPEED_CHANGE) (IMG_HANDLE                           hDevHandle,
+                                                                                                   IMG_BOOL                                     bIdleDevice,
+                                                                                                   PVRSRV_DEV_POWER_STATE       eCurrentPowerState);
+typedef PVRSRV_ERROR (*PFN_POST_CLOCKSPEED_CHANGE) (IMG_HANDLE                          hDevHandle,
+                                                                                                        IMG_BOOL                                bIdleDevice,
+                                                                                                        PVRSRV_DEV_POWER_STATE  eCurrentPowerState);
+
+
+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                    = 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_DXT1                                = 56,
+        PVRSRV_PIXEL_FORMAT_DXT2                                = 57,
+        PVRSRV_PIXEL_FORMAT_DXT3                                = 58,
+        PVRSRV_PIXEL_FORMAT_DXT4                                = 59,
+        PVRSRV_PIXEL_FORMAT_DXT5                                = 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_BC1                                 = 146,  
+        PVRSRV_PIXEL_FORMAT_BC1_UNORM                   = 147,  
+        PVRSRV_PIXEL_FORMAT_BC1_SRGB                    = 148,  
+        PVRSRV_PIXEL_FORMAT_BC2                                 = 149,  
+        PVRSRV_PIXEL_FORMAT_BC2_UNORM                   = 150,  
+        PVRSRV_PIXEL_FORMAT_BC2_SRGB                    = 151,  
+        PVRSRV_PIXEL_FORMAT_BC3                                 = 152,  
+        PVRSRV_PIXEL_FORMAT_BC3_UNORM                   = 153,  
+        PVRSRV_PIXEL_FORMAT_BC3_SRGB                    = 154,  
+        PVRSRV_PIXEL_FORMAT_BC4                                 = 155,  
+        PVRSRV_PIXEL_FORMAT_BC4_UNORM                   = 156,  
+        PVRSRV_PIXEL_FORMAT_BC4_SNORM                   = 157,  
+        PVRSRV_PIXEL_FORMAT_BC5                                 = 158,  
+        PVRSRV_PIXEL_FORMAT_BC5_UNORM                   = 159,
+        PVRSRV_PIXEL_FORMAT_BC5_SNORM                   = 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_ {
+        PVRSRV_ALPHA_FORMAT_UNKNOWN             =  0x00000000,
+        PVRSRV_ALPHA_FORMAT_PRE                 =  0x00000001,
+        PVRSRV_ALPHA_FORMAT_NONPRE              =  0x00000002,
+        PVRSRV_ALPHA_FORMAT_MASK                =  0x0000000F,
+} PVRSRV_ALPHA_FORMAT;
+
+typedef enum _PVRSRV_COLOURSPACE_FORMAT_ {
+        PVRSRV_COLOURSPACE_FORMAT_UNKNOWN               =  0x00000000,
+        PVRSRV_COLOURSPACE_FORMAT_LINEAR                =  0x00010000,
+        PVRSRV_COLOURSPACE_FORMAT_NONLINEAR             =  0x00020000,
+        PVRSRV_COLOURSPACE_FORMAT_MASK                  =  0x000F0000,
+} PVRSRV_COLOURSPACE_FORMAT;
+
+
+typedef enum _PVRSRV_ROTATION_ {
+        PVRSRV_ROTATE_0         =       0,
+        PVRSRV_ROTATE_90        =       1,
+        PVRSRV_ROTATE_180       =       2,
+        PVRSRV_ROTATE_270       =       3,
+        PVRSRV_FLIP_Y
+
+} PVRSRV_ROTATION;
+
+#define PVRSRV_CREATE_SWAPCHAIN_SHARED          (1<<0)
+#define PVRSRV_CREATE_SWAPCHAIN_QUERY           (1<<1)
+#define PVRSRV_CREATE_SWAPCHAIN_OEMOVERLAY      (1<<2)
+
+typedef struct _PVRSRV_SYNC_DATA_
+{
+        
+        IMG_UINT32                                      ui32WriteOpsPending;
+        volatile IMG_UINT32                     ui32WriteOpsComplete;
+
+        
+        IMG_UINT32                                      ui32ReadOpsPending;
+        volatile IMG_UINT32                     ui32ReadOpsComplete;
+
+        
+        IMG_UINT32                                      ui32LastOpDumpVal;
+        IMG_UINT32                                      ui32LastReadOpDumpVal;
+
+} PVRSRV_SYNC_DATA;
+
+typedef struct _PVRSRV_CLIENT_SYNC_INFO_
+{
+        
+        PVRSRV_SYNC_DATA                        *psSyncData;
+
+        
+
+
+        
+        IMG_DEV_VIRTADDR                sWriteOpsCompleteDevVAddr;
+
+        
+        IMG_DEV_VIRTADDR                sReadOpsCompleteDevVAddr;
+
+        
+        IMG_HANDLE                                      hMappingInfo;
+
+        
+        IMG_HANDLE                                      hKernelSyncInfo;
+
+} PVRSRV_CLIENT_SYNC_INFO, *PPVRSRV_CLIENT_SYNC_INFO;
+
+typedef struct PVRSRV_RESOURCE_TAG
+{
+        volatile IMG_UINT32 ui32Lock;
+        IMG_UINT32                      ui32ID;
+}PVRSRV_RESOURCE;
+typedef PVRSRV_RESOURCE PVRSRV_RES_HANDLE;
+
+
+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 struct _IMG_RECT_
+{
+        IMG_INT32       x0;
+        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_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*,
+                                                                                        IMG_UINT32*);
+
+
+typedef struct DISPLAY_DIMS_TAG
+{
+        IMG_UINT32      ui32ByteStride;
+        IMG_UINT32      ui32Width;
+        IMG_UINT32      ui32Height;
+} DISPLAY_DIMS;
+
+
+typedef struct DISPLAY_FORMAT_TAG
+{
+        
+        PVRSRV_PIXEL_FORMAT             pixelformat;
+} DISPLAY_FORMAT;
+
+typedef struct DISPLAY_SURF_ATTRIBUTES_TAG
+{
+        
+        PVRSRV_PIXEL_FORMAT             pixelformat;
+        
+        DISPLAY_DIMS                    sDims;
+} DISPLAY_SURF_ATTRIBUTES;
+
+
+typedef struct DISPLAY_MODE_INFO_TAG
+{
+        
+        PVRSRV_PIXEL_FORMAT             pixelformat;
+        
+        DISPLAY_DIMS                    sDims;
+        
+        IMG_UINT32                              ui32RefreshHZ;
+        
+        IMG_UINT32                              ui32OEMFlags;
+} DISPLAY_MODE_INFO;
+
+
+
+#define MAX_DISPLAY_NAME_SIZE   (50) 
+
+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              ui32Size;
+        IMG_UINT32      ui32FBPhysBaseAddress;
+        IMG_UINT32              ui32FBMemAvailable;                     
+        IMG_UINT32      ui32SysPhysBaseAddress;
+        IMG_UINT32              ui32SysSize;
+        IMG_UINT32              ui32DevIRQ;
+}ACCESS_INFO;
+
+
+typedef struct PVRSRV_CURSOR_SHAPE_TAG
+{
+        IMG_UINT16                      ui16Width;
+        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_CURSOR_SHAPE;
+
+#define PVRSRV_SET_CURSOR_VISIBILITY    (1<<0)
+#define PVRSRV_SET_CURSOR_POSITION              (1<<1)
+#define PVRSRV_SET_CURSOR_SHAPE                 (1<<2)
+#define PVRSRV_SET_CURSOR_ROTATION              (1<<3)
+
+typedef struct PVRSRV_CURSOR_INFO_TAG
+{
+        
+        IMG_UINT32 ui32Flags;
+
+        
+        IMG_BOOL bVisible;
+
+        
+        IMG_INT16 i16XPos;
+        IMG_INT16 i16YPos;
+
+        
+        PVRSRV_CURSOR_SHAPE sCursorShape;
+
+        
+        IMG_UINT32 ui32Rotation;
+
+} PVRSRV_CURSOR_INFO;
+
+
+typedef struct _PVRSRV_REGISTRY_INFO_
+{
+    IMG_UINT32          ui32DevCookie;
+    IMG_PCHAR           pszKey;
+    IMG_PCHAR           pszValue;
+    IMG_PCHAR           pszBuf;
+    IMG_UINT32          ui32BufSize;
+} PVRSRV_REGISTRY_INFO, *PPVRSRV_REGISTRY_INFO;
+
+
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReadRegistryString (PPVRSRV_REGISTRY_INFO psRegInfo);
+PVRSRV_ERROR IMG_CALLCONV PVRSRVWriteRegistryString (PPVRSRV_REGISTRY_INFO psRegInfo);
+
+
+#define PVRSRV_BC_FLAGS_YUVCSC_CONFORMANT_RANGE (0 << 0)
+#define PVRSRV_BC_FLAGS_YUVCSC_FULL_RANGE               (1 << 0)
+
+#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                      ui32BufferDeviceID;
+        PVRSRV_PIXEL_FORMAT     pixelformat;
+        IMG_UINT32                      ui32ByteStride;
+        IMG_UINT32                      ui32Width;
+        IMG_UINT32                      ui32Height;
+        IMG_UINT32                      ui32Flags;
+        IMG_CHAR                        szDeviceName[MAX_BUFFER_DEVICE_NAME_SIZE];
+} BUFFER_INFO;
+
+typedef enum _OVERLAY_DEINTERLACE_MODE_
+{
+        WEAVE=0x0,
+        BOB_ODD,
+        BOB_EVEN,
+        BOB_EVEN_NONINTERLEAVED
+} OVERLAY_DEINTERLACE_MODE;
+
+#endif 
diff --git a/drivers/gpu/pvr/servicesint.h b/drivers/gpu/pvr/servicesint.h
new file mode 100644
index 00000000000..bc5aeb8dc0b
--- /dev/null
+++ b/drivers/gpu/pvr/servicesint.h
@@ -0,0 +1,282 @@
+/**********************************************************************
+ *
+ * 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 (__SERVICESINT_H__)
+#define __SERVICESINT_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "services.h"
+#include "sysinfo.h"
+
+#define HWREC_DEFAULT_TIMEOUT   (500)
+
+#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;
+
+        
+        PVRSRV_MEMBLK                   sMemBlk;
+
+        
+        IMG_PVOID                               pvSysBackupBuffer;
+
+        
+        IMG_UINT32                              ui32RefCount;
+
+        
+        IMG_BOOL                                bPendingFree;
+
+
+#if defined(SUPPORT_MEMINFO_IDS)
+        #if !defined(USE_CODE)
+        
+        IMG_UINT64                              ui64Stamp;
+        #else 
+        IMG_UINT32                              dummy1;
+        IMG_UINT32                              dummy2;
+        #endif 
+#endif 
+
+        
+        struct _PVRSRV_KERNEL_SYNC_INFO_        *psKernelSyncInfo;
+
+        PVRSRV_MEMTYPE                          memType;
+} PVRSRV_KERNEL_MEM_INFO;
+
+
+typedef struct _PVRSRV_KERNEL_SYNC_INFO_
+{
+        
+        PVRSRV_SYNC_DATA                *psSyncData;
+
+        
+        IMG_DEV_VIRTADDR                sWriteOpsCompleteDevVAddr;
+
+        
+        IMG_DEV_VIRTADDR                sReadOpsCompleteDevVAddr;
+
+        
+        PVRSRV_KERNEL_MEM_INFO  *psSyncDataMemInfoKM;
+
+        
+        
+        IMG_UINT32              ui32RefCount;
+
+        
+        IMG_HANDLE hResItem;
+} PVRSRV_KERNEL_SYNC_INFO;
+
+typedef struct _PVRSRV_DEVICE_SYNC_OBJECT_
+{
+        
+        IMG_UINT32                      ui32ReadOpsPendingVal;
+        IMG_DEV_VIRTADDR        sReadOpsCompleteDevVAddr;
+        IMG_UINT32                      ui32WriteOpsPendingVal;
+        IMG_DEV_VIRTADDR        sWriteOpsCompleteDevVAddr;
+} PVRSRV_DEVICE_SYNC_OBJECT;
+
+typedef struct _PVRSRV_SYNC_OBJECT
+{
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfoKM;
+        IMG_UINT32                              ui32WriteOpsPending;
+        IMG_UINT32                              ui32ReadOpsPending;
+
+}PVRSRV_SYNC_OBJECT, *PPVRSRV_SYNC_OBJECT;
+
+typedef struct _PVRSRV_COMMAND
+{
+        IMG_SIZE_T                      ui32CmdSize;            
+        IMG_UINT32                      ui32DevIndex;           
+        IMG_UINT32                      CommandType;            
+        IMG_UINT32                      ui32DstSyncCount;       
+        IMG_UINT32                      ui32SrcSyncCount;       
+        PVRSRV_SYNC_OBJECT      *psDstSync;                     
+        PVRSRV_SYNC_OBJECT      *psSrcSync;                     
+        IMG_SIZE_T                      ui32DataSize;           
+        IMG_UINT32                      ui32ProcessID;          
+        IMG_VOID                        *pvData;                        
+}PVRSRV_COMMAND, *PPVRSRV_COMMAND;
+
+
+typedef struct _PVRSRV_QUEUE_INFO_
+{
+        IMG_VOID                        *pvLinQueueKM;                  
+        IMG_VOID                        *pvLinQueueUM;                  
+        volatile IMG_SIZE_T     ui32ReadOffset;                 
+        volatile IMG_SIZE_T     ui32WriteOffset;                
+        IMG_UINT32                      *pui32KickerAddrKM;             
+        IMG_UINT32                      *pui32KickerAddrUM;             
+        IMG_SIZE_T                      ui32QueueSize;                  
+
+        IMG_UINT32                      ui32ProcessID;                  
+
+        IMG_HANDLE                      hMemBlock[2];
+
+        struct _PVRSRV_QUEUE_INFO_ *psNextKM;           
+}PVRSRV_QUEUE_INFO;
+
+typedef PVRSRV_ERROR (*PFN_INSERT_CMD) (PVRSRV_QUEUE_INFO*,
+                                                                                PVRSRV_COMMAND**,
+                                                                                IMG_UINT32,
+                                                                                IMG_UINT16,
+                                                                                IMG_UINT32,
+                                                                                PVRSRV_KERNEL_SYNC_INFO*[],
+                                                                                IMG_UINT32,
+                                                                                PVRSRV_KERNEL_SYNC_INFO*[],
+                                                                                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;
+        IMG_HANDLE                              hExtBuffer;
+        PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
+
+} PVRSRV_DEVICECLASS_BUFFER;
+
+
+typedef struct PVRSRV_CLIENT_DEVICECLASS_INFO_TAG
+{
+        IMG_HANDLE hDeviceKM;
+        IMG_HANDLE      hServices;
+} PVRSRV_CLIENT_DEVICECLASS_INFO;
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVGetWriteOpsPending)
+#endif
+static INLINE
+IMG_UINT32 PVRSRVGetWriteOpsPending(PVRSRV_KERNEL_SYNC_INFO *psSyncInfo, IMG_BOOL bIsReadOp)
+{
+        IMG_UINT32 ui32WriteOpsPending;
+
+        if(bIsReadOp)
+        {
+                ui32WriteOpsPending = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+        else
+        {
+                
+
+
+                ui32WriteOpsPending = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+        }
+
+        return ui32WriteOpsPending;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVGetReadOpsPending)
+#endif
+static INLINE
+IMG_UINT32 PVRSRVGetReadOpsPending(PVRSRV_KERNEL_SYNC_INFO *psSyncInfo, IMG_BOOL bIsReadOp)
+{
+        IMG_UINT32 ui32ReadOpsPending;
+
+        if(bIsReadOp)
+        {
+                ui32ReadOpsPending = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+        }
+        else
+        {
+                ui32ReadOpsPending = psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+
+        return ui32ReadOpsPending;
+}
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVQueueCommand(IMG_HANDLE hQueueInfo,
+                                                                PVRSRV_COMMAND *psCommand);
+
+
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV
+PVRSRVGetMMUContextPDDevPAddr(const PVRSRV_CONNECTION *psConnection,
+                              IMG_HANDLE hDevMemContext,
+                              IMG_DEV_PHYADDR *sPDDevPAddr);
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV
+PVRSRVAllocSharedSysMem(const PVRSRV_CONNECTION *psConnection,
+                                                IMG_UINT32 ui32Flags,
+                                                IMG_SIZE_T ui32Size,
+                                                PVRSRV_CLIENT_MEM_INFO **ppsClientMemInfo);
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV
+PVRSRVFreeSharedSysMem(const PVRSRV_CONNECTION *psConnection,
+                                           PVRSRV_CLIENT_MEM_INFO *psClientMemInfo);
+
+IMG_IMPORT PVRSRV_ERROR
+PVRSRVUnrefSharedSysMem(const PVRSRV_CONNECTION *psConnection,
+                        PVRSRV_CLIENT_MEM_INFO *psClientMemInfo);
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV
+PVRSRVMapMemInfoMem(const PVRSRV_CONNECTION *psConnection,
+                    IMG_HANDLE hKernelMemInfo,
+                    PVRSRV_CLIENT_MEM_INFO **ppsClientMemInfo);
+
+
+#if defined (__cplusplus)
+}
+#endif
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx/bridged_sgx_bridge.c b/drivers/gpu/pvr/sgx/bridged_sgx_bridge.c
new file mode 100644
index 00000000000..e1b73201a12
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/bridged_sgx_bridge.c
@@ -0,0 +1,2670 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "img_defs.h"
+
+#if defined(SUPPORT_SGX)
+
+#include "services.h"
+#include "pvr_debug.h"
+#include "pvr_bridge.h"
+#include "sgx_bridge.h"
+#include "perproc.h"
+#include "power.h"
+#include "pvr_bridge_km.h"
+#include "sgx_bridge_km.h"
+
+#if defined(SUPPORT_MSVDX)
+        #include "msvdx_bridge.h"
+#endif
+
+#include "bridged_pvr_bridge.h"
+#include "bridged_sgx_bridge.h"
+#include "sgxutils.h"
+#include "pdump_km.h"
+
+static IMG_INT
+SGXGetClientInfoBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_GETCLIENTINFO *psGetClientInfoIN,
+                                   PVRSRV_BRIDGE_OUT_GETCLIENTINFO *psGetClientInfoOUT,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_GETCLIENTINFO);
+
+        psGetClientInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psGetClientInfoIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psGetClientInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psGetClientInfoOUT->eError =
+                SGXGetClientInfoKM(hDevCookieInt,
+                                                   &psGetClientInfoOUT->sClientInfo);
+        return 0;
+}
+
+static IMG_INT
+SGXReleaseClientInfoBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_RELEASECLIENTINFO *psReleaseClientInfoIN,
+                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+        IMG_HANDLE hDevCookieInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_RELEASECLIENTINFO);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psReleaseClientInfoIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookieInt)->pvDevice;
+
+        PVR_ASSERT(psDevInfo->ui32ClientRefCount > 0);
+
+        psDevInfo->ui32ClientRefCount--;
+
+        psRetOUT->eError = PVRSRV_OK;
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXGetInternalDevInfoBW(IMG_UINT32 ui32BridgeID,
+                                                PVRSRV_BRIDGE_IN_GETINTERNALDEVINFO *psSGXGetInternalDevInfoIN,
+                                                PVRSRV_BRIDGE_OUT_GETINTERNALDEVINFO *psSGXGetInternalDevInfoOUT,
+                                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_GETINTERNALDEVINFO);
+
+        psSGXGetInternalDevInfoOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psSGXGetInternalDevInfoIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psSGXGetInternalDevInfoOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psSGXGetInternalDevInfoOUT->eError =
+                SGXGetInternalDevInfoKM(hDevCookieInt,
+                                                                &psSGXGetInternalDevInfoOUT->sSGXInternalDevInfo);
+
+        
+        psSGXGetInternalDevInfoOUT->eError =
+                PVRSRVAllocHandle(psPerProc->psHandleBase,
+                                                  &psSGXGetInternalDevInfoOUT->sSGXInternalDevInfo.hHostCtlKernelMemInfoHandle,
+                                                  psSGXGetInternalDevInfoOUT->sSGXInternalDevInfo.hHostCtlKernelMemInfoHandle,
+                                                  PVRSRV_HANDLE_TYPE_MEM_INFO,
+                                                  PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXDoKickBW(IMG_UINT32 ui32BridgeID,
+                        PVRSRV_BRIDGE_IN_DOKICK *psDoKickIN,
+                        PVRSRV_BRIDGE_RETURN *psRetOUT,
+                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_UINT32 i;
+        IMG_INT ret = 0;
+        IMG_UINT32 ui32NumDstSyncs;
+        IMG_HANDLE *phKernelSyncInfoHandles = IMG_NULL;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_DOKICK);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psDoKickIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &psDoKickIN->sCCBKick.hCCBKernelMemInfo,
+                                                   psDoKickIN->sCCBKick.hCCBKernelMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if(psDoKickIN->sCCBKick.hTA3DSyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.hTA3DSyncInfo,
+                                                           psDoKickIN->sCCBKick.hTA3DSyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if(psDoKickIN->sCCBKick.hTASyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.hTASyncInfo,
+                                                           psDoKickIN->sCCBKick.hTASyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if(psDoKickIN->sCCBKick.h3DSyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.h3DSyncInfo,
+                                                           psDoKickIN->sCCBKick.h3DSyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+        
+        if (psDoKickIN->sCCBKick.ui32NumTASrcSyncs > SGX_MAX_TA_SRC_SYNCS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+
+        for(i=0; i<psDoKickIN->sCCBKick.ui32NumTASrcSyncs; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ahTASrcKernelSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ahTASrcKernelSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psDoKickIN->sCCBKick.ui32NumTADstSyncs > SGX_MAX_TA_DST_SYNCS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+
+        for(i=0; i<psDoKickIN->sCCBKick.ui32NumTADstSyncs; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ahTADstKernelSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ahTADstKernelSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psDoKickIN->sCCBKick.ui32Num3DSrcSyncs > SGX_MAX_3D_SRC_SYNCS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+
+        for(i=0; i<psDoKickIN->sCCBKick.ui32Num3DSrcSyncs; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ah3DSrcKernelSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ah3DSrcKernelSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+#else
+        
+        if (psDoKickIN->sCCBKick.ui32NumSrcSyncs > SGX_MAX_SRC_SYNCS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for(i=0; i<psDoKickIN->sCCBKick.ui32NumSrcSyncs; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ahSrcKernelSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ahSrcKernelSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+#endif
+
+        if (psDoKickIN->sCCBKick.ui32NumTAStatusVals > SGX_MAX_TA_STATUS_VALS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for (i = 0; i < psDoKickIN->sCCBKick.ui32NumTAStatusVals; i++)
+        {
+                psRetOUT->eError =
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.asTAStatusUpdate[i].hKernelMemInfo,
+                                                           psDoKickIN->sCCBKick.asTAStatusUpdate[i].hKernelMemInfo,
+                                                           PVRSRV_HANDLE_TYPE_MEM_INFO);
+#else
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ahTAStatusSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ahTAStatusSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+#endif
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psDoKickIN->sCCBKick.ui32Num3DStatusVals > SGX_MAX_3D_STATUS_VALS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for(i = 0; i < psDoKickIN->sCCBKick.ui32Num3DStatusVals; i++)
+        {
+                psRetOUT->eError =
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.as3DStatusUpdate[i].hKernelMemInfo,
+                                                           psDoKickIN->sCCBKick.as3DStatusUpdate[i].hKernelMemInfo,
+                                                           PVRSRV_HANDLE_TYPE_MEM_INFO);
+#else
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psDoKickIN->sCCBKick.ah3DStatusSyncInfo[i],
+                                                           psDoKickIN->sCCBKick.ah3DStatusSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+#endif
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        ui32NumDstSyncs = psDoKickIN->sCCBKick.ui32NumDstSyncObjects;
+
+        if(ui32NumDstSyncs > 0)
+        {
+                if(!OSAccessOK(PVR_VERIFY_READ,
+                                                psDoKickIN->sCCBKick.pahDstSyncHandles,
+                                                ui32NumDstSyncs * sizeof(IMG_HANDLE)))
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "%s: SGXDoKickBW:"
+                                        " Invalid pasDstSyncHandles pointer", __FUNCTION__));
+                        return -EFAULT;
+                }
+
+                psRetOUT->eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                                                ui32NumDstSyncs * sizeof(IMG_HANDLE),
+                                                                                (IMG_VOID **)&phKernelSyncInfoHandles,
+                                                                                0,
+                                                                                "Array of Synchronization Info Handles");
+                if (psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+
+                if(CopyFromUserWrapper(psPerProc,
+                                                        ui32BridgeID,
+                                                        phKernelSyncInfoHandles,
+                                                        psDoKickIN->sCCBKick.pahDstSyncHandles,
+                                                        ui32NumDstSyncs * sizeof(IMG_HANDLE)) != PVRSRV_OK)
+                {
+                        ret = -EFAULT;
+                        goto PVRSRV_BRIDGE_SGX_DOKICK_RETURN_RESULT;
+                }
+
+                
+                psDoKickIN->sCCBKick.pahDstSyncHandles = phKernelSyncInfoHandles;
+
+                for( i = 0; i < ui32NumDstSyncs; i++)
+                {
+                        psRetOUT->eError =
+                                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                        &psDoKickIN->sCCBKick.pahDstSyncHandles[i],
+                                                                        psDoKickIN->sCCBKick.pahDstSyncHandles[i],
+                                                                        PVRSRV_HANDLE_TYPE_SYNC_INFO);
+
+                        if(psRetOUT->eError != PVRSRV_OK)
+                        {
+                                goto PVRSRV_BRIDGE_SGX_DOKICK_RETURN_RESULT;
+                        }
+
+                }
+
+                psRetOUT->eError =
+                                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                           &psDoKickIN->sCCBKick.hKernelHWSyncListMemInfo,
+                                                                           psDoKickIN->sCCBKick.hKernelHWSyncListMemInfo,
+                                                                           PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        goto PVRSRV_BRIDGE_SGX_DOKICK_RETURN_RESULT;
+                }
+        }
+
+        psRetOUT->eError =
+                SGXDoKickKM(hDevCookieInt,
+                                        &psDoKickIN->sCCBKick);
+
+PVRSRV_BRIDGE_SGX_DOKICK_RETURN_RESULT:
+
+        if(phKernelSyncInfoHandles)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32NumDstSyncs * sizeof(IMG_HANDLE),
+                                  (IMG_VOID *)phKernelSyncInfoHandles,
+                                  0);
+                
+        }
+        return ret;
+}
+
+
+static IMG_INT
+SGXScheduleProcessQueuesBW(IMG_UINT32 ui32BridgeID,
+                        PVRSRV_BRIDGE_IN_SGX_SCHEDULE_PROCESS_QUEUES *psScheduleProcQIN,
+                        PVRSRV_BRIDGE_RETURN *psRetOUT,
+                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psScheduleProcQIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = SGXScheduleProcessQueuesKM(hDevCookieInt);
+
+        return 0;
+}
+
+
+#if defined(TRANSFER_QUEUE)
+static IMG_INT
+SGXSubmitTransferBW(IMG_UINT32 ui32BridgeID,
+                        PVRSRV_BRIDGE_IN_SUBMITTRANSFER *psSubmitTransferIN,
+                        PVRSRV_BRIDGE_RETURN *psRetOUT,
+                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_TRANSFER_SGX_KICK *psKick;
+        IMG_UINT32 i;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_SUBMITTRANSFER);
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+
+        psKick = &psSubmitTransferIN->sKick;
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSubmitTransferIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &psKick->hCCBMemInfo,
+                                                   psKick->hCCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if (psKick->hTASyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->hTASyncInfo,
+                                                           psKick->hTASyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->h3DSyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->h3DSyncInfo,
+                                                           psKick->h3DSyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->ui32NumSrcSync > SGX_MAX_TRANSFER_SYNC_OPS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for (i = 0; i < psKick->ui32NumSrcSync; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->ahSrcSyncInfo[i],
+                                                           psKick->ahSrcSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->ui32NumDstSync > SGX_MAX_TRANSFER_SYNC_OPS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for (i = 0; i < psKick->ui32NumDstSync; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->ahDstSyncInfo[i],
+                                                           psKick->ahDstSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        psRetOUT->eError = SGXSubmitTransferKM(hDevCookieInt, psKick);
+
+        return 0;
+}
+
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+static IMG_INT
+SGXSubmit2DBW(IMG_UINT32 ui32BridgeID,
+                        PVRSRV_BRIDGE_IN_SUBMIT2D *psSubmit2DIN,
+                        PVRSRV_BRIDGE_RETURN *psRetOUT,
+                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_2D_SGX_KICK *psKick;
+        IMG_UINT32 i;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_SUBMIT2D);
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSubmit2DIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psKick = &psSubmit2DIN->sKick;
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &psKick->hCCBMemInfo,
+                                                   psKick->hCCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        if (psKick->hTASyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->hTASyncInfo,
+                                                           psKick->hTASyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->h3DSyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->h3DSyncInfo,
+                                                           psKick->h3DSyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->ui32NumSrcSync > SGX_MAX_2D_SRC_SYNC_OPS)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+                return 0;
+        }
+        for (i = 0; i < psKick->ui32NumSrcSync; i++)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->ahSrcSyncInfo[i],
+                                                           psKick->ahSrcSyncInfo[i],
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        if (psKick->hDstSyncInfo != IMG_NULL)
+        {
+                psRetOUT->eError =
+                        PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &psKick->hDstSyncInfo,
+                                                           psKick->hDstSyncInfo,
+                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        psRetOUT->eError =
+                SGXSubmit2DKM(hDevCookieInt, psKick);
+
+        return 0;
+}
+#endif 
+#endif 
+
+
+static IMG_INT
+SGXGetMiscInfoBW(IMG_UINT32 ui32BridgeID,
+                                 PVRSRV_BRIDGE_IN_SGXGETMISCINFO *psSGXGetMiscInfoIN,
+                                 PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                 PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hDevMemContextInt = 0;
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+        SGX_MISC_INFO        sMiscInfo;
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
+                                                        PVRSRV_BRIDGE_SGX_GETMISCINFO);
+
+        psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                        &hDevCookieInt,
+                                                        psSGXGetMiscInfoIN->hDevCookie,
+                                                        PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
+        
+        if (psSGXGetMiscInfoIN->psMiscInfo->eRequest == SGX_MISC_INFO_REQUEST_MEMREAD)
+        {
+                psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                &hDevMemContextInt,
+                                                                psSGXGetMiscInfoIN->psMiscInfo->hDevMemContext,
+                                                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
+
+                if(psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+#endif
+        
+        psDeviceNode = hDevCookieInt;
+        PVR_ASSERT(psDeviceNode != IMG_NULL);
+        if (psDeviceNode == IMG_NULL)
+        {
+                return -EFAULT;
+        }
+
+        psDevInfo = psDeviceNode->pvDevice;
+
+        
+        psRetOUT->eError = CopyFromUserWrapper(psPerProc,
+                                                       ui32BridgeID,
+                                                       &sMiscInfo,
+                                                       psSGXGetMiscInfoIN->psMiscInfo,
+                                                       sizeof(SGX_MISC_INFO));
+        if (psRetOUT->eError != PVRSRV_OK)
+        {
+                return -EFAULT;
+        }
+
+        {
+                psRetOUT->eError = SGXGetMiscInfoKM(psDevInfo, &sMiscInfo, psDeviceNode, hDevMemContextInt);
+
+                if (psRetOUT->eError != PVRSRV_OK)
+                {
+                        return 0;
+                }
+        }
+
+        
+        psRetOUT->eError = CopyToUserWrapper(psPerProc,
+                                             ui32BridgeID,
+                                             psSGXGetMiscInfoIN->psMiscInfo,
+                                             &sMiscInfo,
+                                             sizeof(SGX_MISC_INFO));
+        if (psRetOUT->eError != PVRSRV_OK)
+        {
+                return -EFAULT;
+        }
+        return 0;
+}
+
+
+static IMG_INT
+SGXReadHWPerfCBBW(IMG_UINT32                                                    ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_SGX_READ_HWPERF_CB   *psSGXReadHWPerfCBIN,
+                                  PVRSRV_BRIDGE_OUT_SGX_READ_HWPERF_CB  *psSGXReadHWPerfCBOUT,
+                                  PVRSRV_PER_PROCESS_DATA                               *psPerProc)
+{
+        IMG_HANDLE                                      hDevCookieInt;
+        PVRSRV_SGX_HWPERF_CB_ENTRY      *psAllocated;
+        IMG_HANDLE                                      hAllocatedHandle;
+        IMG_UINT32                                      ui32AllocatedSize;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_READ_HWPERF_CB);
+
+        psSGXReadHWPerfCBOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                        &hDevCookieInt,
+                                                        psSGXReadHWPerfCBIN->hDevCookie,
+                                                        PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psSGXReadHWPerfCBOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        ui32AllocatedSize = psSGXReadHWPerfCBIN->ui32ArraySize *
+                                                        sizeof(psSGXReadHWPerfCBIN->psHWPerfCBData[0]);
+        ASSIGN_AND_EXIT_ON_ERROR(psSGXReadHWPerfCBOUT->eError,
+                            OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                            ui32AllocatedSize,
+                            (IMG_VOID **)&psAllocated,
+                            &hAllocatedHandle,
+                                                "Array of Hardware Performance Circular Buffer Data"));
+
+        psSGXReadHWPerfCBOUT->eError = SGXReadHWPerfCBKM(hDevCookieInt,
+                                                                                                         psSGXReadHWPerfCBIN->ui32ArraySize,
+                                                                                                         psAllocated,
+                                                                                                         &psSGXReadHWPerfCBOUT->ui32DataCount,
+                                                                                                         &psSGXReadHWPerfCBOUT->ui32ClockSpeed,
+                                                                                                         &psSGXReadHWPerfCBOUT->ui32HostTimeStamp);
+        if (psSGXReadHWPerfCBOUT->eError == PVRSRV_OK)
+        {
+                psSGXReadHWPerfCBOUT->eError = CopyToUserWrapper(psPerProc,
+                                                                 ui32BridgeID,
+                                                                 psSGXReadHWPerfCBIN->psHWPerfCBData,
+                                                                 psAllocated,
+                                                                 ui32AllocatedSize);
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          ui32AllocatedSize,
+                          psAllocated,
+                          hAllocatedHandle);
+        
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXDevInitPart2BW(IMG_UINT32 ui32BridgeID,
+                                  PVRSRV_BRIDGE_IN_SGXDEVINITPART2 *psSGXDevInitPart2IN,
+                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_ERROR eError;
+        IMG_BOOL bDissociateFailed = IMG_FALSE;
+        IMG_BOOL bLookupFailed = IMG_FALSE;
+        IMG_BOOL bReleaseFailed = IMG_FALSE;
+        IMG_HANDLE hDummy;
+        IMG_UINT32 i;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_DEVINITPART2);
+
+        if(!psPerProc->bInitProcess)
+        {
+                psRetOUT->eError = PVRSRV_ERROR_PROCESS_NOT_INITIALISED;
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXDevInitPart2IN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        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);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+#endif
+
+#if defined(SUPPORT_SGX_HWPERF)
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        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)
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+#endif
+
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDummy,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bLookupFailed = IMG_TRUE;
+        }
+#endif
+
+        for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
+        {
+                IMG_HANDLE hHandle = psSGXDevInitPart2IN->sInitInfo.asInitMemHandles[i];
+
+                if (hHandle == IMG_NULL)
+                {
+                        continue;
+                }
+
+                eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                           &hDummy,
+                                                           hHandle,
+                                                           PVRSRV_HANDLE_TYPE_MEM_INFO);
+                if (eError != PVRSRV_OK)
+                {
+                        bLookupFailed = IMG_TRUE;
+                }
+        }
+
+        if (bLookupFailed)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A handle lookup failed"));
+                psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
+                return 0;
+        }
+
+        
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+
+
+        #if defined(SGX_SUPPORT_HWPROFILING)
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+#endif
+
+#if defined(SUPPORT_SGX_HWPERF)
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelHWPerfCBMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        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)
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+#endif
+
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                   &psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
+                                                   psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo,
+                                                   PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if (eError != PVRSRV_OK)
+        {
+                bReleaseFailed = IMG_TRUE;
+        }
+#endif
+
+
+        for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
+        {
+                IMG_HANDLE *phHandle = &psSGXDevInitPart2IN->sInitInfo.asInitMemHandles[i];
+
+                if (*phHandle == IMG_NULL)
+                        continue;
+
+                eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
+                                                           phHandle,
+                                                           *phHandle,
+                                                           PVRSRV_HANDLE_TYPE_MEM_INFO);
+                if (eError != PVRSRV_OK)
+                {
+                        bReleaseFailed = IMG_TRUE;
+                }
+        }
+
+        if (bReleaseFailed)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A handle release failed"));
+                psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
+                
+                PVR_DBG_BREAK;
+                return 0;
+        }
+
+        
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBEventKickerMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+        
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+
+
+#if defined(SGX_SUPPORT_HWPROFILING)
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelHWProfilingMemInfo);
+        bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+#endif
+
+#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(PVRSRV_USSE_EDM_STATUS_DEBUG)
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelEDMStatusBufferMemInfo);
+        bDissociateFailed |= (IMG_BOOL)(eError != PVRSRV_OK);
+#endif
+
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelTmpDPMStateMemInfo);
+        if (eError != PVRSRV_OK)
+        {
+                bDissociateFailed = IMG_TRUE;
+        }
+#endif
+
+        for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
+        {
+                IMG_HANDLE hHandle = psSGXDevInitPart2IN->sInitInfo.asInitMemHandles[i];
+
+                if (hHandle == IMG_NULL)
+                        continue;
+
+                eError = PVRSRVDissociateDeviceMemKM(hDevCookieInt, hHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        bDissociateFailed = IMG_TRUE;
+                }
+        }
+
+        
+        if(bDissociateFailed)
+        {
+                PVRSRVFreeDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBMemInfo);
+                PVRSRVFreeDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelCCBCtlMemInfo);
+                PVRSRVFreeDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXHostCtlMemInfo);
+                PVRSRVFreeDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXTA3DCtlMemInfo);
+                PVRSRVFreeDeviceMemKM(hDevCookieInt, psSGXDevInitPart2IN->sInitInfo.hKernelSGXMiscMemInfo);
+
+                for (i = 0; i < SGX_MAX_INIT_MEM_HANDLES; i++)
+                {
+                        IMG_HANDLE hHandle = psSGXDevInitPart2IN->sInitInfo.asInitMemHandles[i];
+
+                        if (hHandle == IMG_NULL)
+                                continue;
+
+                        PVRSRVFreeDeviceMemKM(hDevCookieInt, (PVRSRV_KERNEL_MEM_INFO *)hHandle);
+
+                }
+
+                PVR_DPF((PVR_DBG_ERROR, "DevInitSGXPart2BW: A dissociate failed"));
+
+                psRetOUT->eError = PVRSRV_ERROR_INIT2_PHASE_FAILED;
+
+                
+                PVR_DBG_BREAK;
+                return 0;
+        }
+
+        psRetOUT->eError =
+                DevInitSGXPart2KM(psPerProc,
+                                                  hDevCookieInt,
+                                                  &psSGXDevInitPart2IN->sInitInfo);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXRegisterHWRenderContextBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_RENDER_CONTEXT *psSGXRegHWRenderContextIN,
+                                                         PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_RENDER_CONTEXT *psSGXRegHWRenderContextOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hHWRenderContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXRegHWRenderContextOUT->eError, psPerProc, 1);
+
+        psSGXRegHWRenderContextOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXRegHWRenderContextIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psSGXRegHWRenderContextOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        hHWRenderContextInt =
+                SGXRegisterHWRenderContextKM(hDevCookieInt,
+                                                                         &psSGXRegHWRenderContextIN->sHWRenderContextDevVAddr,
+                                                                         psPerProc);
+
+        if (hHWRenderContextInt == IMG_NULL)
+        {
+                psSGXRegHWRenderContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psSGXRegHWRenderContextOUT->hHWRenderContext,
+                                          hHWRenderContextInt,
+                                          PVRSRV_HANDLE_TYPE_SGX_HW_RENDER_CONTEXT,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psSGXRegHWRenderContextOUT->eError, psPerProc);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXUnregisterHWRenderContextBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_RENDER_CONTEXT *psSGXUnregHWRenderContextIN,
+                                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hHWRenderContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_UNREGISTER_HW_RENDER_CONTEXT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hHWRenderContextInt,
+                                                   psSGXUnregHWRenderContextIN->hHWRenderContext,
+                                                   PVRSRV_HANDLE_TYPE_SGX_HW_RENDER_CONTEXT);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = SGXUnregisterHWRenderContextKM(hHWRenderContextInt);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psSGXUnregHWRenderContextIN->hHWRenderContext,
+                                                        PVRSRV_HANDLE_TYPE_SGX_HW_RENDER_CONTEXT);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXRegisterHWTransferContextBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_TRANSFER_CONTEXT *psSGXRegHWTransferContextIN,
+                                                         PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_TRANSFER_CONTEXT *psSGXRegHWTransferContextOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hHWTransferContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_REGISTER_HW_TRANSFER_CONTEXT);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXRegHWTransferContextOUT->eError, psPerProc, 1);
+
+        psSGXRegHWTransferContextOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXRegHWTransferContextIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psSGXRegHWTransferContextOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        hHWTransferContextInt =
+                SGXRegisterHWTransferContextKM(hDevCookieInt,
+                                                                           &psSGXRegHWTransferContextIN->sHWTransferContextDevVAddr,
+                                                                           psPerProc);
+
+        if (hHWTransferContextInt == IMG_NULL)
+        {
+                psSGXRegHWTransferContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psSGXRegHWTransferContextOUT->hHWTransferContext,
+                                          hHWTransferContextInt,
+                                          PVRSRV_HANDLE_TYPE_SGX_HW_TRANSFER_CONTEXT,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psSGXRegHWTransferContextOUT->eError, psPerProc);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXUnregisterHWTransferContextBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_TRANSFER_CONTEXT *psSGXUnregHWTransferContextIN,
+                                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hHWTransferContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_UNREGISTER_HW_TRANSFER_CONTEXT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hHWTransferContextInt,
+                                                   psSGXUnregHWTransferContextIN->hHWTransferContext,
+                                                   PVRSRV_HANDLE_TYPE_SGX_HW_TRANSFER_CONTEXT);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = SGXUnregisterHWTransferContextKM(hHWTransferContextInt);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psSGXUnregHWTransferContextIN->hHWTransferContext,
+                                                        PVRSRV_HANDLE_TYPE_SGX_HW_TRANSFER_CONTEXT);
+
+        return 0;
+}
+
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+static IMG_INT
+SGXRegisterHW2DContextBW(IMG_UINT32 ui32BridgeID,
+                                                         PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_2D_CONTEXT *psSGXRegHW2DContextIN,
+                                                         PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_2D_CONTEXT *psSGXRegHW2DContextOUT,
+                                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_HANDLE hHW2DContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_REGISTER_HW_2D_CONTEXT);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXRegHW2DContextOUT->eError, psPerProc, 1);
+
+        psSGXRegHW2DContextOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXRegHW2DContextIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psSGXRegHW2DContextOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        hHW2DContextInt =
+                SGXRegisterHW2DContextKM(hDevCookieInt,
+                                                                 &psSGXRegHW2DContextIN->sHW2DContextDevVAddr,
+                                                                 psPerProc);
+
+        if (hHW2DContextInt == IMG_NULL)
+        {
+                psSGXRegHW2DContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT;
+                return 0;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psSGXRegHW2DContextOUT->hHW2DContext,
+                                          hHW2DContextInt,
+                                          PVRSRV_HANDLE_TYPE_SGX_HW_2D_CONTEXT,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psSGXRegHW2DContextOUT->eError, psPerProc);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXUnregisterHW2DContextBW(IMG_UINT32 ui32BridgeID,
+                                                           PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_2D_CONTEXT *psSGXUnregHW2DContextIN,
+                                                           PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hHW2DContextInt;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_UNREGISTER_HW_2D_CONTEXT);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hHW2DContextInt,
+                                                   psSGXUnregHW2DContextIN->hHW2DContext,
+                                                   PVRSRV_HANDLE_TYPE_SGX_HW_2D_CONTEXT);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError = SGXUnregisterHW2DContextKM(hHW2DContextInt);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                        psSGXUnregHW2DContextIN->hHW2DContext,
+                                                        PVRSRV_HANDLE_TYPE_SGX_HW_2D_CONTEXT);
+
+        return 0;
+}
+#endif 
+
+static IMG_INT
+SGXFlushHWRenderTargetBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_SGX_FLUSH_HW_RENDER_TARGET *psSGXFlushHWRenderTargetIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_FLUSH_HW_RENDER_TARGET);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXFlushHWRenderTargetIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        SGXFlushHWRenderTargetKM(hDevCookieInt, psSGXFlushHWRenderTargetIN->sHWRTDataSetDevVAddr);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGX2DQueryBlitsCompleteBW(IMG_UINT32 ui32BridgeID,
+                                                  PVRSRV_BRIDGE_IN_2DQUERYBLTSCOMPLETE *ps2DQueryBltsCompleteIN,
+                                                  PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_VOID *pvSyncInfo;
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_2DQUERYBLTSCOMPLETE);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   ps2DQueryBltsCompleteIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
+                                                   ps2DQueryBltsCompleteIN->hKernSyncInfo,
+                                                   PVRSRV_HANDLE_TYPE_SYNC_INFO);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookieInt)->pvDevice;
+
+        psRetOUT->eError =
+                SGX2DQueryBlitsCompleteKM(psDevInfo,
+                                                                  (PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo,
+                                                                  ps2DQueryBltsCompleteIN->bWaitForComplete);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXFindSharedPBDescBW(IMG_UINT32 ui32BridgeID,
+                                          PVRSRV_BRIDGE_IN_SGXFINDSHAREDPBDESC *psSGXFindSharedPBDescIN,
+                                          PVRSRV_BRIDGE_OUT_SGXFINDSHAREDPBDESC *psSGXFindSharedPBDescOUT,
+                                          PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_KERNEL_MEM_INFO *psSharedPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psHWPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psBlockKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psHWBlockKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO **ppsSharedPBDescSubKernelMemInfos = IMG_NULL;
+        IMG_UINT32 ui32SharedPBDescSubKernelMemInfosCount = 0;
+        IMG_UINT32 i;
+        IMG_HANDLE hSharedPBDesc = IMG_NULL;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXFindSharedPBDescOUT->eError, psPerProc, PVRSRV_BRIDGE_SGX_SHAREDPBDESC_MAX_SUBMEMINFOS + 4);
+
+        psSGXFindSharedPBDescOUT->hSharedPBDesc = IMG_NULL;
+
+        psSGXFindSharedPBDescOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hDevCookieInt,
+                                                   psSGXFindSharedPBDescIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psSGXFindSharedPBDescOUT->eError != PVRSRV_OK)
+                goto PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC_EXIT;
+
+        psSGXFindSharedPBDescOUT->eError =
+                SGXFindSharedPBDescKM(psPerProc, hDevCookieInt,
+                                                          psSGXFindSharedPBDescIN->bLockOnFailure,
+                                                          psSGXFindSharedPBDescIN->ui32TotalPBSize,
+                                                          &hSharedPBDesc,
+                                                          &psSharedPBDescKernelMemInfo,
+                                                          &psHWPBDescKernelMemInfo,
+                                                          &psBlockKernelMemInfo,
+                                                          &psHWBlockKernelMemInfo,
+                                                          &ppsSharedPBDescSubKernelMemInfos,
+                                                          &ui32SharedPBDescSubKernelMemInfosCount);
+        if(psSGXFindSharedPBDescOUT->eError != PVRSRV_OK)
+                goto PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC_EXIT;
+
+        PVR_ASSERT(ui32SharedPBDescSubKernelMemInfosCount
+                           <= PVRSRV_BRIDGE_SGX_SHAREDPBDESC_MAX_SUBMEMINFOS);
+
+        psSGXFindSharedPBDescOUT->ui32SharedPBDescSubKernelMemInfoHandlesCount =
+                ui32SharedPBDescSubKernelMemInfosCount;
+
+        if(hSharedPBDesc == IMG_NULL)
+        {
+                psSGXFindSharedPBDescOUT->hSharedPBDescKernelMemInfoHandle = 0;
+                
+                goto PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC_EXIT;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                          &psSGXFindSharedPBDescOUT->hSharedPBDesc,
+                                          hSharedPBDesc,
+                                          PVRSRV_HANDLE_TYPE_SHARED_PB_DESC,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+        
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                          &psSGXFindSharedPBDescOUT->hSharedPBDescKernelMemInfoHandle,
+                                          psSharedPBDescKernelMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                          psSGXFindSharedPBDescOUT->hSharedPBDesc);
+
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                          &psSGXFindSharedPBDescOUT->hHWPBDescKernelMemInfoHandle,
+                                          psHWPBDescKernelMemInfo,
+                                          PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                          psSGXFindSharedPBDescOUT->hSharedPBDesc);
+
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                  &psSGXFindSharedPBDescOUT->hBlockKernelMemInfoHandle,
+                                  psBlockKernelMemInfo,
+                                  PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                  PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                  psSGXFindSharedPBDescOUT->hSharedPBDesc);
+
+        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                  &psSGXFindSharedPBDescOUT->hHWBlockKernelMemInfoHandle,
+                                  psHWBlockKernelMemInfo,
+                                  PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                  PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                  psSGXFindSharedPBDescOUT->hSharedPBDesc);
+
+
+        for(i=0; i<ui32SharedPBDescSubKernelMemInfosCount; i++)
+        {
+                PVRSRV_BRIDGE_OUT_SGXFINDSHAREDPBDESC *psSGXFindSharedPBDescOut =
+                        psSGXFindSharedPBDescOUT;
+
+                        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
+                                                          &psSGXFindSharedPBDescOut->ahSharedPBDescSubKernelMemInfoHandles[i],
+                                                          ppsSharedPBDescSubKernelMemInfos[i],
+                                                          PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
+                                                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
+                                                          psSGXFindSharedPBDescOUT->hSharedPBDescKernelMemInfoHandle);
+        }
+
+PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC_EXIT:
+        if (ppsSharedPBDescSubKernelMemInfos != IMG_NULL)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_KERNEL_MEM_INFO *) * ui32SharedPBDescSubKernelMemInfosCount,
+                                  ppsSharedPBDescSubKernelMemInfos,
+                                  IMG_NULL);
+        }
+
+        if(psSGXFindSharedPBDescOUT->eError != PVRSRV_OK)
+        {
+                if(hSharedPBDesc != IMG_NULL)
+                {
+                        SGXUnrefSharedPBDescKM(hSharedPBDesc);
+                }
+        }
+        else
+        {
+                COMMIT_HANDLE_BATCH_OR_ERROR(psSGXFindSharedPBDescOUT->eError, psPerProc);
+        }
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXUnrefSharedPBDescBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_SGXUNREFSHAREDPBDESC *psSGXUnrefSharedPBDescIN,
+                                           PVRSRV_BRIDGE_OUT_SGXUNREFSHAREDPBDESC *psSGXUnrefSharedPBDescOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hSharedPBDesc;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_UNREFSHAREDPBDESC);
+
+        psSGXUnrefSharedPBDescOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                   &hSharedPBDesc,
+                                                   psSGXUnrefSharedPBDescIN->hSharedPBDesc,
+                                                   PVRSRV_HANDLE_TYPE_SHARED_PB_DESC);
+        if(psSGXUnrefSharedPBDescOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psSGXUnrefSharedPBDescOUT->eError =
+                SGXUnrefSharedPBDescKM(hSharedPBDesc);
+
+        if(psSGXUnrefSharedPBDescOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psSGXUnrefSharedPBDescOUT->eError =
+                PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                   psSGXUnrefSharedPBDescIN->hSharedPBDesc,
+                                                   PVRSRV_HANDLE_TYPE_SHARED_PB_DESC);
+
+        return 0;
+}
+
+
+static IMG_INT
+SGXAddSharedPBDescBW(IMG_UINT32 ui32BridgeID,
+                                         PVRSRV_BRIDGE_IN_SGXADDSHAREDPBDESC *psSGXAddSharedPBDescIN,
+                                         PVRSRV_BRIDGE_OUT_SGXADDSHAREDPBDESC *psSGXAddSharedPBDescOUT,
+                                         PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        PVRSRV_KERNEL_MEM_INFO *psSharedPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psHWPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psBlockKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO *psHWBlockKernelMemInfo;
+        IMG_UINT32 ui32KernelMemInfoHandlesCount =
+                psSGXAddSharedPBDescIN->ui32KernelMemInfoHandlesCount;
+        IMG_INT ret = 0;
+        IMG_HANDLE *phKernelMemInfoHandles = IMG_NULL;
+        PVRSRV_KERNEL_MEM_INFO **ppsKernelMemInfos = IMG_NULL;
+        IMG_UINT32 i;
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hSharedPBDesc = IMG_NULL;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXAddSharedPBDescOUT->eError, psPerProc, 1);
+
+        psSGXAddSharedPBDescOUT->hSharedPBDesc = IMG_NULL;
+
+        PVR_ASSERT(ui32KernelMemInfoHandlesCount
+                           <= PVRSRV_BRIDGE_SGX_SHAREDPBDESC_MAX_SUBMEMINFOS);
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                &hDevCookieInt,
+                                                                psSGXAddSharedPBDescIN->hDevCookie,
+                                                                PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                (IMG_VOID **)&psSharedPBDescKernelMemInfo,
+                                                                psSGXAddSharedPBDescIN->hSharedPBDescKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+        if(eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                (IMG_VOID **)&psHWPBDescKernelMemInfo,
+                                                                psSGXAddSharedPBDescIN->hHWPBDescKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                (IMG_VOID **)&psBlockKernelMemInfo,
+                                                                psSGXAddSharedPBDescIN->hBlockKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+        if(eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                (IMG_VOID **)&psHWBlockKernelMemInfo,
+                                                                psSGXAddSharedPBDescIN->hHWBlockKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
+        if(eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+
+        if(!OSAccessOK(PVR_VERIFY_READ,
+                                   psSGXAddSharedPBDescIN->phKernelMemInfoHandles,
+                                   ui32KernelMemInfoHandlesCount * sizeof(IMG_HANDLE)))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "%s: PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC:"
+                                 " Invalid phKernelMemInfos pointer", __FUNCTION__));
+                ret = -EFAULT;
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32KernelMemInfoHandlesCount * sizeof(IMG_HANDLE),
+                                  (IMG_VOID **)&phKernelMemInfoHandles,
+                                  0,
+                                  "Array of Handles");
+        if (eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        if(CopyFromUserWrapper(psPerProc,
+                                       ui32BridgeID,
+                                       phKernelMemInfoHandles,
+                                                   psSGXAddSharedPBDescIN->phKernelMemInfoHandles,
+                                                   ui32KernelMemInfoHandlesCount * sizeof(IMG_HANDLE))
+           != PVRSRV_OK)
+        {
+                ret = -EFAULT;
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32KernelMemInfoHandlesCount * sizeof(PVRSRV_KERNEL_MEM_INFO *),
+                                  (IMG_VOID **)&ppsKernelMemInfos,
+                                  0,
+                                  "Array of pointers to Kernel Memory Info");
+        if (eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        for(i=0; i<ui32KernelMemInfoHandlesCount; i++)
+        {
+                eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                        (IMG_VOID **)&ppsKernelMemInfos[i],
+                                                                        phKernelMemInfoHandles[i],
+                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+                if(eError != PVRSRV_OK)
+                {
+                        goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+                }
+        }
+
+        
+         
+        eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                psSGXAddSharedPBDescIN->hSharedPBDescKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+        PVR_ASSERT(eError == PVRSRV_OK);
+
+         
+        eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                psSGXAddSharedPBDescIN->hHWPBDescKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
+        PVR_ASSERT(eError == PVRSRV_OK);
+
+         
+        eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                psSGXAddSharedPBDescIN->hBlockKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
+        PVR_ASSERT(eError == PVRSRV_OK);
+
+         
+        eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                psSGXAddSharedPBDescIN->hHWBlockKernelMemInfo,
+                                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
+        PVR_ASSERT(eError == PVRSRV_OK);
+
+        for(i=0; i<ui32KernelMemInfoHandlesCount; i++)
+        {
+                 
+                eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
+                                                                        phKernelMemInfoHandles[i],
+                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+                PVR_ASSERT(eError == PVRSRV_OK);
+        }
+
+        eError = SGXAddSharedPBDescKM(psPerProc, hDevCookieInt,
+                                                                  psSharedPBDescKernelMemInfo,
+                                                                  psHWPBDescKernelMemInfo,
+                                                                  psBlockKernelMemInfo,
+                                                                  psHWBlockKernelMemInfo,
+                                                                  psSGXAddSharedPBDescIN->ui32TotalPBSize,
+                                                                  &hSharedPBDesc,
+                                                                  ppsKernelMemInfos,
+                                                                  ui32KernelMemInfoHandlesCount);
+
+
+        if (eError != PVRSRV_OK)
+        {
+                goto PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT;
+        }
+
+        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                  &psSGXAddSharedPBDescOUT->hSharedPBDesc,
+                                  hSharedPBDesc,
+                                  PVRSRV_HANDLE_TYPE_SHARED_PB_DESC,
+                                  PVRSRV_HANDLE_ALLOC_FLAG_NONE);
+
+PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC_RETURN_RESULT:
+
+        if(phKernelMemInfoHandles)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  psSGXAddSharedPBDescIN->ui32KernelMemInfoHandlesCount * sizeof(IMG_HANDLE),
+                                  (IMG_VOID *)phKernelMemInfoHandles,
+                                  0);
+        }
+        if(ppsKernelMemInfos)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  psSGXAddSharedPBDescIN->ui32KernelMemInfoHandlesCount * sizeof(PVRSRV_KERNEL_MEM_INFO *),
+                                  (IMG_VOID *)ppsKernelMemInfos,
+                                  0);
+        }
+
+        if(ret == 0 && eError == PVRSRV_OK)
+        {
+                COMMIT_HANDLE_BATCH_OR_ERROR(psSGXAddSharedPBDescOUT->eError, psPerProc);
+        }
+
+        psSGXAddSharedPBDescOUT->eError = eError;
+
+        return ret;
+}
+
+static IMG_INT
+SGXGetInfoForSrvinitBW(IMG_UINT32 ui32BridgeID,
+                                           PVRSRV_BRIDGE_IN_SGXINFO_FOR_SRVINIT *psSGXInfoForSrvinitIN,
+                                           PVRSRV_BRIDGE_OUT_SGXINFO_FOR_SRVINIT *psSGXInfoForSrvinitOUT,
+                                           PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_HANDLE hDevCookieInt;
+        IMG_UINT32 i;
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGXINFO_FOR_SRVINIT);
+
+        NEW_HANDLE_BATCH_OR_ERROR(psSGXInfoForSrvinitOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS);
+
+        if(!psPerProc->bInitProcess)
+        {
+                psSGXInfoForSrvinitOUT->eError = PVRSRV_ERROR_PROCESS_NOT_INITIALISED;
+                return 0;
+        }
+
+        psSGXInfoForSrvinitOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
+                                                   psSGXInfoForSrvinitIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+
+        if(psSGXInfoForSrvinitOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psSGXInfoForSrvinitOUT->eError =
+                SGXGetInfoForSrvinitKM(hDevCookieInt,
+                                                           &psSGXInfoForSrvinitOUT->sInitInfo);
+
+        if(psSGXInfoForSrvinitOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        for(i = 0; i < PVRSRV_MAX_CLIENT_HEAPS; i++)
+        {
+                PVRSRV_HEAP_INFO *psHeapInfo;
+
+                psHeapInfo = &psSGXInfoForSrvinitOUT->sInitInfo.asHeapInfo[i];
+
+                if (psHeapInfo->ui32HeapID != (IMG_UINT32)SGX_UNDEFINED_HEAP_ID)
+                {
+                        IMG_HANDLE hDevMemHeapExt;
+
+                        if (psHeapInfo->hDevMemHeap != IMG_NULL)
+                        {
+                                
+                                PVRSRVAllocHandleNR(psPerProc->psHandleBase,
+                                                                  &hDevMemHeapExt,
+                                                                  psHeapInfo->hDevMemHeap,
+                                                                  PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
+                                                                  PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
+                                psHeapInfo->hDevMemHeap = hDevMemHeapExt;
+                        }
+                }
+        }
+
+        COMMIT_HANDLE_BATCH_OR_ERROR(psSGXInfoForSrvinitOUT->eError, psPerProc);
+
+        return 0;
+}
+
+#if defined(PDUMP)
+static IMG_VOID
+DumpBufferArray(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                PSGX_KICKTA_DUMP_BUFFER psBufferArray,
+                                IMG_UINT32                                              ui32BufferArrayLength,
+                                IMG_BOOL                                                bDumpPolls)
+{
+        IMG_UINT32      i;
+
+        for (i=0; i<ui32BufferArrayLength; i++)
+        {
+                PSGX_KICKTA_DUMP_BUFFER psBuffer;
+                PVRSRV_KERNEL_MEM_INFO  *psCtrlMemInfoKM;
+                IMG_CHAR * pszName;
+                IMG_HANDLE hUniqueTag;
+                IMG_UINT32      ui32Offset;
+
+                psBuffer = &psBufferArray[i];
+                pszName = psBuffer->pszName;
+                if (!pszName)
+                {
+                        pszName = "Nameless buffer";
+                }
+
+                hUniqueTag = MAKEUNIQUETAG((PVRSRV_KERNEL_MEM_INFO *)psBuffer->hKernelMemInfo);
+
+        #if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                psCtrlMemInfoKM = ((PVRSRV_KERNEL_MEM_INFO *)psBuffer->hCtrlKernelMemInfo);
+                ui32Offset =  psBuffer->sCtrlDevVAddr.uiAddr - psCtrlMemInfoKM->sDevVAddr.uiAddr;
+        #else
+                psCtrlMemInfoKM = ((PVRSRV_KERNEL_MEM_INFO *)psBuffer->hKernelMemInfo)->psKernelSyncInfo->psSyncDataMemInfoKM;
+                ui32Offset = offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete);
+        #endif
+
+                if (psBuffer->ui32Start <= psBuffer->ui32End)
+                {
+                        if (bDumpPolls)
+                        {
+                                PDUMPCOMMENTWITHFLAGS(0, "Wait for %s space\r\n", pszName);
+                                PDUMPCBP(psCtrlMemInfoKM,
+                                                 ui32Offset,
+                                                 psBuffer->ui32Start,
+                                                 psBuffer->ui32SpaceUsed,
+                                                 psBuffer->ui32BufferSize,
+                                                 0,
+                                                 MAKEUNIQUETAG(psCtrlMemInfoKM));
+                        }
+
+                        PDUMPCOMMENTWITHFLAGS(0, "%s\r\n", pszName);
+                        PDUMPMEMUM(psPerProc,
+                                         IMG_NULL,
+                                         psBuffer->pvLinAddr,
+                                         (PVRSRV_KERNEL_MEM_INFO*)psBuffer->hKernelMemInfo,
+                                         psBuffer->ui32Start,
+                                         psBuffer->ui32End - psBuffer->ui32Start,
+                                         0,
+                                         hUniqueTag);
+                }
+                else
+                {
+                        
+
+                        if (bDumpPolls)
+                        {
+                                PDUMPCOMMENTWITHFLAGS(0, "Wait for %s space\r\n", pszName);
+                                PDUMPCBP(psCtrlMemInfoKM,
+                                                 ui32Offset,
+                                                 psBuffer->ui32Start,
+                                                 psBuffer->ui32BackEndLength,
+                                                 psBuffer->ui32BufferSize,
+                                                 0,
+                                                 MAKEUNIQUETAG(psCtrlMemInfoKM));
+                        }
+                        PDUMPCOMMENTWITHFLAGS(0, "%s (part 1)\r\n", pszName);
+                        PDUMPMEMUM(psPerProc,
+                                         IMG_NULL,
+                                         psBuffer->pvLinAddr,
+                                         (PVRSRV_KERNEL_MEM_INFO*)psBuffer->hKernelMemInfo,
+                                         psBuffer->ui32Start,
+                                         psBuffer->ui32BackEndLength,
+                                         0,
+                                         hUniqueTag);
+
+                        if (bDumpPolls)
+                        {
+                                PDUMPMEMPOL(psCtrlMemInfoKM,
+                                                        ui32Offset,
+                                                        0,
+                                                        0xFFFFFFFF,
+                                                        PDUMP_POLL_OPERATOR_NOTEQUAL,
+                                                        0,
+                                                        MAKEUNIQUETAG(psCtrlMemInfoKM));
+
+                                PDUMPCOMMENTWITHFLAGS(0, "Wait for %s space\r\n", pszName);
+                                PDUMPCBP(psCtrlMemInfoKM,
+                                                 ui32Offset,
+                                                 0,
+                                                 psBuffer->ui32End,
+                                                 psBuffer->ui32BufferSize,
+                                                 0,
+                                                 MAKEUNIQUETAG(psCtrlMemInfoKM));
+                        }
+                        PDUMPCOMMENTWITHFLAGS(0, "%s (part 2)\r\n", pszName);
+                        PDUMPMEMUM(psPerProc,
+                                         IMG_NULL,
+                                         psBuffer->pvLinAddr,
+                                         (PVRSRV_KERNEL_MEM_INFO*)psBuffer->hKernelMemInfo,
+                                         0,
+                                         psBuffer->ui32End,
+                                         0,
+                                         hUniqueTag);
+                }
+        }
+}
+static IMG_INT
+SGXPDumpBufferArrayBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_PDUMP_BUFFER_ARRAY *psPDumpBufferArrayIN,
+                                   IMG_VOID *psBridgeOut,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 i;
+        SGX_KICKTA_DUMP_BUFFER *psKickTADumpBuffer;
+        IMG_UINT32 ui32BufferArrayLength =
+                psPDumpBufferArrayIN->ui32BufferArrayLength;
+        IMG_UINT32 ui32BufferArraySize =
+                ui32BufferArrayLength * sizeof(SGX_KICKTA_DUMP_BUFFER);
+        PVRSRV_ERROR eError = PVRSRV_ERROR_TOO_FEW_BUFFERS;
+
+        PVR_UNREFERENCED_PARAMETER(psBridgeOut);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY);
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32BufferArraySize,
+                                  (IMG_PVOID *)&psKickTADumpBuffer, 0,
+                                  "Array of Kick Tile Accelerator Dump Buffer") != PVRSRV_OK)
+        {
+                return -ENOMEM;
+        }
+
+        if(CopyFromUserWrapper(psPerProc,
+                                       ui32BridgeID,
+                                                   psKickTADumpBuffer,
+                                                   psPDumpBufferArrayIN->psBufferArray,
+                                                   ui32BufferArraySize) != PVRSRV_OK)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32BufferArraySize, psKickTADumpBuffer, 0);
+                
+                return -EFAULT;
+        }
+
+        for(i = 0; i < ui32BufferArrayLength; i++)
+        {
+                IMG_VOID *pvMemInfo;
+
+                eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                        &pvMemInfo,
+                                                                        psKickTADumpBuffer[i].hKernelMemInfo,
+                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY: "
+                                         "PVRSRVLookupHandle failed (%d)", eError));
+                        break;
+                }
+                psKickTADumpBuffer[i].hKernelMemInfo = pvMemInfo;
+
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
+                                                                        &pvMemInfo,
+                                                                        psKickTADumpBuffer[i].hCtrlKernelMemInfo,
+                                                                        PVRSRV_HANDLE_TYPE_MEM_INFO);
+
+                if(eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY: "
+                                         "PVRSRVLookupHandle failed (%d)", eError));
+                        break;
+                }
+                psKickTADumpBuffer[i].hCtrlKernelMemInfo = pvMemInfo;
+#endif
+        }
+
+        if(eError == PVRSRV_OK)
+        {
+                DumpBufferArray(psPerProc,
+                                                psKickTADumpBuffer,
+                                                ui32BufferArrayLength,
+                                                psPDumpBufferArrayIN->bDumpPolls);
+        }
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32BufferArraySize, psKickTADumpBuffer, 0);
+        
+
+        return 0;
+}
+
+static IMG_INT
+SGXPDump3DSignatureRegistersBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_PDUMP_3D_SIGNATURE_REGISTERS *psPDump3DSignatureRegistersIN,
+                                   PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 ui32RegisterArraySize =  psPDump3DSignatureRegistersIN->ui32NumRegisters * sizeof(IMG_UINT32);
+        IMG_UINT32 *pui32Registers = IMG_NULL;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = IMG_NULL;
+#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);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_3D_SIGNATURE_REGISTERS);
+
+        if (ui32RegisterArraySize == 0)
+        {
+                goto ExitNoError;
+        }
+
+        psRetOUT->eError =
+                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_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(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
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32RegisterArraySize,
+                                  (IMG_PVOID *)&pui32Registers, 0,
+                                  "Array of Registers") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDump3DSignatureRegistersBW: OSAllocMem failed"));
+                goto Exit;
+        }
+
+        if(CopyFromUserWrapper(psPerProc,
+                                        ui32BridgeID,
+                                        pui32Registers,
+                                        psPDump3DSignatureRegistersIN->pui32Registers,
+                                        ui32RegisterArraySize) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDump3DSignatureRegistersBW: CopyFromUserWrapper failed"));
+                goto Exit;
+        }
+
+        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;
+Exit:
+        if (pui32Registers != IMG_NULL)
+        {
+                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(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, ui32RegVal,
+                                                        psPDump3DSignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
+#endif
+        }
+#endif
+
+        return ret;
+}
+
+static IMG_INT
+SGXPDumpCounterRegistersBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_PDUMP_COUNTER_REGISTERS *psPDumpCounterRegistersIN,
+                                   IMG_VOID *psBridgeOut,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        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);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_COUNTER_REGISTERS);
+
+        if (ui32RegisterArraySize == 0)
+        {
+                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,
+                                  "Array of Registers") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpCounterRegistersBW: OSAllocMem failed"));
+                ret = -ENOMEM;
+                goto Exit;
+        }
+
+        if(CopyFromUserWrapper(psPerProc,
+                                        ui32BridgeID,
+                                        pui32Registers,
+                                        psPDumpCounterRegistersIN->pui32Registers,
+                                        ui32RegisterArraySize) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpCounterRegistersBW: CopyFromUserWrapper failed"));
+                goto Exit;
+        }
+
+        PDumpCounterRegisters(&psDeviceNode->sDevId,
+                                        psPDumpCounterRegistersIN->ui32DumpFrameNum,
+                                        psPDumpCounterRegistersIN->bLastFrame,
+                                        pui32Registers,
+                                        psPDumpCounterRegistersIN->ui32NumRegisters);
+
+ExitNoError:
+        ret = 0;
+Exit:
+        if (pui32Registers != IMG_NULL)
+        {
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32RegisterArraySize, pui32Registers, 0);
+        }
+
+        return ret;
+}
+
+static IMG_INT
+SGXPDumpTASignatureRegistersBW(IMG_UINT32 ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_PDUMP_TA_SIGNATURE_REGISTERS *psPDumpTASignatureRegistersIN,
+                                   PVRSRV_BRIDGE_RETURN *psRetOUT,
+                                   PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        IMG_UINT32 ui32RegisterArraySize =  psPDumpTASignatureRegistersIN->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_UINT32      ui32RegVal = 0;
+#endif
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_INT ret = -EFAULT;
+
+        PVR_UNREFERENCED_PARAMETER(psRetOUT);
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_TA_SIGNATURE_REGISTERS);
+
+        if (ui32RegisterArraySize == 0)
+        {
+                goto ExitNoError;
+        }
+
+        psRetOUT->eError =
+                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;
+        }
+
+#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(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
+
+        if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  ui32RegisterArraySize,
+                                  (IMG_PVOID *)&pui32Registers, 0,
+                                  "Array of Registers") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpTASignatureRegistersBW: OSAllocMem failed"));
+                ret = -ENOMEM;
+                goto Exit;
+        }
+
+        if(CopyFromUserWrapper(psPerProc,
+                                        ui32BridgeID,
+                                        pui32Registers,
+                                        psPDumpTASignatureRegistersIN->pui32Registers,
+                                        ui32RegisterArraySize) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "PDumpTASignatureRegistersBW: CopyFromUserWrapper failed"));
+                goto Exit;
+        }
+
+        PDumpTASignatureRegisters(&psDeviceNode->sDevId,
+                                        psPDumpTASignatureRegistersIN->ui32DumpFrameNum,
+                                        psPDumpTASignatureRegistersIN->ui32TAKickCount,
+                                        psPDumpTASignatureRegistersIN->bLastFrame,
+                                        pui32Registers,
+                                        psPDumpTASignatureRegistersIN->ui32NumRegisters);
+
+ExitNoError:
+        psRetOUT->eError = PVRSRV_OK;
+        ret = 0;
+Exit:
+        if (pui32Registers != IMG_NULL)
+        {
+                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(SGX_PDUMPREG_NAME, EUR_CR_MASTER_CORE, ui32RegVal,
+                                                        psPDumpTASignatureRegistersIN->bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);
+#endif
+        }
+#endif
+
+        return ret;
+}
+static IMG_INT
+SGXPDumpHWPerfCBBW(IMG_UINT32                                           ui32BridgeID,
+                                   PVRSRV_BRIDGE_IN_PDUMP_HWPERFCB      *psPDumpHWPerfCBIN,
+                                   PVRSRV_BRIDGE_RETURN                         *psRetOUT,
+                                   PVRSRV_PER_PROCESS_DATA                      *psPerProc)
+{
+#if defined(SUPPORT_SGX_HWPERF)
+#if defined(__linux__)
+        PVRSRV_SGXDEV_INFO      *psDevInfo;
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SGX_PDUMP_HWPERFCB);
+
+        psRetOUT->eError =
+                PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID**)&psDeviceNode,
+                                                   psPDumpHWPerfCBIN->hDevCookie,
+                                                   PVRSRV_HANDLE_TYPE_DEV_NODE);
+        if(psRetOUT->eError != PVRSRV_OK)
+        {
+                return 0;
+        }
+
+        psDevInfo = psDeviceNode->pvDevice;
+
+        PDumpHWPerfCBKM(&psDeviceNode->sDevId,
+                                        &psPDumpHWPerfCBIN->szFileName[0],
+                                        psPDumpHWPerfCBIN->ui32FileOffset,
+                                        psDevInfo->psKernelHWPerfCBMemInfo->sDevVAddr,
+                                        psDevInfo->psKernelHWPerfCBMemInfo->ui32AllocSize,
+                                        psPDumpHWPerfCBIN->ui32PDumpFlags);
+
+        return 0;
+#else
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+        PVR_UNREFERENCED_PARAMETER(psPDumpHWPerfCBIN);
+        PVR_UNREFERENCED_PARAMETER(psRetOUT);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        return 0;
+#endif 
+#else
+        PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
+        PVR_UNREFERENCED_PARAMETER(psPDumpHWPerfCBIN);
+        PVR_UNREFERENCED_PARAMETER(psRetOUT);
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        return -EFAULT;
+#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_GETCLIENTINFO, SGXGetClientInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_RELEASECLIENTINFO, SGXReleaseClientInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_GETINTERNALDEVINFO, SGXGetInternalDevInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_DOKICK, SGXDoKickBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_GETPHYSPAGEADDR, DummyBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_READREGISTRYDWORD, DummyBW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_2DQUERYBLTSCOMPLETE, SGX2DQueryBlitsCompleteBW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_GETMMUPDADDR, DummyBW);
+
+#if defined(TRANSFER_QUEUE)
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_SUBMITTRANSFER, SGXSubmitTransferBW);
+#endif
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_GETMISCINFO, SGXGetMiscInfoBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGXINFO_FOR_SRVINIT , SGXGetInfoForSrvinitBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_DEVINITPART2, SGXDevInitPart2BW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC, SGXFindSharedPBDescBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_UNREFSHAREDPBDESC, SGXUnrefSharedPBDescBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC, SGXAddSharedPBDescBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT, SGXRegisterHWRenderContextBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_FLUSH_HW_RENDER_TARGET, SGXFlushHWRenderTargetBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_UNREGISTER_HW_RENDER_CONTEXT, SGXUnregisterHWRenderContextBW);
+#if defined(SGX_FEATURE_2D_HARDWARE)
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_SUBMIT2D, SGXSubmit2DBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_REGISTER_HW_2D_CONTEXT, SGXRegisterHW2DContextBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_UNREGISTER_HW_2D_CONTEXT, SGXUnregisterHW2DContextBW);
+#endif
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_REGISTER_HW_TRANSFER_CONTEXT, SGXRegisterHWTransferContextBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_UNREGISTER_HW_TRANSFER_CONTEXT, SGXUnregisterHWTransferContextBW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES, SGXScheduleProcessQueuesBW);
+
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_READ_HWPERF_CB, SGXReadHWPerfCBBW);
+
+#if defined(PDUMP)
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY, SGXPDumpBufferArrayBW);
+        SetDispatchTableEntry(PVRSRV_BRIDGE_SGX_PDUMP_3D_SIGNATURE_REGISTERS, SGXPDump3DSignatureRegistersBW);
+        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 
diff --git a/drivers/gpu/pvr/sgx/bridged_sgx_bridge.h b/drivers/gpu/pvr/sgx/bridged_sgx_bridge.h
new file mode 100644
index 00000000000..de6cfd1bc1e
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/bridged_sgx_bridge.h
@@ -0,0 +1,42 @@
+/**********************************************************************
+ *
+ * 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 __BRIDGED_SGX_BRIDGE_H__
+#define __BRIDGED_SGX_BRIDGE_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+IMG_VOID SetSGXDispatchTableEntry(IMG_VOID);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx/mmu.c b/drivers/gpu/pvr/sgx/mmu.c
new file mode 100644
index 00000000000..8cf6682c247
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/mmu.c
@@ -0,0 +1,2940 @@
+/**********************************************************************
+ *
+ * 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 "sgxdefs.h"
+#include "sgxmmu.h"
+#include "services_headers.h"
+#include "buffer_manager.h"
+#include "hash.h"
+#include "ra.h"
+#include "pdump_km.h"
+#include "sgxapi_km.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#include "mmu.h"
+#include "sgxconfig.h"
+#include "sgx_bridge_km.h"
+
+#define UINT32_MAX_VALUE        0xFFFFFFFFUL
+
+#define SGX_MAX_PD_ENTRIES      (1<<(SGX_FEATURE_ADDRESS_SPACE_SIZE - SGX_MMU_PT_SHIFT - SGX_MMU_PAGE_SHIFT))
+
+typedef struct _MMU_PT_INFO_
+{
+        
+        IMG_VOID *hPTPageOSMemHandle;
+        IMG_CPU_VIRTADDR PTPageCpuVAddr;
+        IMG_UINT32 ui32ValidPTECount;
+} MMU_PT_INFO;
+
+struct _MMU_CONTEXT_
+{
+        
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        
+        IMG_CPU_VIRTADDR pvPDCpuVAddr;
+        IMG_DEV_PHYADDR sPDDevPAddr;
+
+        IMG_VOID *hPDOSMemHandle;
+
+        
+        MMU_PT_INFO *apsPTInfoList[SGX_MAX_PD_ENTRIES];
+
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+
+#if defined(PDUMP)
+        IMG_UINT32 ui32PDumpMMUContextID;
+#endif
+
+        struct _MMU_CONTEXT_ *psNext;
+};
+
+struct _MMU_HEAP_
+{
+        
+        MMU_CONTEXT                     *psMMUContext;
+
+        
+
+        
+        IMG_UINT32                      ui32PDBaseIndex;
+        
+        IMG_UINT32                      ui32PageTableCount;
+        
+        IMG_UINT32                      ui32PTETotal;
+        
+        IMG_UINT32                      ui32PDEPageSizeCtrl;
+
+        
+
+        
+        IMG_UINT32                      ui32DataPageSize;
+        
+        IMG_UINT32                      ui32DataPageBitWidth;
+        
+        IMG_UINT32                      ui32DataPageMask;
+
+        
+
+        
+        IMG_UINT32                      ui32PTShift;
+        
+        IMG_UINT32                      ui32PTBitWidth;
+        
+        IMG_UINT32                      ui32PTMask;
+        
+        IMG_UINT32                      ui32PTSize;
+        
+        IMG_UINT32                      ui32PTECount;
+
+        
+
+        
+        IMG_UINT32                      ui32PDShift;
+        
+        IMG_UINT32                      ui32PDBitWidth;
+        
+        IMG_UINT32                      ui32PDMask;
+
+        
+
+        RA_ARENA *psVMArena;
+        DEV_ARENA_DESCRIPTOR *psDevArena;
+#if defined(PDUMP)
+        PDUMP_MMU_ATTRIB sMMUAttrib;
+#endif
+};
+
+
+
+#if defined (SUPPORT_SGX_MMU_DUMMY_PAGE)
+#define DUMMY_DATA_PAGE_SIGNATURE       0xDEADBEEF
+#endif
+
+#if defined(PDUMP)
+static IMG_VOID
+MMU_PDumpPageTables     (MMU_HEAP *pMMUHeap,
+                                         IMG_DEV_VIRTADDR DevVAddr,
+                                         IMG_SIZE_T uSize,
+                                         IMG_BOOL bForUnmap,
+                                         IMG_HANDLE hUniqueTag);
+#endif 
+
+#define PAGE_TEST                                       0
+#if PAGE_TEST
+static IMG_VOID PageTest(IMG_VOID* pMem, IMG_DEV_PHYADDR sDevPAddr);
+#endif
+
+#define PT_DEBUG 0
+#if PT_DEBUG
+static IMG_VOID DumpPT(MMU_PT_INFO *psPTInfoList)
+{
+        IMG_UINT32 *p = (IMG_UINT32*)psPTInfoList->PTPageCpuVAddr;
+        IMG_UINT32 i;
+
+        
+        for(i = 0; i < 1024; i += 8)
+        {
+                PVR_DPF((PVR_DBG_WARNING,
+                                 "%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]));
+        }
+}
+
+static IMG_VOID CheckPT(MMU_PT_INFO *psPTInfoList)
+{
+        IMG_UINT32 *p = (IMG_UINT32*) psPTInfoList->PTPageCpuVAddr;
+        IMG_UINT32 i, ui32Count = 0;
+
+        
+        for(i = 0; i < 1024; i++)
+                if(p[i] & SGX_MMU_PTE_VALID)
+                        ui32Count++;
+
+        if(psPTInfoList->ui32ValidPTECount != ui32Count)
+        {
+                PVR_DPF((PVR_DBG_WARNING, "ui32ValidPTECount: %u ui32Count: %u\n",
+                                 psPTInfoList->ui32ValidPTECount, ui32Count));
+                DumpPT(psPTInfoList);
+                BUG();
+        }
+}
+#else 
+static INLINE IMG_VOID DumpPT(MMU_PT_INFO *psPTInfoList)
+{
+        PVR_UNREFERENCED_PARAMETER(psPTInfoList);
+}
+
+static INLINE IMG_VOID CheckPT(MMU_PT_INFO *psPTInfoList)
+{
+        PVR_UNREFERENCED_PARAMETER(psPTInfoList);
+}
+#endif 
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+IMG_VOID
+EnableHostAccess (MMU_CONTEXT *psMMUContext)
+{
+        IMG_UINT32 ui32RegVal;
+        IMG_VOID *pvRegsBaseKM = psMMUContext->psDevInfo->pvRegsBaseKM;
+
+        
+
+
+        ui32RegVal = OSReadHWReg(pvRegsBaseKM, EUR_CR_BIF_CTRL);
+
+        OSWriteHWReg(pvRegsBaseKM,
+                                EUR_CR_BIF_CTRL,
+                                ui32RegVal | 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
+DisableHostAccess (MMU_CONTEXT *psMMUContext)
+{
+        IMG_UINT32 ui32RegVal;
+        IMG_VOID *pvRegsBaseKM = psMMUContext->psDevInfo->pvRegsBaseKM;
+
+        
+
+
+
+        OSWriteHWReg(pvRegsBaseKM,
+                                EUR_CR_BIF_CTRL,
+                                ui32RegVal & ~EUR_CR_BIF_CTRL_MMU_BYPASS_HOST_MASK);
+        
+        PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, 0);
+}
+#endif
+
+
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+static IMG_VOID MMU_InvalidateSystemLevelCache(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        #if defined(SGX_FEATURE_MP)
+        psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_SL;
+        #else
+        
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+        #endif 
+}
+#endif 
+
+IMG_VOID MMU_InvalidateDirectoryCache(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_PD;
+        #if defined(SGX_FEATURE_SYSTEM_CACHE)
+        MMU_InvalidateSystemLevelCache(psDevInfo);
+        #endif 
+}
+
+
+static IMG_VOID MMU_InvalidatePageTableCache(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        psDevInfo->ui32CacheControl |= SGXMKIF_CC_INVAL_BIF_PT;
+        #if defined(SGX_FEATURE_SYSTEM_CACHE)
+        MMU_InvalidateSystemLevelCache(psDevInfo);
+        #endif 
+}
+
+
+static IMG_BOOL
+_AllocPageTableMemory (MMU_HEAP *pMMUHeap,
+                                                MMU_PT_INFO *psPTInfoList,
+                                                IMG_DEV_PHYADDR *psDevPAddr)
+{
+        IMG_DEV_PHYADDR sDevPAddr;
+        IMG_CPU_PHYADDR sCpuPAddr;
+
+        
+
+
+        if(pMMUHeap->psDevArena->psDeviceMemoryHeapInfo->psLocalDevMemArena == IMG_NULL)
+        {
+                
+                if (OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                   pMMUHeap->ui32PTSize,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   (IMG_VOID **)&psPTInfoList->PTPageCpuVAddr,
+                                                   &psPTInfoList->hPTPageOSMemHandle) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "_AllocPageTableMemory: ERROR call to OSAllocPages failed"));
+                        return IMG_FALSE;
+                }
+
+                
+                if(psPTInfoList->PTPageCpuVAddr)
+                {
+                        sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->hPTPageOSMemHandle,
+                                                                                  psPTInfoList->PTPageCpuVAddr);
+                }
+                else
+                {
+                        
+                        sCpuPAddr = OSMemHandleToCpuPAddr(psPTInfoList->hPTPageOSMemHandle, 0);
+                }
+
+                sDevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+        }
+        else
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+
+                
+
+
+                
+                if(RA_Alloc(pMMUHeap->psDevArena->psDeviceMemoryHeapInfo->psLocalDevMemArena,
+                                        SGX_MMU_PAGE_SIZE,
+                                        IMG_NULL,
+                                        IMG_NULL,
+                                        0,
+                                        SGX_MMU_PAGE_SIZE,
+                                        0,
+                                        &(sSysPAddr.uiAddr))!= IMG_TRUE)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "_AllocPageTableMemory: ERROR call to RA_Alloc failed"));
+                        return IMG_FALSE;
+                }
+
+                
+                sCpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                
+                psPTInfoList->PTPageCpuVAddr = OSMapPhysToLin(sCpuPAddr,
+                                                                                                        SGX_MMU_PAGE_SIZE,
+                                                                                                        PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                                                        &psPTInfoList->hPTPageOSMemHandle);
+                if(!psPTInfoList->PTPageCpuVAddr)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "_AllocPageTableMemory: ERROR failed to map page tables"));
+                        return IMG_FALSE;
+                }
+
+                
+                sDevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+                #if PAGE_TEST
+                PageTest(psPTInfoList->PTPageCpuVAddr, sDevPAddr);
+                #endif
+        }
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        {
+                IMG_UINT32 *pui32Tmp;
+                IMG_UINT32 i;
+
+                pui32Tmp = (IMG_UINT32*)psPTInfoList->PTPageCpuVAddr;
+                
+                for(i=0; i<pMMUHeap->ui32PTECount; i++)
+                {
+                        pui32Tmp[i] = (pMMUHeap->psMMUContext->psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                | SGX_MMU_PTE_VALID;
+                }
+        }
+#else
+        
+        OSMemSet(psPTInfoList->PTPageCpuVAddr, 0, pMMUHeap->ui32PTSize);
+#endif
+
+        
+        PDUMPMALLOCPAGETABLE(&pMMUHeap->psMMUContext->psDeviceNode->sDevId, psPTInfoList->hPTPageOSMemHandle, 0, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, PDUMP_PT_UNIQUETAG);
+        
+        PDUMPMEMPTENTRIES(&pMMUHeap->sMMUAttrib, psPTInfoList->hPTPageOSMemHandle, psPTInfoList->PTPageCpuVAddr, pMMUHeap->ui32PTSize, 0, IMG_TRUE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+        
+        *psDevPAddr = sDevPAddr;
+
+        return IMG_TRUE;
+}
+
+
+static IMG_VOID
+_FreePageTableMemory (MMU_HEAP *pMMUHeap, MMU_PT_INFO *psPTInfoList)
+{
+        
+
+
+
+        if(pMMUHeap->psDevArena->psDeviceMemoryHeapInfo->psLocalDevMemArena == IMG_NULL)
+        {
+                
+                OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                          pMMUHeap->ui32PTSize,
+                                          psPTInfoList->PTPageCpuVAddr,
+                                          psPTInfoList->hPTPageOSMemHandle);
+        }
+        else
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+                IMG_CPU_PHYADDR sCpuPAddr;
+
+                
+                sCpuPAddr = OSMapLinToCPUPhys(psPTInfoList->hPTPageOSMemHandle, 
+                                                                          psPTInfoList->PTPageCpuVAddr);
+                sSysPAddr = SysCpuPAddrToSysPAddr (sCpuPAddr);
+
+                
+                
+                OSUnMapPhysToLin(psPTInfoList->PTPageCpuVAddr,
+                         SGX_MMU_PAGE_SIZE,
+                         PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                         psPTInfoList->hPTPageOSMemHandle);
+
+                
+
+
+                RA_Free (pMMUHeap->psDevArena->psDeviceMemoryHeapInfo->psLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+        }
+}
+
+
+
+static IMG_VOID
+_DeferredFreePageTable (MMU_HEAP *pMMUHeap, IMG_UINT32 ui32PTIndex, IMG_BOOL bOSFreePT)
+{
+        IMG_UINT32 *pui32PDEntry;
+        IMG_UINT32 i;
+        IMG_UINT32 ui32PDIndex;
+        SYS_DATA *psSysData;
+        MMU_PT_INFO **ppsPTInfoList;
+
+        SysAcquireData(&psSysData);
+
+        
+        ui32PDIndex = pMMUHeap->psDevArena->BaseDevVAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        
+        ppsPTInfoList = &pMMUHeap->psMMUContext->apsPTInfoList[ui32PDIndex];
+
+        {
+#if PT_DEBUG
+                if(ppsPTInfoList[ui32PTIndex] && ppsPTInfoList[ui32PTIndex]->ui32ValidPTECount > 0)
+                {
+                        DumpPT(ppsPTInfoList[ui32PTIndex]);
+                        
+                }
+#endif
+
+                
+                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)
+        {
+                PDUMPFREEPAGETABLE(&pMMUHeap->psMMUContext->psDeviceNode->sDevId, ppsPTInfoList[ui32PTIndex]->hPTPageOSMemHandle, ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr, pMMUHeap->ui32PTSize, PDUMP_PT_UNIQUETAG);
+        }
+
+        switch(pMMUHeap->psDevArena->DevMemHeapType)
+        {
+                case DEVICE_MEMORY_HEAP_SHARED :
+                case DEVICE_MEMORY_HEAP_SHARED_EXPORTED :
+                {
+                        
+                        MMU_CONTEXT *psMMUContext = (MMU_CONTEXT*)pMMUHeap->psMMUContext->psDevInfo->pvMMUContextList;
+
+                        while(psMMUContext)
+                        {
+                                
+                                pui32PDEntry = (IMG_UINT32*)psMMUContext->pvPDCpuVAddr;
+                                pui32PDEntry += ui32PDIndex;
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                                
+                                pui32PDEntry[ui32PTIndex] = (psMMUContext->psDevInfo->sDummyPTDevPAddr.uiAddr
+                                                                                        >>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                                                                        | SGX_MMU_PDE_PAGE_SIZE_4K
+                                                                                        | SGX_MMU_PDE_VALID;
+#else
+                                
+                                if(bOSFreePT)
+                                {
+                                        pui32PDEntry[ui32PTIndex] = 0;
+                                }
+#endif
+
+                                
+                                PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PT_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+                                
+                                psMMUContext = psMMUContext->psNext;
+                        }
+                        break;
+                }
+                case DEVICE_MEMORY_HEAP_PERCONTEXT :
+                case DEVICE_MEMORY_HEAP_KERNEL :
+                {
+                        
+                        pui32PDEntry = (IMG_UINT32*)pMMUHeap->psMMUContext->pvPDCpuVAddr;
+                        pui32PDEntry += ui32PDIndex;
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                        
+                        pui32PDEntry[ui32PTIndex] = (pMMUHeap->psMMUContext->psDevInfo->sDummyPTDevPAddr.uiAddr
+                                                                                >>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                                                                | SGX_MMU_PDE_PAGE_SIZE_4K
+                                                                                | SGX_MMU_PDE_VALID;
+#else
+                        
+                        if(bOSFreePT)
+                        {
+                                pui32PDEntry[ui32PTIndex] = 0;
+                        }
+#endif
+
+                        
+                        PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, pMMUHeap->psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[ui32PTIndex], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+                        break;
+                }
+                default:
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "_DeferredFreePagetable: ERROR invalid heap type"));
+                        return;
+                }
+        }
+
+        
+        if(ppsPTInfoList[ui32PTIndex] != IMG_NULL)
+        {
+                if(ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr != IMG_NULL)
+                {
+                        IMG_PUINT32 pui32Tmp;
+
+                        pui32Tmp = (IMG_UINT32*)ppsPTInfoList[ui32PTIndex]->PTPageCpuVAddr;
+
+                        
+                        for(i=0;
+                                (i<pMMUHeap->ui32PTETotal) && (i<pMMUHeap->ui32PTECount);
+                                 i++)
+                        {
+                                pui32Tmp[i] = 0;
+                        }
+
+                        
+
+                        if(bOSFreePT)
+                        {
+                                _FreePageTableMemory(pMMUHeap, ppsPTInfoList[ui32PTIndex]);
+                        }
+
+                        
+
+
+                        pMMUHeap->ui32PTETotal -= i;
+                }
+                else
+                {
+                        
+                        pMMUHeap->ui32PTETotal -= pMMUHeap->ui32PTECount;
+                }
+
+                if(bOSFreePT)
+                {
+                        
+                        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(MMU_PT_INFO),
+                                                ppsPTInfoList[ui32PTIndex],
+                                                IMG_NULL);
+                        ppsPTInfoList[ui32PTIndex] = IMG_NULL;
+                }
+        }
+        else
+        {
+                
+                pMMUHeap->ui32PTETotal -= pMMUHeap->ui32PTECount;
+        }
+
+        PDUMPCOMMENT("Finished free page table (page count == %08X)", pMMUHeap->ui32PageTableCount);
+}
+
+static IMG_VOID
+_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);
+        }
+        MMU_InvalidateDirectoryCache(pMMUHeap->psMMUContext->psDevInfo);
+}
+
+
+static IMG_BOOL
+_DeferredAllocPagetables(MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR DevVAddr, IMG_UINT32 ui32Size)
+{
+        IMG_UINT32 ui32PageTableCount;
+        IMG_UINT32 ui32PDIndex;
+        IMG_UINT32 i;
+        IMG_UINT32 *pui32PDEntry;
+        MMU_PT_INFO **ppsPTInfoList;
+        SYS_DATA *psSysData;
+        IMG_DEV_VIRTADDR sHighDevVAddr;
+
+        
+#if SGX_FEATURE_ADDRESS_SPACE_SIZE < 32
+        PVR_ASSERT(DevVAddr.uiAddr < (1<<SGX_FEATURE_ADDRESS_SPACE_SIZE));
+#endif
+
+        
+        SysAcquireData(&psSysData);
+
+        
+        ui32PDIndex = DevVAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        
+        
+        if((UINT32_MAX_VALUE - DevVAddr.uiAddr)
+                < (ui32Size + pMMUHeap->ui32DataPageMask + pMMUHeap->ui32PTMask))
+        {
+                
+                sHighDevVAddr.uiAddr = UINT32_MAX_VALUE;
+        }
+        else
+        {
+                sHighDevVAddr.uiAddr = DevVAddr.uiAddr
+                                                                + ui32Size
+                                                                + pMMUHeap->ui32DataPageMask
+                                                                + pMMUHeap->ui32PTMask;
+        }
+
+        ui32PageTableCount = sHighDevVAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        ui32PageTableCount -= ui32PDIndex;
+
+        
+        pui32PDEntry = (IMG_UINT32*)pMMUHeap->psMMUContext->pvPDCpuVAddr;
+        pui32PDEntry += ui32PDIndex;
+
+        
+        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++)
+        {
+                if(ppsPTInfoList[i] == IMG_NULL)
+                {
+                        OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                 sizeof (MMU_PT_INFO),
+                                                 (IMG_VOID **)&ppsPTInfoList[i], IMG_NULL,
+                                                 "MMU Page Table Info");
+                        if (ppsPTInfoList[i] == IMG_NULL)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "_DeferredAllocPagetables: ERROR call to OSAllocMem failed"));
+                                return IMG_FALSE;
+                        }
+                        OSMemSet (ppsPTInfoList[i], 0, sizeof(MMU_PT_INFO));
+                }
+
+                if(ppsPTInfoList[i]->hPTPageOSMemHandle == IMG_NULL
+                && ppsPTInfoList[i]->PTPageCpuVAddr == IMG_NULL)
+                {
+                        IMG_DEV_PHYADDR sDevPAddr;
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                        IMG_UINT32 *pui32Tmp;
+                        IMG_UINT32 j;
+#else
+                        
+                        PVR_ASSERT(pui32PDEntry[i] == 0);
+#endif
+
+                        if(_AllocPageTableMemory (pMMUHeap, ppsPTInfoList[i], &sDevPAddr) != IMG_TRUE)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "_DeferredAllocPagetables: ERROR call to _AllocPageTableMemory failed"));
+                                return IMG_FALSE;
+                        }
+
+                        switch(pMMUHeap->psDevArena->DevMemHeapType)
+                        {
+                                case DEVICE_MEMORY_HEAP_SHARED :
+                                case DEVICE_MEMORY_HEAP_SHARED_EXPORTED :
+                                {
+                                        
+                                        MMU_CONTEXT *psMMUContext = (MMU_CONTEXT*)pMMUHeap->psMMUContext->psDevInfo->pvMMUContextList;
+
+                                        while(psMMUContext)
+                                        {
+                                                
+                                                pui32PDEntry = (IMG_UINT32*)psMMUContext->pvPDCpuVAddr;
+                                                pui32PDEntry += ui32PDIndex;
+
+                                                
+                                                pui32PDEntry[i] = (sDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                                                                | pMMUHeap->ui32PDEPageSizeCtrl
+                                                                                | SGX_MMU_PDE_VALID;
+
+                                                
+                                                PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+                                                
+                                                psMMUContext = psMMUContext->psNext;
+                                        }
+                                        break;
+                                }
+                                case DEVICE_MEMORY_HEAP_PERCONTEXT :
+                                case DEVICE_MEMORY_HEAP_KERNEL :
+                                {
+                                        
+                                        pui32PDEntry[i] = (sDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                                                        | pMMUHeap->ui32PDEPageSizeCtrl
+                                                                        | SGX_MMU_PDE_VALID;
+
+                                        
+                                        PDUMPPDENTRIES(&pMMUHeap->sMMUAttrib, pMMUHeap->psMMUContext->hPDOSMemHandle, (IMG_VOID*)&pui32PDEntry[i], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+                                        break;
+                                }
+                                default:
+                                {
+                                        PVR_DPF((PVR_DBG_ERROR, "_DeferredAllocPagetables: ERROR invalid heap type"));
+                                        return IMG_FALSE;
+                                }
+                        }
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+                        
+
+
+
+                        MMU_InvalidateDirectoryCache(pMMUHeap->psMMUContext->psDevInfo);
+#endif
+                }
+                else
+                {
+                        
+                        PVR_ASSERT(pui32PDEntry[i] != 0);
+                }
+        }
+
+        #if defined(SGX_FEATURE_SYSTEM_CACHE)
+        MMU_InvalidateSystemLevelCache(pMMUHeap->psMMUContext->psDevInfo);
+        #endif 
+
+        return IMG_TRUE;
+}
+
+
+#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_UINT32 *pui32Tmp;
+        IMG_UINT32 i;
+        IMG_CPU_VIRTADDR pvPDCpuVAddr;
+        IMG_DEV_PHYADDR sPDDevPAddr;
+        IMG_CPU_PHYADDR sCpuPAddr;
+        MMU_CONTEXT *psMMUContext;
+        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),
+                                 (IMG_VOID **)&psMMUContext, IMG_NULL,
+                                 "MMU Context");
+        if (psMMUContext == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocMem failed"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+        OSMemSet (psMMUContext, 0, sizeof(MMU_CONTEXT));
+
+        
+        psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+        psMMUContext->psDevInfo = psDevInfo;
+
+        
+        psMMUContext->psDeviceNode = psDeviceNode;
+
+        
+        if(psDeviceNode->psLocalDevMemArena == IMG_NULL)
+        {
+                if (OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                        SGX_MMU_PAGE_SIZE,
+                                                        SGX_MMU_PAGE_SIZE,
+                                                        &pvPDCpuVAddr,
+                                                        &hPDOSMemHandle) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
+                        return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
+                }
+
+                if(pvPDCpuVAddr)
+                {
+                        sCpuPAddr = OSMapLinToCPUPhys(hPDOSMemHandle,
+                                                                                  pvPDCpuVAddr);
+                }
+                else
+                {
+                        
+                        sCpuPAddr = OSMemHandleToCpuPAddr(hPDOSMemHandle, 0);
+                }
+                sPDDevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+                #if PAGE_TEST
+                PageTest(pvPDCpuVAddr, sPDDevPAddr);
+                #endif
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                if(!psDevInfo->pvMMUContextList)
+                {
+                        
+                        if (OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                                SGX_MMU_PAGE_SIZE,
+                                                                SGX_MMU_PAGE_SIZE,
+                                                                &psDevInfo->pvDummyPTPageCpuVAddr,
+                                                                &psDevInfo->hDummyPTPageOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
+                                return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
+                        }
+
+                        if(psDevInfo->pvDummyPTPageCpuVAddr)
+                        {
+                                sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+                                                                                          psDevInfo->pvDummyPTPageCpuVAddr);
+                        }
+                        else
+                        {
+                                
+                                sCpuPAddr = OSMemHandleToCpuPAddr(psDevInfo->hDummyPTPageOSMemHandle, 0);
+                        }
+                        psDevInfo->sDummyPTDevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+                        
+                        if (OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                                SGX_MMU_PAGE_SIZE,
+                                                                SGX_MMU_PAGE_SIZE,
+                                                                &psDevInfo->pvDummyDataPageCpuVAddr,
+                                                                &psDevInfo->hDummyDataPageOSMemHandle) != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to OSAllocPages failed"));
+                                return PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES;
+                        }
+
+                        if(psDevInfo->pvDummyDataPageCpuVAddr)
+                        {
+                                sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+                                                                                          psDevInfo->pvDummyDataPageCpuVAddr);
+                        }
+                        else
+                        {
+                                sCpuPAddr = OSMemHandleToCpuPAddr(psDevInfo->hDummyDataPageOSMemHandle, 0);
+                        }
+                        psDevInfo->sDummyDataDevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+                }
+#endif 
+        }
+        else
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+
+                
+                if(RA_Alloc(psDeviceNode->psLocalDevMemArena,
+                                        SGX_MMU_PAGE_SIZE,
+                                        IMG_NULL,
+                                        IMG_NULL,
+                                        0,
+                                        SGX_MMU_PAGE_SIZE,
+                                        0,
+                                        &(sSysPAddr.uiAddr))!= IMG_TRUE)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
+                        return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
+                }
+
+                
+                sCpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                sPDDevPAddr = SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sSysPAddr);
+                pvPDCpuVAddr = OSMapPhysToLin(sCpuPAddr,
+                                                                                SGX_MMU_PAGE_SIZE,
+                                                                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                                &hPDOSMemHandle);
+                if(!pvPDCpuVAddr)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
+                        return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
+                }
+
+                #if PAGE_TEST
+                PageTest(pvPDCpuVAddr, sPDDevPAddr);
+                #endif
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                if(!psDevInfo->pvMMUContextList)
+                {
+                        
+                        if(RA_Alloc(psDeviceNode->psLocalDevMemArena,
+                                                SGX_MMU_PAGE_SIZE,
+                                                IMG_NULL,
+                                                IMG_NULL,
+                                                0,
+                                                SGX_MMU_PAGE_SIZE,
+                                                0,
+                                                &(sSysPAddr.uiAddr))!= IMG_TRUE)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
+                                return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
+                        }
+
+                        
+                        sCpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                        psDevInfo->sDummyPTDevPAddr = SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sSysPAddr);
+                        psDevInfo->pvDummyPTPageCpuVAddr = OSMapPhysToLin(sCpuPAddr,
+                                                                                                                                SGX_MMU_PAGE_SIZE,
+                                                                                                                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                                                                                &psDevInfo->hDummyPTPageOSMemHandle);
+                        if(!psDevInfo->pvDummyPTPageCpuVAddr)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
+                                return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
+                        }
+
+                        
+                        if(RA_Alloc(psDeviceNode->psLocalDevMemArena,
+                                                SGX_MMU_PAGE_SIZE,
+                                                IMG_NULL,
+                                                IMG_NULL,
+                                                0,
+                                                SGX_MMU_PAGE_SIZE,
+                                                0,
+                                                &(sSysPAddr.uiAddr))!= IMG_TRUE)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR call to RA_Alloc failed"));
+                                return PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY;
+                        }
+
+                        
+                        sCpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                        psDevInfo->sDummyDataDevPAddr = SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sSysPAddr);
+                        psDevInfo->pvDummyDataPageCpuVAddr = OSMapPhysToLin(sCpuPAddr,
+                                                                                                                                SGX_MMU_PAGE_SIZE,
+                                                                                                                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                                                                                &psDevInfo->hDummyDataPageOSMemHandle);
+                        if(!psDevInfo->pvDummyDataPageCpuVAddr)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: ERROR failed to map page tables"));
+                                return PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE;
+                        }
+                }
+#endif 
+        }
+
+#if defined(PDUMP)
+        
+#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
+#endif 
+#ifdef SUPPORT_SGX_MMU_BYPASS
+        EnableHostAccess(psMMUContext);
+#endif
+
+        if (pvPDCpuVAddr)
+        {
+                pui32Tmp = (IMG_UINT32 *)pvPDCpuVAddr;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Initialise: pvPDCpuVAddr invalid"));
+                return PVRSRV_ERROR_INVALID_CPU_ADDR;
+        }
+
+        PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevId, hPDOSMemHandle, 0, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        
+        for(i=0; i<SGX_MMU_PD_SIZE; i++)
+        {
+                pui32Tmp[i] = (psDevInfo->sDummyPTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                        | SGX_MMU_PDE_PAGE_SIZE_4K
+                                        | SGX_MMU_PDE_VALID;
+        }
+
+        if(!psDevInfo->pvMMUContextList)
+        {
+                
+
+
+                pui32Tmp = (IMG_UINT32 *)psDevInfo->pvDummyPTPageCpuVAddr;
+                for(i=0; i<SGX_MMU_PT_SIZE; i++)
+                {
+                        pui32Tmp[i] = (psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                | SGX_MMU_PTE_VALID;
+                }
+                
+                PDUMPCOMMENT("Dummy Page table contents");
+                PDUMPMEMPTENTRIES(&sMMUAttrib, psDevInfo->hDummyPTOSMemHandle, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+                
+
+                pui32Tmp = (IMG_UINT32 *)psDevInfo->pvDummyDataPageCpuVAddr;
+                for(i=0; i<(SGX_MMU_PAGE_SIZE/4); i++)
+                {
+                        pui32Tmp[i] = DUMMY_DATA_PAGE_SIGNATURE;
+                }
+                
+                PDUMPCOMMENT("Dummy Data Page contents");
+                PDUMPMEMPTENTRIES(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->hDummyDataPageOSMemHandle, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+        }
+#else 
+        
+        for(i=0; i<SGX_MMU_PD_SIZE; i++)
+        {
+                
+                pui32Tmp[i] = 0;
+        }
+#endif 
+
+        
+        PDUMPCOMMENT("Page directory contents");
+        PDUMPMEMPTENTRIES(&sMMUAttrib, hPDOSMemHandle, pvPDCpuVAddr, SGX_MMU_PAGE_SIZE, 0, IMG_TRUE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+        
+#if defined(PDUMP)
+        {
+                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
+
+        
+        psMMUContext->pvPDCpuVAddr = pvPDCpuVAddr;
+        psMMUContext->sPDDevPAddr = sPDDevPAddr;
+        psMMUContext->hPDOSMemHandle = hPDOSMemHandle;
+
+        
+        *ppsMMUContext = psMMUContext;
+
+        
+        *psPDDevPAddr = sPDDevPAddr;
+
+        
+        psMMUContext->psNext = (MMU_CONTEXT*)psDevInfo->pvMMUContextList;
+        psDevInfo->pvMMUContextList = (IMG_VOID*)psMMUContext;
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+        DisableHostAccess(psMMUContext);
+#endif
+
+        return PVRSRV_OK;
+}
+
+IMG_VOID
+MMU_Finalise (MMU_CONTEXT *psMMUContext)
+{
+        IMG_UINT32 *pui32Tmp, i;
+        SYS_DATA *psSysData;
+        MMU_CONTEXT **ppsMMUContext;
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO*)psMMUContext->psDevInfo;
+        MMU_CONTEXT *psMMUContextList = (MMU_CONTEXT*)psDevInfo->pvMMUContextList;
+#endif
+
+        SysAcquireData(&psSysData);
+
+#if defined(PDUMP)
+        
+        PDUMPCOMMENT("Clear MMU context (MMU Context ID == %u)", psMMUContext->ui32PDumpMMUContextID);
+        PDUMPCLEARMMUCONTEXT(PVRSRV_DEVICE_TYPE_SGX, psMMUContext->psDeviceNode->sDevId.pszPDumpDevName, psMMUContext->ui32PDumpMMUContextID, 2);
+
+        
+#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, PDUMP_PT_UNIQUETAG);
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        PDUMPFREEPAGETABLE(&psMMUContext->psDeviceNode->sDevId, psDevInfo->hDummyPTPageOSMemHandle, psDevInfo->pvDummyPTPageCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+        PDUMPFREEPAGETABLE(&psMMUContext->psDeviceNode->sDevId, psDevInfo->hDummyDataPageOSMemHandle, psDevInfo->pvDummyDataPageCpuVAddr, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+#endif
+
+        pui32Tmp = (IMG_UINT32 *)psMMUContext->pvPDCpuVAddr;
+
+        
+        for(i=0; i<SGX_MMU_PD_SIZE; i++)
+        {
+                
+                pui32Tmp[i] = 0;
+        }
+
+        
+
+
+
+        if(psMMUContext->psDeviceNode->psLocalDevMemArena == IMG_NULL)
+        {
+                OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                SGX_MMU_PAGE_SIZE,
+                                                psMMUContext->pvPDCpuVAddr,
+                                                psMMUContext->hPDOSMemHandle);
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                if(!psMMUContextList->psNext)
+                {
+                        OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                        SGX_MMU_PAGE_SIZE,
+                                                        psDevInfo->pvDummyPTPageCpuVAddr,
+                                                        psDevInfo->hDummyPTPageOSMemHandle);
+                        OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                        SGX_MMU_PAGE_SIZE,
+                                                        psDevInfo->pvDummyDataPageCpuVAddr,
+                                                        psDevInfo->hDummyDataPageOSMemHandle);
+                }
+#endif
+        }
+        else
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+                IMG_CPU_PHYADDR sCpuPAddr;
+
+                
+                sCpuPAddr = OSMapLinToCPUPhys(psMMUContext->hPDOSMemHandle,
+                                                                          psMMUContext->pvPDCpuVAddr);
+                sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
+
+                
+                OSUnMapPhysToLin(psMMUContext->pvPDCpuVAddr,
+                                                        SGX_MMU_PAGE_SIZE,
+                            PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                        psMMUContext->hPDOSMemHandle);
+                
+                RA_Free (psMMUContext->psDeviceNode->psLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                if(!psMMUContextList->psNext)
+                {
+                        
+                        sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyPTPageOSMemHandle,
+                                                                                  psDevInfo->pvDummyPTPageCpuVAddr);
+                        sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
+
+                        
+                        OSUnMapPhysToLin(psDevInfo->pvDummyPTPageCpuVAddr,
+                                                                SGX_MMU_PAGE_SIZE,
+                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                psDevInfo->hDummyPTPageOSMemHandle);
+                        
+                        RA_Free (psMMUContext->psDeviceNode->psLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+
+                        
+                        sCpuPAddr = OSMapLinToCPUPhys(psDevInfo->hDummyDataPageOSMemHandle,
+                                                                                  psDevInfo->pvDummyDataPageCpuVAddr);
+                        sSysPAddr = SysCpuPAddrToSysPAddr(sCpuPAddr);
+
+                        
+                        OSUnMapPhysToLin(psDevInfo->pvDummyDataPageCpuVAddr,
+                                                                SGX_MMU_PAGE_SIZE,
+                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                psDevInfo->hDummyDataPageOSMemHandle);
+                        
+                        RA_Free (psMMUContext->psDeviceNode->psLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE);
+                }
+#endif
+        }
+
+        PVR_DPF ((PVR_DBG_MESSAGE, "MMU_Finalise"));
+
+        
+        ppsMMUContext = (MMU_CONTEXT**)&psMMUContext->psDevInfo->pvMMUContextList;
+        while(*ppsMMUContext)
+        {
+                if(*ppsMMUContext == psMMUContext)
+                {
+                        
+                        *ppsMMUContext = psMMUContext->psNext;
+                        break;
+                }
+
+                
+                ppsMMUContext = &((*ppsMMUContext)->psNext);
+        }
+
+        
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(MMU_CONTEXT), psMMUContext, IMG_NULL);
+        
+}
+
+
+IMG_VOID
+MMU_InsertHeap(MMU_CONTEXT *psMMUContext, MMU_HEAP *psMMUHeap)
+{
+        IMG_UINT32 *pui32PDCpuVAddr = (IMG_UINT32 *) psMMUContext->pvPDCpuVAddr;
+        IMG_UINT32 *pui32KernelPDCpuVAddr = (IMG_UINT32 *) psMMUHeap->psMMUContext->pvPDCpuVAddr;
+        IMG_UINT32 ui32PDEntry;
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+        IMG_BOOL bInvalidateDirectoryCache = IMG_FALSE;
+#endif
+
+        
+        pui32PDCpuVAddr += psMMUHeap->psDevArena->BaseDevVAddr.uiAddr >> psMMUHeap->ui32PDShift;
+        pui32KernelPDCpuVAddr += psMMUHeap->psDevArena->BaseDevVAddr.uiAddr >> psMMUHeap->ui32PDShift;
+
+        
+
+
+#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
+
+        for (ui32PDEntry = 0; ui32PDEntry < psMMUHeap->ui32PageTableCount; ui32PDEntry++)
+        {
+#if !defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                PVR_ASSERT(pui32PDCpuVAddr[ui32PDEntry] == 0);
+#endif
+
+                
+                pui32PDCpuVAddr[ui32PDEntry] = pui32KernelPDCpuVAddr[ui32PDEntry];
+                if (pui32PDCpuVAddr[ui32PDEntry])
+                {
+                        PDUMPPDENTRIES(&psMMUHeap->sMMUAttrib, psMMUContext->hPDOSMemHandle, (IMG_VOID *) &pui32PDCpuVAddr[ui32PDEntry], sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PD_UNIQUETAG, PDUMP_PT_UNIQUETAG);
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+                        bInvalidateDirectoryCache = IMG_TRUE;
+#endif
+                }
+        }
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+        DisableHostAccess(psMMUContext);
+#endif
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+        if (bInvalidateDirectoryCache)
+        {
+                
+
+
+
+                MMU_InvalidateDirectoryCache(psMMUContext->psDevInfo);
+        }
+#endif
+}
+
+
+static IMG_VOID
+MMU_UnmapPagesAndFreePTs (MMU_HEAP *psMMUHeap,
+                                                  IMG_DEV_VIRTADDR sDevVAddr,
+                                                  IMG_UINT32 ui32PageCount,
+                                                  IMG_HANDLE hUniqueTag)
+{
+        IMG_DEV_VIRTADDR        sTmpDevVAddr;
+        IMG_UINT32                      i;
+        IMG_UINT32                      ui32PDIndex;
+        IMG_UINT32                      ui32PTIndex;
+        IMG_UINT32                      *pui32Tmp;
+        IMG_BOOL                        bInvalidateDirectoryCache = IMG_FALSE;
+
+#if !defined (PDUMP)
+        PVR_UNREFERENCED_PARAMETER(hUniqueTag);
+#endif
+        
+        sTmpDevVAddr = sDevVAddr;
+
+        for(i=0; i<ui32PageCount; i++)
+        {
+                MMU_PT_INFO **ppsPTInfoList;
+
+                
+                ui32PDIndex = sTmpDevVAddr.uiAddr >> psMMUHeap->ui32PDShift;
+
+                
+                ppsPTInfoList = &psMMUHeap->psMMUContext->apsPTInfoList[ui32PDIndex];
+
+                {
+                        
+                        ui32PTIndex = (sTmpDevVAddr.uiAddr & psMMUHeap->ui32PTMask) >> psMMUHeap->ui32PTShift;
+
+                        
+                        if (!ppsPTInfoList[0])
+                        {
+                                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;
+
+                                
+                                continue;
+                        }
+
+                        
+                        pui32Tmp = (IMG_UINT32*)ppsPTInfoList[0]->PTPageCpuVAddr;
+
+                        
+                        if (!pui32Tmp)
+                        {
+                                continue;
+                        }
+
+                        CheckPT(ppsPTInfoList[0]);
+
+                        
+                        if (pui32Tmp[ui32PTIndex] & SGX_MMU_PTE_VALID)
+                        {
+                                ppsPTInfoList[0]->ui32ValidPTECount--;
+                        }
+                        else
+                        {
+                                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 ));
+                        }
+
+                        
+                        PVR_ASSERT((IMG_INT32)ppsPTInfoList[0]->ui32ValidPTECount >= 0);
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                        
+                        pui32Tmp[ui32PTIndex] = (psMMUHeap->psMMUContext->psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                                        | SGX_MMU_PTE_VALID;
+#else
+                        
+                        pui32Tmp[ui32PTIndex] = 0;
+#endif
+
+                        CheckPT(ppsPTInfoList[0]);
+                }
+
+                
+
+                if (ppsPTInfoList[0] && ppsPTInfoList[0]->ui32ValidPTECount == 0)
+                {
+                        _DeferredFreePageTable(psMMUHeap, ui32PDIndex - psMMUHeap->ui32PDBaseIndex, IMG_TRUE);
+                        bInvalidateDirectoryCache = IMG_TRUE;
+                }
+
+                
+                sTmpDevVAddr.uiAddr += psMMUHeap->ui32DataPageSize;
+        }
+
+        if(bInvalidateDirectoryCache)
+        {
+                MMU_InvalidateDirectoryCache(psMMUHeap->psMMUContext->psDevInfo);
+        }
+        else
+        {
+                MMU_InvalidatePageTableCache(psMMUHeap->psMMUContext->psDevInfo);
+        }
+
+#if defined(PDUMP)
+        MMU_PDumpPageTables(psMMUHeap,
+                                                sDevVAddr,
+                                                psMMUHeap->ui32DataPageSize * ui32PageCount,
+                                                IMG_TRUE,
+                                                hUniqueTag);
+#endif 
+}
+
+
+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;
+
+        Start.uiAddr = ui32Start;
+
+        MMU_UnmapPagesAndFreePTs(pMMUHeap, Start, (ui32End - ui32Start) >> pMMUHeap->ui32PTShift, hUniqueTag);
+}
+
+MMU_HEAP *
+MMU_Create (MMU_CONTEXT *psMMUContext,
+                        DEV_ARENA_DESCRIPTOR *psDevArena,
+                        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)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Create: invalid parameter"));
+                return IMG_NULL;
+        }
+
+        OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                 sizeof (MMU_HEAP),
+                                 (IMG_VOID **)&pMMUHeap, IMG_NULL,
+                                 "MMU Heap");
+        if (pMMUHeap == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Create: ERROR call to OSAllocMem failed"));
+                return IMG_NULL;
+        }
+
+        pMMUHeap->psMMUContext = psMMUContext;
+        pMMUHeap->psDevArena = psDevArena;
+
+        
+
+
+        switch(pMMUHeap->psDevArena->ui32DataPageSize)
+        {
+                case 0x1000:
+                        ui32ScaleSize = 0;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_4K;
+                        break;
+#if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)
+                case 0x4000:
+                        ui32ScaleSize = 2;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_16K;
+                        break;
+                case 0x10000:
+                        ui32ScaleSize = 4;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_64K;
+                        break;
+                case 0x40000:
+                        ui32ScaleSize = 6;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_256K;
+                        break;
+                case 0x100000:
+                        ui32ScaleSize = 8;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_1M;
+                        break;
+                case 0x400000:
+                        ui32ScaleSize = 10;
+                        pMMUHeap->ui32PDEPageSizeCtrl = SGX_MMU_PDE_PAGE_SIZE_4M;
+                        break;
+#endif 
+                default:
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_Create: invalid data page size"));
+                        goto ErrorFreeHeap;
+        }
+
+        
+        pMMUHeap->ui32DataPageSize = psDevArena->ui32DataPageSize;
+        pMMUHeap->ui32DataPageBitWidth = SGX_MMU_PAGE_SHIFT + ui32ScaleSize;
+        pMMUHeap->ui32DataPageMask = pMMUHeap->ui32DataPageSize - 1;
+        
+        pMMUHeap->ui32PTShift = pMMUHeap->ui32DataPageBitWidth;
+        pMMUHeap->ui32PTBitWidth = SGX_MMU_PT_SHIFT - ui32ScaleSize;
+        pMMUHeap->ui32PTMask = SGX_MMU_PT_MASK & (SGX_MMU_PT_MASK<<ui32ScaleSize);
+        pMMUHeap->ui32PTSize = (IMG_UINT32)(1UL<<pMMUHeap->ui32PTBitWidth) * sizeof(IMG_UINT32);
+        
+        if(pMMUHeap->ui32PTSize < 4 * sizeof(IMG_UINT32))
+        {
+                pMMUHeap->ui32PTSize = 4 * sizeof(IMG_UINT32);
+        }
+        pMMUHeap->ui32PTECount = pMMUHeap->ui32PTSize >> 2;
+
+        
+        pMMUHeap->ui32PDShift = pMMUHeap->ui32PTBitWidth + pMMUHeap->ui32PTShift;
+        pMMUHeap->ui32PDBitWidth = SGX_FEATURE_ADDRESS_SPACE_SIZE - pMMUHeap->ui32PTBitWidth - pMMUHeap->ui32DataPageBitWidth;
+        pMMUHeap->ui32PDMask = SGX_MMU_PD_MASK & (SGX_MMU_PD_MASK>>(32-SGX_FEATURE_ADDRESS_SPACE_SIZE));
+
+        
+
+
+
+        if(psDevArena->BaseDevVAddr.uiAddr > (pMMUHeap->ui32DataPageMask | pMMUHeap->ui32PTMask))
+        {
+                
+
+
+                PVR_ASSERT ((psDevArena->BaseDevVAddr.uiAddr
+                                                & (pMMUHeap->ui32DataPageMask
+                                                        | pMMUHeap->ui32PTMask)) == 0);
+        }
+
+        
+        pMMUHeap->ui32PTETotal = pMMUHeap->psDevArena->ui32Size >> pMMUHeap->ui32PTShift;
+
+        
+        pMMUHeap->ui32PDBaseIndex = (pMMUHeap->psDevArena->BaseDevVAddr.uiAddr & pMMUHeap->ui32PDMask) >> pMMUHeap->ui32PDShift;
+
+        
+
+
+        pMMUHeap->ui32PageTableCount = (pMMUHeap->ui32PTETotal + pMMUHeap->ui32PTECount - 1)
+                                                                                >> pMMUHeap->ui32PTBitWidth;
+
+        
+        pMMUHeap->psVMArena = RA_Create(psDevArena->pszName,
+                                                                        psDevArena->BaseDevVAddr.uiAddr,
+                                                                        psDevArena->ui32Size,
+                                                                        IMG_NULL,
+                                                                        MAX(HOST_PAGESIZE(), pMMUHeap->ui32DataPageSize),
+                                                                        IMG_NULL,
+                                                                        IMG_NULL,
+                                                                        &MMU_FreePageTables,
+                                                                        pMMUHeap);
+
+        if (pMMUHeap->psVMArena == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Create: ERROR call to RA_Create failed"));
+                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)
+        {
+                IMG_UINT32 ui32RegVal;
+                IMG_UINT32 ui32XTileStride;
+
+                
+
+
+
+
+                ui32XTileStride = 2;
+
+                ui32RegVal = (EUR_CR_BIF_TILE0_MIN_ADDRESS_MASK
+                                                & ((psDevArena->BaseDevVAddr.uiAddr>>20)
+                                                << EUR_CR_BIF_TILE0_MIN_ADDRESS_SHIFT))
+                                        |(EUR_CR_BIF_TILE0_MAX_ADDRESS_MASK
+                                                & (((psDevArena->BaseDevVAddr.uiAddr+psDevArena->ui32Size)>>20)
+                                                << EUR_CR_BIF_TILE0_MAX_ADDRESS_SHIFT))
+                                        |(EUR_CR_BIF_TILE0_CFG_MASK
+                                                & (((ui32XTileStride<<1)|8) << EUR_CR_BIF_TILE0_CFG_SHIFT));
+                PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_TILE0, ui32RegVal);
+        }
+#endif
+
+        
+
+        *ppsVMArena = pMMUHeap->psVMArena;
+
+        return pMMUHeap;
+
+        
+ErrorFreePagetables:
+        _DeferredFreePageTables (pMMUHeap);
+
+ErrorFreeHeap:
+        OSFreeMem (PVRSRV_OS_PAGEABLE_HEAP, sizeof(MMU_HEAP), pMMUHeap, IMG_NULL);
+        
+
+        return IMG_NULL;
+}
+
+IMG_VOID
+MMU_Delete (MMU_HEAP *pMMUHeap)
+{
+        if (pMMUHeap != IMG_NULL)
+        {
+                PVR_DPF ((PVR_DBG_MESSAGE, "MMU_Delete"));
+
+                if(pMMUHeap->psVMArena)
+                {
+                        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
+                _DeferredFreePageTables (pMMUHeap);
+#ifdef SUPPORT_SGX_MMU_BYPASS
+                DisableHostAccess(pMMUHeap->psMMUContext);
+#endif
+
+                OSFreeMem (PVRSRV_OS_PAGEABLE_HEAP, sizeof(MMU_HEAP), pMMUHeap, IMG_NULL);
+                
+        }
+}
+
+IMG_BOOL
+MMU_Alloc (MMU_HEAP *pMMUHeap,
+                   IMG_SIZE_T uSize,
+                   IMG_SIZE_T *pActualSize,
+                   IMG_UINT32 uFlags,
+                   IMG_UINT32 uDevVAddrAlignment,
+                   IMG_DEV_VIRTADDR *psDevVAddr)
+{
+        IMG_BOOL bStatus;
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                "MMU_Alloc: uSize=0x%x, flags=0x%x, align=0x%x",
+                uSize, uFlags, uDevVAddrAlignment));
+
+        
+
+        if((uFlags & PVRSRV_MEM_USER_SUPPLIED_DEVVADDR) == 0)
+        {
+                IMG_UINTPTR_T uiAddr;
+
+                bStatus = RA_Alloc (pMMUHeap->psVMArena,
+                                                        uSize,
+                                                        pActualSize,
+                                                        IMG_NULL,
+                                                        0,
+                                                        uDevVAddrAlignment,
+                                                        0,
+                                                        &uiAddr);
+                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);
+        }
+
+        #ifdef SUPPORT_SGX_MMU_BYPASS
+        EnableHostAccess(pMMUHeap->psMMUContext);
+        #endif
+
+        
+        bStatus = _DeferredAllocPagetables(pMMUHeap, *psDevVAddr, uSize);
+
+        #ifdef SUPPORT_SGX_MMU_BYPASS
+        DisableHostAccess(pMMUHeap->psMMUContext);
+        #endif
+
+        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)
+                {
+                        
+                        RA_Free (pMMUHeap->psVMArena, psDevVAddr->uiAddr, IMG_FALSE);
+                }
+        }
+
+        return bStatus;
+}
+
+IMG_VOID
+MMU_Free (MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR DevVAddr, IMG_UINT32 ui32Size)
+{
+        PVR_ASSERT (pMMUHeap != IMG_NULL);
+
+        if (pMMUHeap == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "MMU_Free: invalid parameter"));
+                return;
+        }
+
+        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))
+        {
+                RA_Free (pMMUHeap->psVMArena, DevVAddr.uiAddr, IMG_TRUE);
+                return;
+        }
+
+        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
+MMU_Enable (MMU_HEAP *pMMUHeap)
+{
+        PVR_UNREFERENCED_PARAMETER(pMMUHeap);
+        
+}
+
+IMG_VOID
+MMU_Disable (MMU_HEAP *pMMUHeap)
+{
+        PVR_UNREFERENCED_PARAMETER(pMMUHeap);
+        
+}
+
+#if defined(PDUMP)
+static IMG_VOID
+MMU_PDumpPageTables     (MMU_HEAP *pMMUHeap,
+                                         IMG_DEV_VIRTADDR DevVAddr,
+                                         IMG_SIZE_T uSize,
+                                         IMG_BOOL bForUnmap,
+                                         IMG_HANDLE hUniqueTag)
+{
+        IMG_UINT32      ui32NumPTEntries;
+        IMG_UINT32      ui32PTIndex;
+        IMG_UINT32      *pui32PTEntry;
+
+        MMU_PT_INFO **ppsPTInfoList;
+        IMG_UINT32 ui32PDIndex;
+        IMG_UINT32 ui32PTDumpCount;
+
+        
+        ui32NumPTEntries = (uSize + pMMUHeap->ui32DataPageMask) >> pMMUHeap->ui32PTShift;
+
+        
+        ui32PDIndex = DevVAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        
+        ppsPTInfoList = &pMMUHeap->psMMUContext->apsPTInfoList[ui32PDIndex];
+
+        
+        ui32PTIndex = (DevVAddr.uiAddr & pMMUHeap->ui32PTMask) >> pMMUHeap->ui32PTShift;
+
+        
+        PDUMPCOMMENT("Page table mods (num entries == %08X) %s", ui32NumPTEntries, bForUnmap ? "(for unmap)" : "");
+
+        
+        while(ui32NumPTEntries > 0)
+        {
+                MMU_PT_INFO* psPTInfo = *ppsPTInfoList++;
+
+                if(ui32NumPTEntries <= pMMUHeap->ui32PTECount - ui32PTIndex)
+                {
+                        ui32PTDumpCount = ui32NumPTEntries;
+                }
+                else
+                {
+                        ui32PTDumpCount = pMMUHeap->ui32PTECount - ui32PTIndex;
+                }
+
+                if (psPTInfo)
+                {
+                        pui32PTEntry = (IMG_UINT32*)psPTInfo->PTPageCpuVAddr;
+                        PDUMPMEMPTENTRIES(&pMMUHeap->sMMUAttrib, psPTInfo->hPTPageOSMemHandle, (IMG_VOID *) &pui32PTEntry[ui32PTIndex], ui32PTDumpCount * sizeof(IMG_UINT32), 0, IMG_FALSE, PDUMP_PT_UNIQUETAG, hUniqueTag);
+                }
+
+                
+                ui32NumPTEntries -= ui32PTDumpCount;
+
+                
+                ui32PTIndex = 0;
+        }
+
+        PDUMPCOMMENT("Finished page table mods %s", bForUnmap ? "(for unmap)" : "");
+}
+#endif 
+
+
+static IMG_VOID
+MMU_MapPage (MMU_HEAP *pMMUHeap,
+                         IMG_DEV_VIRTADDR DevVAddr,
+                         IMG_DEV_PHYADDR DevPAddr,
+                         IMG_UINT32 ui32MemFlags)
+{
+        IMG_UINT32 ui32Index;
+        IMG_UINT32 *pui32Tmp;
+        IMG_UINT32 ui32MMUFlags = 0;
+        MMU_PT_INFO **ppsPTInfoList;
+
+        
+        PVR_ASSERT((DevPAddr.uiAddr & pMMUHeap->ui32DataPageMask) == 0);
+
+        
+
+        if(((PVRSRV_MEM_READ|PVRSRV_MEM_WRITE) & ui32MemFlags) == (PVRSRV_MEM_READ|PVRSRV_MEM_WRITE))
+        {
+                
+                ui32MMUFlags = 0;
+        }
+        else if(PVRSRV_MEM_READ & ui32MemFlags)
+        {
+                
+                ui32MMUFlags |= SGX_MMU_PTE_READONLY;
+        }
+        else if(PVRSRV_MEM_WRITE & ui32MemFlags)
+        {
+                
+                ui32MMUFlags |= SGX_MMU_PTE_WRITEONLY;
+        }
+
+        
+        if(PVRSRV_MEM_CACHE_CONSISTENT & ui32MemFlags)
+        {
+                ui32MMUFlags |= SGX_MMU_PTE_CACHECONSISTENT;
+        }
+
+#if !defined(FIX_HW_BRN_25503)
+        
+        if(PVRSRV_MEM_EDM_PROTECT & ui32MemFlags)
+        {
+                ui32MMUFlags |= SGX_MMU_PTE_EDMPROTECT;
+        }
+#endif
+
+        
+
+
+        
+        ui32Index = DevVAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        
+        ppsPTInfoList = &pMMUHeap->psMMUContext->apsPTInfoList[ui32Index];
+
+        CheckPT(ppsPTInfoList[0]);
+
+        
+        ui32Index = (DevVAddr.uiAddr & pMMUHeap->ui32PTMask) >> pMMUHeap->ui32PTShift;
+
+        
+        pui32Tmp = (IMG_UINT32*)ppsPTInfoList[0]->PTPageCpuVAddr;
+
+#if !defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        {
+                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);
+        }
+#endif
+
+        
+        ppsPTInfoList[0]->ui32ValidPTECount++;
+
+        
+        pui32Tmp[ui32Index] = ((DevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                & ((~pMMUHeap->ui32DataPageMask)>>SGX_MMU_PTE_ADDR_ALIGNSHIFT))
+                                                | SGX_MMU_PTE_VALID
+                                                | ui32MMUFlags;
+
+        CheckPT(ppsPTInfoList[0]);
+}
+
+
+IMG_VOID
+MMU_MapScatter (MMU_HEAP *pMMUHeap,
+                                IMG_DEV_VIRTADDR DevVAddr,
+                                IMG_SYS_PHYADDR *psSysAddr,
+                                IMG_SIZE_T uSize,
+                                IMG_UINT32 ui32MemFlags,
+                                IMG_HANDLE hUniqueTag)
+{
+#if defined(PDUMP)
+        IMG_DEV_VIRTADDR MapBaseDevVAddr;
+#endif 
+        IMG_UINT32 uCount, i;
+        IMG_DEV_PHYADDR DevPAddr;
+
+        PVR_ASSERT (pMMUHeap != IMG_NULL);
+
+#if defined(PDUMP)
+        MapBaseDevVAddr = DevVAddr;
+#else
+        PVR_UNREFERENCED_PARAMETER(hUniqueTag);
+#endif 
+
+        for (i=0, uCount=0; uCount<uSize; i++, uCount+=pMMUHeap->ui32DataPageSize)
+        {
+                IMG_SYS_PHYADDR sSysAddr;
+
+                sSysAddr = psSysAddr[i];
+
+
+                
+                PVR_ASSERT((sSysAddr.uiAddr & pMMUHeap->ui32DataPageMask) == 0);
+
+                DevPAddr = SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sSysAddr);
+
+                MMU_MapPage (pMMUHeap, DevVAddr, DevPAddr, ui32MemFlags);
+                DevVAddr.uiAddr += pMMUHeap->ui32DataPageSize;
+
+                PVR_DPF ((PVR_DBG_MESSAGE,
+                                 "MMU_MapScatter: devVAddr=%08X, SysAddr=%08X, size=0x%x/0x%x",
+                                  DevVAddr.uiAddr, sSysAddr.uiAddr, uCount, uSize));
+        }
+
+#if defined(PDUMP)
+        MMU_PDumpPageTables (pMMUHeap, MapBaseDevVAddr, uSize, IMG_FALSE, hUniqueTag);
+#endif 
+}
+
+IMG_VOID
+MMU_MapPages (MMU_HEAP *pMMUHeap,
+                          IMG_DEV_VIRTADDR DevVAddr,
+                          IMG_SYS_PHYADDR SysPAddr,
+                          IMG_SIZE_T uSize,
+                          IMG_UINT32 ui32MemFlags,
+                          IMG_HANDLE hUniqueTag)
+{
+        IMG_DEV_PHYADDR DevPAddr;
+#if defined(PDUMP)
+        IMG_DEV_VIRTADDR MapBaseDevVAddr;
+#endif 
+        IMG_UINT32 uCount;
+        IMG_UINT32 ui32VAdvance;
+        IMG_UINT32 ui32PAdvance;
+
+        PVR_ASSERT (pMMUHeap != IMG_NULL);
+
+        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;
+        ui32PAdvance = pMMUHeap->ui32DataPageSize;
+
+#if defined(PDUMP)
+        MapBaseDevVAddr = DevVAddr;
+#else
+        PVR_UNREFERENCED_PARAMETER(hUniqueTag);
+#endif 
+
+        DevPAddr = SysSysPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, SysPAddr);
+
+        
+        PVR_ASSERT((DevPAddr.uiAddr & pMMUHeap->ui32DataPageMask) == 0);
+
+#if defined(FIX_HW_BRN_23281)
+        if(ui32MemFlags & PVRSRV_MEM_INTERLEAVED)
+        {
+                ui32VAdvance *= 2;
+        }
+#endif
+
+        
+
+
+        if(ui32MemFlags & PVRSRV_MEM_DUMMY)
+        {
+                ui32PAdvance = 0;
+        }
+
+        for (uCount=0; uCount<uSize; uCount+=ui32VAdvance)
+        {
+                MMU_MapPage (pMMUHeap, DevVAddr, DevPAddr, ui32MemFlags);
+                DevVAddr.uiAddr += ui32VAdvance;
+                DevPAddr.uiAddr += ui32PAdvance;
+        }
+
+#if defined(PDUMP)
+        MMU_PDumpPageTables (pMMUHeap, MapBaseDevVAddr, uSize, IMG_FALSE, hUniqueTag);
+#endif 
+}
+
+IMG_VOID
+MMU_MapShadow (MMU_HEAP          *pMMUHeap,
+                           IMG_DEV_VIRTADDR   MapBaseDevVAddr,
+                           IMG_SIZE_T         uByteSize,
+                           IMG_CPU_VIRTADDR   CpuVAddr,
+                           IMG_HANDLE         hOSMemHandle,
+                           IMG_DEV_VIRTADDR  *pDevVAddr,
+                           IMG_UINT32         ui32MemFlags,
+                           IMG_HANDLE         hUniqueTag)
+{
+        IMG_UINT32                      i;
+        IMG_UINT32                      uOffset = 0;
+        IMG_DEV_VIRTADDR        MapDevVAddr;
+        IMG_UINT32                      ui32VAdvance;
+        IMG_UINT32                      ui32PAdvance;
+
+#if !defined (PDUMP)
+        PVR_UNREFERENCED_PARAMETER(hUniqueTag);
+#endif
+
+        PVR_DPF ((PVR_DBG_MESSAGE,
+                        "MMU_MapShadow: DevVAddr:%08X, Bytes:0x%x, CPUVAddr:%08X",
+                        MapBaseDevVAddr.uiAddr,
+                        uByteSize,
+                        (IMG_UINTPTR_T)CpuVAddr));
+
+        
+        ui32VAdvance = pMMUHeap->ui32DataPageSize;
+        ui32PAdvance = pMMUHeap->ui32DataPageSize;
+
+        
+        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 defined(FIX_HW_BRN_23281)
+        if(ui32MemFlags & PVRSRV_MEM_INTERLEAVED)
+        {
+                ui32VAdvance *= 2;
+        }
+#endif
+
+        
+
+
+        if(ui32MemFlags & PVRSRV_MEM_DUMMY)
+        {
+                ui32PAdvance = 0;
+        }
+
+        
+        MapDevVAddr = MapBaseDevVAddr;
+        for (i=0; i<uByteSize; i+=ui32VAdvance)
+        {
+                IMG_CPU_PHYADDR CpuPAddr;
+                IMG_DEV_PHYADDR DevPAddr;
+
+                if(CpuVAddr)
+                {
+                        CpuPAddr = OSMapLinToCPUPhys (hOSMemHandle,
+                                                                                  (IMG_VOID *)((IMG_UINTPTR_T)CpuVAddr + uOffset));
+                }
+                else
+                {
+                        CpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, uOffset);
+                }
+                DevPAddr = SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE_SGX, CpuPAddr);
+
+                
+                PVR_ASSERT((DevPAddr.uiAddr & pMMUHeap->ui32DataPageMask) == 0);
+
+                PVR_DPF ((PVR_DBG_MESSAGE,
+                                "Offset=0x%x: CpuVAddr=%08X, CpuPAddr=%08X, DevVAddr=%08X, DevPAddr=%08X",
+                                uOffset,
+                                (IMG_UINTPTR_T)CpuVAddr + uOffset,
+                                CpuPAddr.uiAddr,
+                                MapDevVAddr.uiAddr,
+                                DevPAddr.uiAddr));
+
+                MMU_MapPage (pMMUHeap, MapDevVAddr, DevPAddr, ui32MemFlags);
+
+                
+                MapDevVAddr.uiAddr += ui32VAdvance;
+                uOffset += ui32PAdvance;
+        }
+
+#if defined(PDUMP)
+        MMU_PDumpPageTables (pMMUHeap, MapBaseDevVAddr, uByteSize, IMG_FALSE, hUniqueTag);
+#endif 
+}
+
+
+IMG_VOID
+MMU_UnmapPages (MMU_HEAP *psMMUHeap,
+                                IMG_DEV_VIRTADDR sDevVAddr,
+                                IMG_UINT32 ui32PageCount,
+                                IMG_HANDLE hUniqueTag)
+{
+        IMG_UINT32                      uPageSize = psMMUHeap->ui32DataPageSize;
+        IMG_DEV_VIRTADDR        sTmpDevVAddr;
+        IMG_UINT32                      i;
+        IMG_UINT32                      ui32PDIndex;
+        IMG_UINT32                      ui32PTIndex;
+        IMG_UINT32                      *pui32Tmp;
+
+#if !defined (PDUMP)
+        PVR_UNREFERENCED_PARAMETER(hUniqueTag);
+#endif
+
+        
+        sTmpDevVAddr = sDevVAddr;
+
+        for(i=0; i<ui32PageCount; i++)
+        {
+                MMU_PT_INFO **ppsPTInfoList;
+
+                
+                ui32PDIndex = sTmpDevVAddr.uiAddr >> psMMUHeap->ui32PDShift;
+
+                
+                ppsPTInfoList = &psMMUHeap->psMMUContext->apsPTInfoList[ui32PDIndex];
+
+                
+                ui32PTIndex = (sTmpDevVAddr.uiAddr & psMMUHeap->ui32PTMask) >> psMMUHeap->ui32PTShift;
+
+                
+                if (!ppsPTInfoList[0])
+                {
+                        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,
+                                                                        ui32PDIndex,
+                                                                        ui32PTIndex));
+
+                        
+                        sTmpDevVAddr.uiAddr += uPageSize;
+
+                        
+                        continue;
+                }
+
+                CheckPT(ppsPTInfoList[0]);
+
+                
+                pui32Tmp = (IMG_UINT32*)ppsPTInfoList[0]->PTPageCpuVAddr;
+
+                
+                if (pui32Tmp[ui32PTIndex] & SGX_MMU_PTE_VALID)
+                {
+                        ppsPTInfoList[0]->ui32ValidPTECount--;
+                }
+                else
+                {
+                        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%08X", pui32Tmp[ui32PTIndex]));
+                }
+
+                
+                PVR_ASSERT((IMG_INT32)ppsPTInfoList[0]->ui32ValidPTECount >= 0);
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+                
+                pui32Tmp[ui32PTIndex] = (psMMUHeap->psMMUContext->psDevInfo->sDummyDataDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                                | SGX_MMU_PTE_VALID;
+#else
+                
+                pui32Tmp[ui32PTIndex] = 0;
+#endif
+
+                CheckPT(ppsPTInfoList[0]);
+
+                
+                sTmpDevVAddr.uiAddr += uPageSize;
+        }
+
+        MMU_InvalidatePageTableCache(psMMUHeap->psMMUContext->psDevInfo);
+
+#if defined(PDUMP)
+        MMU_PDumpPageTables (psMMUHeap, sDevVAddr, uPageSize*ui32PageCount, IMG_TRUE, hUniqueTag);
+#endif 
+}
+
+
+IMG_DEV_PHYADDR
+MMU_GetPhysPageAddr(MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR sDevVPageAddr)
+{
+        IMG_UINT32 *pui32PageTable;
+        IMG_UINT32 ui32Index;
+        IMG_DEV_PHYADDR sDevPAddr;
+        MMU_PT_INFO **ppsPTInfoList;
+
+        
+        ui32Index = sDevVPageAddr.uiAddr >> pMMUHeap->ui32PDShift;
+
+        
+        ppsPTInfoList = &pMMUHeap->psMMUContext->apsPTInfoList[ui32Index];
+        if (!ppsPTInfoList[0])
+        {
+                PVR_DPF((PVR_DBG_ERROR,"MMU_GetPhysPageAddr: Not mapped in at 0x%08x", sDevVPageAddr.uiAddr));
+                sDevPAddr.uiAddr = 0;
+                return sDevPAddr;
+        }
+
+        
+        ui32Index = (sDevVPageAddr.uiAddr & pMMUHeap->ui32PTMask) >> pMMUHeap->ui32PTShift;
+
+        
+        pui32PageTable = (IMG_UINT32*)ppsPTInfoList[0]->PTPageCpuVAddr;
+
+        
+        sDevPAddr.uiAddr = pui32PageTable[ui32Index];
+
+        
+        sDevPAddr.uiAddr &= ~(pMMUHeap->ui32DataPageMask>>SGX_MMU_PTE_ADDR_ALIGNSHIFT);
+
+        
+        sDevPAddr.uiAddr <<= SGX_MMU_PTE_ADDR_ALIGNSHIFT;
+
+        return sDevPAddr;
+}
+
+
+IMG_DEV_PHYADDR MMU_GetPDDevPAddr(MMU_CONTEXT *pMMUContext)
+{
+        return (pMMUContext->sPDDevPAddr);
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR SGXGetPhysPageAddrKM (IMG_HANDLE hDevMemHeap,
+                                                                   IMG_DEV_VIRTADDR sDevVAddr,
+                                                                   IMG_DEV_PHYADDR *pDevPAddr,
+                                                                   IMG_CPU_PHYADDR *pCpuPAddr)
+{
+        MMU_HEAP *pMMUHeap;
+        IMG_DEV_PHYADDR DevPAddr;
+
+        
+
+        pMMUHeap = (MMU_HEAP*)BM_GetMMUHeap(hDevMemHeap);
+
+        DevPAddr = MMU_GetPhysPageAddr(pMMUHeap, sDevVAddr);
+        pCpuPAddr->uiAddr = DevPAddr.uiAddr; 
+        pDevPAddr->uiAddr = DevPAddr.uiAddr;
+
+        return (pDevPAddr->uiAddr != 0) ? PVRSRV_OK : PVRSRV_ERROR_INVALID_PARAMS;
+}
+
+
+PVRSRV_ERROR SGXGetMMUPDAddrKM(IMG_HANDLE               hDevCookie,
+                                                                IMG_HANDLE              hDevMemContext,
+                                                                IMG_DEV_PHYADDR *psPDDevPAddr)
+{
+        if (!hDevCookie || !hDevMemContext || !psPDDevPAddr)
+        {
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        
+        *psPDDevPAddr = ((BM_CONTEXT*)hDevMemContext)->psMMUContext->sPDDevPAddr;
+
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR MMU_BIFResetPDAlloc(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        PVRSRV_ERROR eError;
+        SYS_DATA *psSysData;
+        RA_ARENA *psLocalDevMemArena;
+        IMG_HANDLE hOSMemHandle = IMG_NULL;
+        IMG_BYTE *pui8MemBlock = IMG_NULL;
+        IMG_SYS_PHYADDR sMemBlockSysPAddr;
+        IMG_CPU_PHYADDR sMemBlockCpuPAddr;
+
+        SysAcquireData(&psSysData);
+
+        psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                
+                eError = OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                      3 * SGX_MMU_PAGE_SIZE,
+                                                      SGX_MMU_PAGE_SIZE,
+                                                      (IMG_VOID **)&pui8MemBlock,
+                                                      &hOSMemHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_BIFResetPDAlloc: ERROR call to OSAllocPages failed"));
+                        return eError;
+                }
+
+                
+                if(pui8MemBlock)
+                {
+                        sMemBlockCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle,
+                                                                                                  pui8MemBlock);
+                }
+                else
+                {
+                        
+                        sMemBlockCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, 0);
+                }
+        }
+        else
+        {
+                
+
+                if(RA_Alloc(psLocalDevMemArena,
+                                        3 * SGX_MMU_PAGE_SIZE,
+                                        IMG_NULL,
+                                        IMG_NULL,
+                                        0,
+                                        SGX_MMU_PAGE_SIZE,
+                                        0,
+                                        &(sMemBlockSysPAddr.uiAddr)) != IMG_TRUE)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_BIFResetPDAlloc: ERROR call to RA_Alloc failed"));
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+
+                
+                sMemBlockCpuPAddr = SysSysPAddrToCpuPAddr(sMemBlockSysPAddr);
+                pui8MemBlock = OSMapPhysToLin(sMemBlockCpuPAddr,
+                                                                          SGX_MMU_PAGE_SIZE * 3,
+                                                                          PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                          &hOSMemHandle);
+                if(!pui8MemBlock)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_BIFResetPDAlloc: ERROR failed to map page tables"));
+                        return PVRSRV_ERROR_BAD_MAPPING;
+                }
+        }
+
+        psDevInfo->hBIFResetPDOSMemHandle = hOSMemHandle;
+        psDevInfo->sBIFResetPDDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sMemBlockCpuPAddr);
+        psDevInfo->sBIFResetPTDevPAddr.uiAddr = psDevInfo->sBIFResetPDDevPAddr.uiAddr + SGX_MMU_PAGE_SIZE;
+        psDevInfo->sBIFResetPageDevPAddr.uiAddr = psDevInfo->sBIFResetPTDevPAddr.uiAddr + SGX_MMU_PAGE_SIZE;
+        
+        
+        psDevInfo->pui32BIFResetPD = (IMG_UINT32 *)pui8MemBlock;
+        psDevInfo->pui32BIFResetPT = (IMG_UINT32 *)(pui8MemBlock + SGX_MMU_PAGE_SIZE);
+
+        
+        OSMemSet(psDevInfo->pui32BIFResetPD, 0, SGX_MMU_PAGE_SIZE);
+        OSMemSet(psDevInfo->pui32BIFResetPT, 0, SGX_MMU_PAGE_SIZE);
+        
+        OSMemSet(pui8MemBlock + (2 * SGX_MMU_PAGE_SIZE), 0xDB, SGX_MMU_PAGE_SIZE);
+
+        return PVRSRV_OK;
+}
+
+IMG_VOID MMU_BIFResetPDFree(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        SYS_DATA *psSysData;
+        RA_ARENA *psLocalDevMemArena;
+        IMG_SYS_PHYADDR sPDSysPAddr;
+
+        SysAcquireData(&psSysData);
+
+        psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                        3 * SGX_MMU_PAGE_SIZE,
+                                        psDevInfo->pui32BIFResetPD,
+                                        psDevInfo->hBIFResetPDOSMemHandle);
+        }
+        else
+        {
+                OSUnMapPhysToLin(psDevInfo->pui32BIFResetPD,
+                         3 * SGX_MMU_PAGE_SIZE,
+                         PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                         psDevInfo->hBIFResetPDOSMemHandle);
+
+                sPDSysPAddr = SysDevPAddrToSysPAddr(PVRSRV_DEVICE_TYPE_SGX, psDevInfo->sBIFResetPDDevPAddr);
+                RA_Free(psLocalDevMemArena, sPDSysPAddr.uiAddr, IMG_FALSE);
+        }
+}
+
+
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
+PVRSRV_ERROR WorkaroundBRN22997Alloc(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR eError;
+        SYS_DATA *psSysData;
+        RA_ARENA *psLocalDevMemArena;
+        IMG_HANDLE hPTPageOSMemHandle = IMG_NULL;
+        IMG_HANDLE hPDPageOSMemHandle = IMG_NULL;
+        IMG_UINT32 *pui32PD = IMG_NULL;
+        IMG_UINT32 *pui32PT = IMG_NULL;
+        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);
+
+        psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                
+                eError = OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   (IMG_VOID **)&pui32PT,
+                                                   &hPTPageOSMemHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        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,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   (IMG_VOID **)&pui32PD,
+                                                   &hPDPageOSMemHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "WorkaroundBRN22997: ERROR call to OSAllocPages failed"));
+                        return eError;
+                }
+                ui32PDOffset = 0;
+
+                
+                if(pui32PT)
+        {
+            sCpuPAddr = OSMapLinToCPUPhys(hPTPageOSMemHandle,
+                                                                                  pui32PT);
+        }
+        else
+        {
+            
+            sCpuPAddr = OSMemHandleToCpuPAddr(hPTPageOSMemHandle, 0);
+        }
+                sPTDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+                if(pui32PD)
+        {
+            sCpuPAddr = OSMapLinToCPUPhys(hPDPageOSMemHandle,
+                                                                                  pui32PD);
+        }
+        else
+        {
+            
+            sCpuPAddr = OSMemHandleToCpuPAddr(hPDPageOSMemHandle, 0);
+        }
+                sPDDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+        }
+        else
+        {
+                
+
+                if(RA_Alloc(psLocalDevMemArena,
+                                        SGX_MMU_PAGE_SIZE * 2,
+                                        IMG_NULL,
+                                        IMG_NULL,
+                                        0,
+                                        SGX_MMU_PAGE_SIZE,
+                                        0,
+                                        &(psDevInfo->sBRN22997SysPAddr.uiAddr))!= IMG_TRUE)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "WorkaroundBRN22997: ERROR call to RA_Alloc failed"));
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+
+                
+                sCpuPAddr = SysSysPAddrToCpuPAddr(psDevInfo->sBRN22997SysPAddr);
+                pui32PT = OSMapPhysToLin(sCpuPAddr,
+                                                                SGX_MMU_PAGE_SIZE * 2,
+                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                &hPTPageOSMemHandle);
+                if(!pui32PT)
+                {
+                        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 + 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(&psDeviceNode->sDevId, hPDPageOSMemHandle, ui32PDOffset, pui32PD, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
+        PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevId, hPTPageOSMemHandle, ui32PTOffset, pui32PT, SGX_MMU_PAGE_SIZE, 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;
+        psDevInfo->sBRN22997PTDevPAddr = sPTDevPAddr;
+        psDevInfo->sBRN22997PDDevPAddr = sPDDevPAddr;
+        psDevInfo->pui32BRN22997PD = pui32PD;
+        psDevInfo->pui32BRN22997PT = pui32PT;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_VOID WorkaroundBRN22997ReadHostPort(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        IMG_UINT32 *pui32PD = psDevInfo->pui32BRN22997PD;
+        IMG_UINT32 *pui32PT = psDevInfo->pui32BRN22997PT;
+        IMG_UINT32 ui32PDIndex;
+        IMG_UINT32 ui32PTIndex;
+        IMG_DEV_VIRTADDR sDevVAddr;
+        volatile IMG_UINT32 *pui32HostPort;
+        IMG_UINT32 ui32BIFCtrl;
+
+        
+        
+        
+        pui32HostPort = (volatile IMG_UINT32*)(((IMG_UINT8*)psDevInfo->pvHostPortBaseKM) + SYS_SGX_HOSTPORT_BRN23030_OFFSET);
+
+        
+        sDevVAddr.uiAddr = SYS_SGX_HOSTPORT_BASE_DEVVADDR + SYS_SGX_HOSTPORT_BRN23030_OFFSET;
+
+        ui32PDIndex = (sDevVAddr.uiAddr & SGX_MMU_PD_MASK) >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
+        ui32PTIndex = (sDevVAddr.uiAddr & SGX_MMU_PT_MASK) >> SGX_MMU_PAGE_SHIFT;
+
+        
+        pui32PD[ui32PDIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT)
+                                                        | SGX_MMU_PDE_VALID;
+        
+        pui32PT[ui32PTIndex] = (psDevInfo->sBRN22997PTDevPAddr.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                        | SGX_MMU_PTE_VALID;
+
+        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(&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(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl);
+        PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl);
+
+        
+        if (pui32HostPort)
+        {
+                 
+                IMG_UINT32 ui32Tmp;
+                ui32Tmp = *pui32HostPort;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_ERROR,"Host Port not present for BRN22997 workaround"));
+        }
+
+        
+
+
+
+
+        
+        PDUMPCOMMENT("RDW :SGXMEM:v4:%08X\r\n", sDevVAddr.uiAddr);
+        
+    PDUMPCOMMENT("SAB :SGXMEM:v4:%08X 4 0 hostport.bin", sDevVAddr.uiAddr);
+
+        
+        pui32PD[ui32PDIndex] = 0;
+        pui32PT[ui32PTIndex] = 0;
+
+        
+        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(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl | EUR_CR_BIF_CTRL_INVALDC_MASK);
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32BIFCtrl);
+        PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32BIFCtrl);
+}
+
+
+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(&psDeviceNode->sDevId, psDevInfo->hBRN22997PDPageOSMemHandle, psDevInfo->pui32BRN22997PD, SGX_MMU_PAGE_SIZE, PDUMP_PD_UNIQUETAG);
+        PDUMPFREEPAGETABLE(&psDeviceNode->sDevId, psDevInfo->hBRN22997PTPageOSMemHandle, psDevInfo->pui32BRN22997PT, SGX_MMU_PAGE_SIZE, PDUMP_PT_UNIQUETAG);
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                if (psDevInfo->pui32BRN22997PD != IMG_NULL)
+                {
+                        OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                  SGX_MMU_PAGE_SIZE,
+                                                  psDevInfo->pui32BRN22997PD,
+                                                  psDevInfo->hBRN22997PDPageOSMemHandle);
+                }
+
+                if (psDevInfo->pui32BRN22997PT != IMG_NULL)
+                {
+                        OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                  SGX_MMU_PAGE_SIZE,
+                                                  psDevInfo->pui32BRN22997PT,
+                                                  psDevInfo->hBRN22997PTPageOSMemHandle);
+                }
+        }
+        else
+        {
+                if (psDevInfo->pui32BRN22997PT != IMG_NULL)
+                {
+                        OSUnMapPhysToLin(psDevInfo->pui32BRN22997PT,
+                                 SGX_MMU_PAGE_SIZE * 2,
+                                 PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                 psDevInfo->hBRN22997PTPageOSMemHandle);
+
+
+                        RA_Free(psLocalDevMemArena, psDevInfo->sBRN22997SysPAddr.uiAddr, IMG_FALSE);
+                }
+        }
+}
+#endif 
+
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+PVRSRV_ERROR MMU_MapExtSystemCacheRegs(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR eError;
+        SYS_DATA *psSysData;
+        RA_ARENA *psLocalDevMemArena;
+        IMG_HANDLE hPTPageOSMemHandle = IMG_NULL;
+        IMG_UINT32 *pui32PD;
+        IMG_UINT32 *pui32PT = IMG_NULL;
+        IMG_CPU_PHYADDR sCpuPAddr;
+        IMG_DEV_PHYADDR sPTDevPAddr;
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+        IMG_UINT32 ui32PDIndex;
+        IMG_UINT32 ui32PTIndex;
+
+        psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+        pui32PD = (IMG_UINT32*)psDeviceNode->sDevMemoryInfo.pBMKernelContext->psMMUContext->pvPDCpuVAddr;
+
+        SysAcquireData(&psSysData);
+
+        psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                
+                eError = OSAllocPages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   SGX_MMU_PAGE_SIZE,
+                                                   (IMG_VOID **)&pui32PT,
+                                                   &hPTPageOSMemHandle);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_MapExtSystemCacheRegs: ERROR call to OSAllocPages failed"));
+                        return eError;
+                }
+
+                
+                if(pui32PT)
+        {
+            sCpuPAddr = OSMapLinToCPUPhys(hPTPageOSMemHandle,
+                                                                                  pui32PT);
+        }
+        else
+        {
+            
+            sCpuPAddr = OSMemHandleToCpuPAddr(hPTPageOSMemHandle, 0);
+        }
+                sPTDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+        }
+        else
+        {
+                IMG_SYS_PHYADDR sSysPAddr;
+
+                
+                if(RA_Alloc(psLocalDevMemArena,
+                                        SGX_MMU_PAGE_SIZE,
+                                        IMG_NULL,
+                                        IMG_NULL,
+                                        0,
+                                        SGX_MMU_PAGE_SIZE,
+                                        0,
+                                        &(sSysPAddr.uiAddr))!= IMG_TRUE)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_MapExtSystemCacheRegs: ERROR call to RA_Alloc failed"));
+                        return PVRSRV_ERROR_OUT_OF_MEMORY;
+                }
+
+                
+                sCpuPAddr = SysSysPAddrToCpuPAddr(sSysPAddr);
+                pui32PT = OSMapPhysToLin(sCpuPAddr,
+                                                                SGX_MMU_PAGE_SIZE,
+                                PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                                                &hPTPageOSMemHandle);
+                if(!pui32PT)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "MMU_MapExtSystemCacheRegs: ERROR failed to map page tables"));
+                        return PVRSRV_ERROR_BAD_MAPPING;
+                }
+
+                
+                sPTDevPAddr = SysCpuPAddrToDevPAddr(PVRSRV_DEVICE_TYPE_SGX, sCpuPAddr);
+
+                
+                psDevInfo->sExtSystemCacheRegsPTSysPAddr = sSysPAddr;
+        }
+
+        OSMemSet(pui32PT, 0, SGX_MMU_PAGE_SIZE);
+
+        ui32PDIndex = (SGX_EXT_SYSTEM_CACHE_REGS_DEVVADDR_BASE & SGX_MMU_PD_MASK) >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
+        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)
+                                                        | SGX_MMU_PDE_VALID;
+        
+        pui32PT[ui32PTIndex] = (psDevInfo->sExtSysCacheRegsDevPBase.uiAddr>>SGX_MMU_PTE_ADDR_ALIGNSHIFT)
+                                                        | SGX_MMU_PTE_VALID;
+
+        
+        PDUMPMALLOCPAGETABLE(&psDeviceNode->sDevID, hPTPageOSMemHandle, 0, pui32PT, SGX_MMU_PAGE_SIZE, 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;
+        psDevInfo->hExtSystemCacheRegsPTPageOSMemHandle = hPTPageOSMemHandle;
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR MMU_UnmapExtSystemCacheRegs(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        SYS_DATA *psSysData;
+        RA_ARENA *psLocalDevMemArena;
+        PVRSRV_SGXDEV_INFO *psDevInfo;
+        IMG_UINT32 ui32PDIndex;
+        IMG_UINT32 *pui32PD;
+
+        psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+        pui32PD = (IMG_UINT32*)psDeviceNode->sDevMemoryInfo.pBMKernelContext->psMMUContext->pvPDCpuVAddr;
+
+        SysAcquireData(&psSysData);
+
+        psLocalDevMemArena = psSysData->apsLocalDevMemArena[0];
+
+        
+        ui32PDIndex = (SGX_EXT_SYSTEM_CACHE_REGS_DEVVADDR_BASE & SGX_MMU_PD_MASK) >> (SGX_MMU_PAGE_SHIFT + SGX_MMU_PT_SHIFT);
+        pui32PD[ui32PDIndex] = 0;
+
+        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, PDUMP_PT_UNIQUETAG);
+
+        
+        if(psLocalDevMemArena == IMG_NULL)
+        {
+                if (psDevInfo->pui32ExtSystemCacheRegsPT != IMG_NULL)
+                {
+                        OSFreePages(PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_KERNEL_ONLY,
+                                                  SGX_MMU_PAGE_SIZE,
+                                                  psDevInfo->pui32ExtSystemCacheRegsPT,
+                                                  psDevInfo->hExtSystemCacheRegsPTPageOSMemHandle);
+                }
+        }
+        else
+        {
+                if (psDevInfo->pui32ExtSystemCacheRegsPT != IMG_NULL)
+                {
+                        OSUnMapPhysToLin(psDevInfo->pui32ExtSystemCacheRegsPT,
+                                 SGX_MMU_PAGE_SIZE,
+                                 PVRSRV_HAP_WRITECOMBINE|PVRSRV_HAP_KERNEL_ONLY,
+                                 psDevInfo->hExtSystemCacheRegsPTPageOSMemHandle);
+
+                        RA_Free(psLocalDevMemArena, psDevInfo->sExtSystemCacheRegsPTSysPAddr.uiAddr, IMG_FALSE);
+                }
+        }
+
+        return PVRSRV_OK;
+}
+#endif
+
+
+#if PAGE_TEST
+static IMG_VOID PageTest(IMG_VOID* pMem, IMG_DEV_PHYADDR sDevPAddr)
+{
+        volatile IMG_UINT32 ui32WriteData;
+        volatile IMG_UINT32 ui32ReadData;
+        volatile IMG_UINT32 *pMem32 = (volatile IMG_UINT32 *)pMem;
+        IMG_INT n;
+        IMG_BOOL bOK=IMG_TRUE;
+
+        ui32WriteData = 0xffffffff;
+
+        for (n=0; n<1024; n++)
+        {
+                pMem32[n] = ui32WriteData;
+                ui32ReadData = pMem32[n];
+
+                if (ui32WriteData != ui32ReadData)
+                {
+                        
+                        PVR_DPF ((PVR_DBG_ERROR, "Error - memory page test failed at device phys address 0x%08X", sDevPAddr.uiAddr + (n<<2) ));
+                        PVR_DBG_BREAK;
+                        bOK = IMG_FALSE;
+                }
+        }
+
+        ui32WriteData = 0;
+
+        for (n=0; n<1024; n++)
+        {
+                pMem32[n] = ui32WriteData;
+                ui32ReadData = pMem32[n];
+
+                if (ui32WriteData != ui32ReadData)
+                {
+                        
+                        PVR_DPF ((PVR_DBG_ERROR, "Error - memory page test failed at device phys address 0x%08X", sDevPAddr.uiAddr + (n<<2) ));
+                        PVR_DBG_BREAK;
+                        bOK = IMG_FALSE;
+                }
+        }
+
+        if (bOK)
+        {
+                PVR_DPF ((PVR_DBG_VERBOSE, "MMU Page 0x%08X is OK", sDevPAddr.uiAddr));
+        }
+        else
+        {
+                PVR_DPF ((PVR_DBG_VERBOSE, "MMU Page 0x%08X *** FAILED ***", sDevPAddr.uiAddr));
+        }
+}
+#endif
+
diff --git a/drivers/gpu/pvr/sgx/mmu.h b/drivers/gpu/pvr/sgx/mmu.h
new file mode 100644
index 00000000000..f13fcc0d2d9
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/mmu.h
@@ -0,0 +1,144 @@
+/**********************************************************************
+ *
+ * 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 _MMU_H_
+#define _MMU_H_
+
+#include "sgxinfokm.h"
+
+PVRSRV_ERROR
+MMU_Initialise (PVRSRV_DEVICE_NODE *psDeviceNode, MMU_CONTEXT **ppsMMUContext, IMG_DEV_PHYADDR *psPDDevPAddr);
+
+IMG_VOID
+MMU_Finalise (MMU_CONTEXT *psMMUContext);
+
+
+IMG_VOID
+MMU_InsertHeap(MMU_CONTEXT *psMMUContext, MMU_HEAP *psMMUHeap);
+
+MMU_HEAP *
+MMU_Create (MMU_CONTEXT *psMMUContext,
+                        DEV_ARENA_DESCRIPTOR *psDevArena,
+                        RA_ARENA **ppsVMArena,
+                        PDUMP_MMU_ATTRIB **ppsMMUAttrib);
+
+IMG_VOID
+MMU_Delete (MMU_HEAP *pMMU);
+
+IMG_BOOL
+MMU_Alloc (MMU_HEAP *pMMU,
+           IMG_SIZE_T uSize,
+           IMG_SIZE_T *pActualSize,
+           IMG_UINT32 uFlags,
+                   IMG_UINT32 uDevVAddrAlignment,
+           IMG_DEV_VIRTADDR *pDevVAddr);
+
+IMG_VOID
+MMU_Free (MMU_HEAP *pMMU,
+          IMG_DEV_VIRTADDR DevVAddr,
+                  IMG_UINT32 ui32Size);
+
+IMG_VOID 
+MMU_Enable (MMU_HEAP *pMMU);
+
+IMG_VOID 
+MMU_Disable (MMU_HEAP *pMMU);
+
+IMG_VOID
+MMU_MapPages (MMU_HEAP *pMMU,
+                          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,
+               IMG_DEV_VIRTADDR    MapBaseDevVAddr,
+               IMG_SIZE_T          uSize, 
+               IMG_CPU_VIRTADDR    CpuVAddr,
+               IMG_HANDLE          hOSMemHandle,
+               IMG_DEV_VIRTADDR  * pDevVAddr,
+               IMG_UINT32          ui32MemFlags,
+               IMG_HANDLE          hUniqueTag);
+
+IMG_VOID
+MMU_UnmapPages (MMU_HEAP *pMMU,
+             IMG_DEV_VIRTADDR dev_vaddr,
+             IMG_UINT32 ui32PageCount,
+             IMG_HANDLE hUniqueTag);
+
+IMG_VOID
+MMU_MapScatter (MMU_HEAP *pMMU,
+                                IMG_DEV_VIRTADDR DevVAddr,
+                                IMG_SYS_PHYADDR *psSysAddr,
+                                IMG_SIZE_T uSize,
+                                IMG_UINT32 ui32MemFlags,
+                                IMG_HANDLE hUniqueTag);
+
+
+IMG_DEV_PHYADDR
+MMU_GetPhysPageAddr(MMU_HEAP *pMMUHeap, IMG_DEV_VIRTADDR sDevVPageAddr);
+
+
+IMG_DEV_PHYADDR
+MMU_GetPDDevPAddr(MMU_CONTEXT *pMMUContext);
+
+
+#ifdef SUPPORT_SGX_MMU_BYPASS
+IMG_VOID
+EnableHostAccess (MMU_CONTEXT *psMMUContext);
+
+
+IMG_VOID
+DisableHostAccess (MMU_CONTEXT *psMMUContext);
+#endif
+
+IMG_VOID MMU_InvalidateDirectoryCache(PVRSRV_SGXDEV_INFO *psDevInfo);
+
+PVRSRV_ERROR MMU_BIFResetPDAlloc(PVRSRV_SGXDEV_INFO *psDevInfo);
+
+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_DEVICE_NODE *psDeviceNode);
+
+IMG_VOID WorkaroundBRN22997ReadHostPort(PVRSRV_SGXDEV_INFO *psDevInfo);
+
+IMG_VOID WorkaroundBRN22997Free(PVRSRV_DEVICE_NODE *psDeviceNode);
+#endif 
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+PVRSRV_ERROR MMU_MapExtSystemCacheRegs(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+PVRSRV_ERROR MMU_UnmapExtSystemCacheRegs(PVRSRV_DEVICE_NODE *psDeviceNode);
+#endif 
+
+#if defined(PDUMP)
+IMG_UINT32 MMU_GetPDumpContextID(IMG_HANDLE hDevMemContext);
+#endif 
+
+#endif 
diff --git a/drivers/gpu/pvr/sgx/pb.c b/drivers/gpu/pvr/sgx/pb.c
new file mode 100644
index 00000000000..f9e8b19a70a
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/pb.c
@@ -0,0 +1,459 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "services_headers.h"
+#include "sgx_bridge_km.h"
+#include "sgxapi_km.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#include "pvr_bridge_km.h"
+#include "pdump_km.h"
+#include "sgxutils.h"
+
+#ifndef __linux__
+#pragma message("TODO: Review use of OS_PAGEABLE vs OS_NON_PAGEABLE")
+#endif
+
+#include "lists.h"
+
+static IMPLEMENT_LIST_INSERT(PVRSRV_STUB_PBDESC)
+static IMPLEMENT_LIST_REMOVE(PVRSRV_STUB_PBDESC)
+
+static PRESMAN_ITEM psResItemCreateSharedPB = IMG_NULL;
+static PVRSRV_PER_PROCESS_DATA *psPerProcCreateSharedPB = IMG_NULL;
+
+static PVRSRV_ERROR SGXCleanupSharedPBDescCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param);
+static PVRSRV_ERROR SGXCleanupSharedPBDescCreateLockCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param);
+
+IMG_EXPORT PVRSRV_ERROR
+SGXFindSharedPBDescKM(PVRSRV_PER_PROCESS_DATA   *psPerProc,
+                                          IMG_HANDLE                            hDevCookie,
+                                          IMG_BOOL                              bLockOnFailure,
+                                          IMG_UINT32                            ui32TotalPBSize,
+                                          IMG_HANDLE                            *phSharedPBDesc,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsSharedPBDescKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsHWPBDescKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsBlockKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsHWBlockKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        ***pppsSharedPBDescSubKernelMemInfos,
+                                          IMG_UINT32                            *ui32SharedPBDescSubKernelMemInfosCount)
+{
+        PVRSRV_STUB_PBDESC *psStubPBDesc;
+        PVRSRV_KERNEL_MEM_INFO **ppsSharedPBDescSubKernelMemInfos=IMG_NULL;
+        PVRSRV_SGXDEV_INFO *psSGXDevInfo;
+        PVRSRV_ERROR eError;
+
+        psSGXDevInfo = ((PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
+
+        psStubPBDesc = psSGXDevInfo->psStubPBDescListKM;
+        if (psStubPBDesc != IMG_NULL)
+        {
+                IMG_UINT32 i;
+                PRESMAN_ITEM psResItem;
+
+                if(psStubPBDesc->ui32TotalPBSize != ui32TotalPBSize)
+                {
+                        PVR_DPF((PVR_DBG_WARNING,
+                                        "SGXFindSharedPBDescKM: Shared PB requested with different size (0x%x) from existing shared PB (0x%x) - requested size ignored",
+                                        ui32TotalPBSize, psStubPBDesc->ui32TotalPBSize));
+                }
+
+                if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                          sizeof(PVRSRV_KERNEL_MEM_INFO *)
+                                                * psStubPBDesc->ui32SubKernelMemInfosCount,
+                                          (IMG_VOID **)&ppsSharedPBDescSubKernelMemInfos,
+                                          IMG_NULL,
+                                          "Array of Kernel Memory Info") != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: OSAllocMem failed"));
+
+                        eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+                        goto ExitNotFound;
+                }
+
+                psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                          RESMAN_TYPE_SHARED_PB_DESC,
+                                                                          psStubPBDesc,
+                                                                          0,
+                                                                          &SGXCleanupSharedPBDescCallback);
+
+                if (psResItem == IMG_NULL)
+                {
+                        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                          sizeof(PVRSRV_KERNEL_MEM_INFO *) * psStubPBDesc->ui32SubKernelMemInfosCount,
+                                          ppsSharedPBDescSubKernelMemInfos,
+                                          0);
+                        
+
+                        PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: ResManRegisterRes failed"));
+
+                        eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
+                        goto ExitNotFound;
+                }
+
+                *ppsSharedPBDescKernelMemInfo = psStubPBDesc->psSharedPBDescKernelMemInfo;
+                *ppsHWPBDescKernelMemInfo = psStubPBDesc->psHWPBDescKernelMemInfo;
+                *ppsBlockKernelMemInfo = psStubPBDesc->psBlockKernelMemInfo;
+                *ppsHWBlockKernelMemInfo = psStubPBDesc->psHWBlockKernelMemInfo;
+
+                *ui32SharedPBDescSubKernelMemInfosCount =
+                        psStubPBDesc->ui32SubKernelMemInfosCount;
+
+                *pppsSharedPBDescSubKernelMemInfos = ppsSharedPBDescSubKernelMemInfos;
+
+                for(i=0; i<psStubPBDesc->ui32SubKernelMemInfosCount; i++)
+                {
+                        ppsSharedPBDescSubKernelMemInfos[i] =
+                                psStubPBDesc->ppsSubKernelMemInfos[i];
+                }
+
+                psStubPBDesc->ui32RefCount++;
+                *phSharedPBDesc = (IMG_HANDLE)psResItem;
+                return PVRSRV_OK;
+        }
+
+        eError = PVRSRV_OK;
+        if (bLockOnFailure)
+        {
+                if (psResItemCreateSharedPB == IMG_NULL)
+                {
+                        psResItemCreateSharedPB = ResManRegisterRes(psPerProc->hResManContext,
+                                  RESMAN_TYPE_SHARED_PB_DESC_CREATE_LOCK,
+                                  psPerProc,
+                                  0,
+                                  &SGXCleanupSharedPBDescCreateLockCallback);
+
+                        if (psResItemCreateSharedPB == IMG_NULL)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "SGXFindSharedPBDescKM: ResManRegisterRes failed"));
+
+                                eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
+                                goto ExitNotFound;
+                        }
+                        PVR_ASSERT(psPerProcCreateSharedPB == IMG_NULL);
+                        psPerProcCreateSharedPB = psPerProc;
+                }
+                else
+                {
+                         eError = PVRSRV_ERROR_PROCESSING_BLOCKED;
+                }
+        }
+ExitNotFound:
+        *phSharedPBDesc = IMG_NULL;
+
+        return eError;
+}
+
+
+static PVRSRV_ERROR
+SGXCleanupSharedPBDescKM(PVRSRV_STUB_PBDESC *psStubPBDescIn)
+{
+        
+        IMG_UINT32 i;
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE*)psStubPBDescIn->hDevCookie;
+
+        
+
+        
+        psStubPBDescIn->ui32RefCount--;
+        if (psStubPBDescIn->ui32RefCount == 0)
+        {
+                List_PVRSRV_STUB_PBDESC_Remove(psStubPBDescIn);
+                for(i=0 ; i<psStubPBDescIn->ui32SubKernelMemInfosCount; i++)
+                {
+                        
+                        PVRSRVFreeDeviceMemKM(psStubPBDescIn->hDevCookie,
+                                                                  psStubPBDescIn->ppsSubKernelMemInfos[i]);
+                }
+
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_KERNEL_MEM_INFO *) * psStubPBDescIn->ui32SubKernelMemInfosCount,
+                                  psStubPBDescIn->ppsSubKernelMemInfos,
+                                  0);
+                psStubPBDescIn->ppsSubKernelMemInfos = IMG_NULL;
+
+                PVRSRVFreeSharedSysMemoryKM(psStubPBDescIn->psBlockKernelMemInfo);
+
+                PVRSRVFreeDeviceMemKM(psStubPBDescIn->hDevCookie, psStubPBDescIn->psHWBlockKernelMemInfo);
+
+                PVRSRVFreeDeviceMemKM(psStubPBDescIn->hDevCookie, psStubPBDescIn->psHWPBDescKernelMemInfo);
+
+                PVRSRVFreeSharedSysMemoryKM(psStubPBDescIn->psSharedPBDescKernelMemInfo);
+
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_STUB_PBDESC),
+                                  psStubPBDescIn,
+                                  0);
+                
+
+                
+                SGXCleanupRequest(psDeviceNode,
+                                                  IMG_NULL,
+                                                  PVRSRV_CLEANUPCMD_PB);
+        }
+        return PVRSRV_OK;
+        
+}
+
+static PVRSRV_ERROR SGXCleanupSharedPBDescCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+{
+        PVRSRV_STUB_PBDESC *psStubPBDesc = (PVRSRV_STUB_PBDESC *)pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        return SGXCleanupSharedPBDescKM(psStubPBDesc);
+}
+
+static PVRSRV_ERROR SGXCleanupSharedPBDescCreateLockCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+{
+#ifdef DEBUG
+        PVRSRV_PER_PROCESS_DATA *psPerProc = (PVRSRV_PER_PROCESS_DATA *)pvParam;
+        PVR_ASSERT(psPerProc == psPerProcCreateSharedPB);
+#else
+        PVR_UNREFERENCED_PARAMETER(pvParam);
+#endif
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        psPerProcCreateSharedPB = IMG_NULL;
+        psResItemCreateSharedPB = IMG_NULL;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_EXPORT PVRSRV_ERROR
+SGXUnrefSharedPBDescKM(IMG_HANDLE hSharedPBDesc)
+{
+        PVR_ASSERT(hSharedPBDesc != IMG_NULL);
+
+        return ResManFreeResByPtr(hSharedPBDesc);
+}
+
+
+IMG_EXPORT PVRSRV_ERROR
+SGXAddSharedPBDescKM(PVRSRV_PER_PROCESS_DATA    *psPerProc,
+                                         IMG_HANDLE                                     hDevCookie,
+                                         PVRSRV_KERNEL_MEM_INFO         *psSharedPBDescKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psHWPBDescKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psBlockKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psHWBlockKernelMemInfo,
+                                         IMG_UINT32                                     ui32TotalPBSize,
+                                         IMG_HANDLE                                     *phSharedPBDesc,
+                                         PVRSRV_KERNEL_MEM_INFO         **ppsSharedPBDescSubKernelMemInfos,
+                                         IMG_UINT32                                     ui32SharedPBDescSubKernelMemInfosCount)
+{
+        PVRSRV_STUB_PBDESC *psStubPBDesc=IMG_NULL;
+        PVRSRV_ERROR eRet = PVRSRV_ERROR_INVALID_PERPROC;
+        IMG_UINT32 i;
+        PVRSRV_SGXDEV_INFO *psSGXDevInfo;
+        PRESMAN_ITEM psResItem;
+
+        
+        if (psPerProcCreateSharedPB != psPerProc)
+        {
+                goto NoAdd;
+        }
+        else
+        {
+                PVR_ASSERT(psResItemCreateSharedPB != IMG_NULL);
+
+                ResManFreeResByPtr(psResItemCreateSharedPB);
+
+                PVR_ASSERT(psResItemCreateSharedPB == IMG_NULL);
+                PVR_ASSERT(psPerProcCreateSharedPB == IMG_NULL);
+        }
+
+        psSGXDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
+
+        psStubPBDesc = psSGXDevInfo->psStubPBDescListKM;
+        if (psStubPBDesc != IMG_NULL)
+        {
+                if(psStubPBDesc->ui32TotalPBSize != ui32TotalPBSize)
+                {
+                        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));
+
+                }
+
+                
+                psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                          RESMAN_TYPE_SHARED_PB_DESC,
+                                                                          psStubPBDesc,
+                                                                          0,
+                                                                          &SGXCleanupSharedPBDescCallback);
+                if (psResItem == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,
+                                "SGXAddSharedPBDescKM: "
+                                "Failed to register existing shared "
+                                "PBDesc with the resource manager"));
+                        goto NoAddKeepPB;
+                }
+
+                
+                psStubPBDesc->ui32RefCount++;
+
+                *phSharedPBDesc = (IMG_HANDLE)psResItem;
+                eRet = PVRSRV_OK;
+                goto NoAddKeepPB;
+        }
+
+        if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_STUB_PBDESC),
+                                  (IMG_VOID **)&psStubPBDesc,
+                                  0,
+                                  "Stub Parameter Buffer Description") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: Failed to alloc "
+                                        "StubPBDesc"));
+                eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto NoAdd;
+        }
+
+
+        psStubPBDesc->ppsSubKernelMemInfos = IMG_NULL;
+
+        if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_KERNEL_MEM_INFO *)
+                                  * ui32SharedPBDescSubKernelMemInfosCount,
+                                  (IMG_VOID **)&psStubPBDesc->ppsSubKernelMemInfos,
+                                  0,
+                                  "Array of Kernel Memory Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
+                                 "Failed to alloc "
+                                 "StubPBDesc->ppsSubKernelMemInfos"));
+                eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
+                goto NoAdd;
+        }
+
+        if(PVRSRVDissociateMemFromResmanKM(psSharedPBDescKernelMemInfo)
+           != PVRSRV_OK)
+        {
+                goto NoAdd;
+        }
+
+        if(PVRSRVDissociateMemFromResmanKM(psHWPBDescKernelMemInfo)
+           != PVRSRV_OK)
+        {
+                goto NoAdd;
+        }
+
+        if(PVRSRVDissociateMemFromResmanKM(psBlockKernelMemInfo)
+           != PVRSRV_OK)
+        {
+                goto NoAdd;
+        }
+
+        if(PVRSRVDissociateMemFromResmanKM(psHWBlockKernelMemInfo)
+           != PVRSRV_OK)
+        {
+                goto NoAdd;
+        }
+
+        psStubPBDesc->ui32RefCount = 1;
+        psStubPBDesc->ui32TotalPBSize = ui32TotalPBSize;
+        psStubPBDesc->psSharedPBDescKernelMemInfo = psSharedPBDescKernelMemInfo;
+        psStubPBDesc->psHWPBDescKernelMemInfo = psHWPBDescKernelMemInfo;
+        psStubPBDesc->psBlockKernelMemInfo = psBlockKernelMemInfo;
+        psStubPBDesc->psHWBlockKernelMemInfo = psHWBlockKernelMemInfo;
+
+        psStubPBDesc->ui32SubKernelMemInfosCount =
+                ui32SharedPBDescSubKernelMemInfosCount;
+        for(i=0; i<ui32SharedPBDescSubKernelMemInfosCount; i++)
+        {
+                psStubPBDesc->ppsSubKernelMemInfos[i] = ppsSharedPBDescSubKernelMemInfos[i];
+                if(PVRSRVDissociateMemFromResmanKM(ppsSharedPBDescSubKernelMemInfos[i])
+                   != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
+                                         "Failed to dissociate shared PBDesc "
+                                         "from process"));
+                        goto NoAdd;
+                }
+        }
+
+        psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                  RESMAN_TYPE_SHARED_PB_DESC,
+                                                                  psStubPBDesc,
+                                                                  0,
+                                                                  &SGXCleanupSharedPBDescCallback);
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
+                                         "Failed to register shared PBDesc "
+                                         " with the resource manager"));
+                goto NoAdd;
+        }
+        psStubPBDesc->hDevCookie = hDevCookie;
+
+        
+        List_PVRSRV_STUB_PBDESC_Insert(&(psSGXDevInfo->psStubPBDescListKM),
+                                                                        psStubPBDesc);
+
+        *phSharedPBDesc = (IMG_HANDLE)psResItem;
+
+        return PVRSRV_OK;
+
+NoAdd:
+        if(psStubPBDesc)
+        {
+                if(psStubPBDesc->ppsSubKernelMemInfos)
+                {
+                        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                          sizeof(PVRSRV_KERNEL_MEM_INFO *) * ui32SharedPBDescSubKernelMemInfosCount,
+                                          psStubPBDesc->ppsSubKernelMemInfos,
+                                          0);
+                        psStubPBDesc->ppsSubKernelMemInfos = IMG_NULL;
+                }
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                  sizeof(PVRSRV_STUB_PBDESC),
+                                  psStubPBDesc,
+                                  0);
+                
+        }
+
+NoAddKeepPB:
+        for (i = 0; i < ui32SharedPBDescSubKernelMemInfosCount; i++)
+        {
+                PVRSRVFreeDeviceMemKM(hDevCookie, ppsSharedPBDescSubKernelMemInfos[i]);
+        }
+
+        PVRSRVFreeSharedSysMemoryKM(psSharedPBDescKernelMemInfo);
+        PVRSRVFreeDeviceMemKM(hDevCookie, psHWPBDescKernelMemInfo);
+
+        PVRSRVFreeSharedSysMemoryKM(psBlockKernelMemInfo);
+        PVRSRVFreeDeviceMemKM(hDevCookie, psHWBlockKernelMemInfo);
+
+        return eRet;
+}
+
diff --git a/drivers/gpu/pvr/sgx/sgx_bridge_km.h b/drivers/gpu/pvr/sgx/sgx_bridge_km.h
new file mode 100644
index 00000000000..7738be13f38
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgx_bridge_km.h
@@ -0,0 +1,134 @@
+/**********************************************************************
+ *
+ * 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(__SGX_BRIDGE_KM_H__)
+#define __SGX_BRIDGE_KM_H__
+
+#include "sgxapi_km.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#include "sgx_bridge.h"
+#include "pvr_bridge.h"
+#include "perproc.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR SGXSubmitTransferKM(IMG_HANDLE hDevHandle, PVRSRV_TRANSFER_SGX_KICK *psKick);
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+IMG_IMPORT
+PVRSRV_ERROR SGXSubmit2DKM(IMG_HANDLE hDevHandle, PVRSRV_2D_SGX_KICK *psKick);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR SGXDoKickKM(IMG_HANDLE hDevHandle,
+                                                 SGX_CCB_KICK *psCCBKick);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXGetPhysPageAddrKM(IMG_HANDLE hDevMemHeap,
+                                                                  IMG_DEV_VIRTADDR sDevVAddr,
+                                                                  IMG_DEV_PHYADDR *pDevPAddr,
+                                                                  IMG_CPU_PHYADDR *pCpuPAddr);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV SGXGetMMUPDAddrKM(IMG_HANDLE          hDevCookie,
+                                                                                        IMG_HANDLE              hDevMemContext,
+                                                                                        IMG_DEV_PHYADDR *psPDDevPAddr);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXGetClientInfoKM(IMG_HANDLE                              hDevCookie,
+                                                                SGX_CLIENT_INFO*        psClientInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXGetMiscInfoKM(PVRSRV_SGXDEV_INFO        *psDevInfo,
+                                                          SGX_MISC_INFO                 *psMiscInfo,
+                                                          PVRSRV_DEVICE_NODE    *psDeviceNode,
+                                                          IMG_HANDLE                     hDevMemContext);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXReadHWPerfCBKM(IMG_HANDLE                                       hDevHandle,
+                                                           IMG_UINT32                                   ui32ArraySize,
+                                                           PVRSRV_SGX_HWPERF_CB_ENTRY   *psHWPerfCBData,
+                                                           IMG_UINT32                                   *pui32DataCount,
+                                                           IMG_UINT32                                   *pui32ClockSpeed,
+                                                           IMG_UINT32                                   *pui32HostTimeStamp);
+
+IMG_IMPORT
+PVRSRV_ERROR SGX2DQueryBlitsCompleteKM(PVRSRV_SGXDEV_INFO               *psDevInfo,
+                                                                           PVRSRV_KERNEL_SYNC_INFO      *psSyncInfo,
+                                                                           IMG_BOOL bWaitForComplete);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXGetInfoForSrvinitKM(IMG_HANDLE hDevHandle,
+                                                                        SGX_BRIDGE_INFO_FOR_SRVINIT *psInitInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR DevInitSGXPart2KM(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                                           IMG_HANDLE hDevHandle,
+                                                           SGX_BRIDGE_INIT_INFO *psInitInfo);
+
+IMG_IMPORT PVRSRV_ERROR
+SGXFindSharedPBDescKM(PVRSRV_PER_PROCESS_DATA   *psPerProc,
+                                          IMG_HANDLE                            hDevCookie,
+                                          IMG_BOOL                              bLockOnFailure,
+                                          IMG_UINT32                            ui32TotalPBSize,
+                                          IMG_HANDLE                            *phSharedPBDesc,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsSharedPBDescKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsHWPBDescKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsBlockKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        **ppsHWBlockKernelMemInfo,
+                                          PVRSRV_KERNEL_MEM_INFO        ***pppsSharedPBDescSubKernelMemInfos,
+                                          IMG_UINT32                            *ui32SharedPBDescSubKernelMemInfosCount);
+
+IMG_IMPORT PVRSRV_ERROR
+SGXUnrefSharedPBDescKM(IMG_HANDLE hSharedPBDesc);
+
+IMG_IMPORT PVRSRV_ERROR
+SGXAddSharedPBDescKM(PVRSRV_PER_PROCESS_DATA    *psPerProc,
+                                         IMG_HANDLE                             hDevCookie,
+                                         PVRSRV_KERNEL_MEM_INFO         *psSharedPBDescKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psHWPBDescKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psBlockKernelMemInfo,
+                                         PVRSRV_KERNEL_MEM_INFO         *psHWBlockKernelMemInfo,
+                                         IMG_UINT32                                     ui32TotalPBSize,
+                                         IMG_HANDLE                                     *phSharedPBDesc,
+                                         PVRSRV_KERNEL_MEM_INFO         **psSharedPBDescSubKernelMemInfos,
+                                         IMG_UINT32                                     ui32SharedPBDescSubKernelMemInfosCount);
+
+
+IMG_IMPORT PVRSRV_ERROR
+SGXGetInternalDevInfoKM(IMG_HANDLE hDevCookie,
+                                                SGX_INTERNAL_DEVINFO *psSGXInternalDevInfo);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx/sgxconfig.h b/drivers/gpu/pvr/sgx/sgxconfig.h
new file mode 100644
index 00000000000..a0ca3e9e864
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxconfig.h
@@ -0,0 +1,227 @@
+/**********************************************************************
+ *
+ * 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 __SGXCONFIG_H__
+#define __SGXCONFIG_H__
+
+#include "sgxdefs.h"
+
+#define DEV_DEVICE_TYPE                 PVRSRV_DEVICE_TYPE_SGX
+#define DEV_DEVICE_CLASS                PVRSRV_DEVICE_CLASS_3D
+
+#define DEV_MAJOR_VERSION               1
+#define DEV_MINOR_VERSION               0
+
+#if SGX_FEATURE_ADDRESS_SPACE_SIZE == 32
+        #if defined(SGX_FEATURE_2D_HARDWARE)
+        #define SGX_2D_HEAP_BASE                                         0x00100000
+        #define SGX_2D_HEAP_SIZE                                        (0x08000000-0x00100000-0x00001000)
+        #else
+                #if defined(FIX_HW_BRN_26915)
+                #define SGX_CGBUFFER_HEAP_BASE                                   0x00100000
+                #define SGX_CGBUFFER_HEAP_SIZE                                  (0x08000000-0x00100000-0x00001000)
+                #endif
+        #endif
+
+        #if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+        #define SGX_GENERAL_MAPPING_HEAP_BASE            0x08000000
+        #define SGX_GENERAL_MAPPING_HEAP_SIZE           (0x08000000-0x00001000)
+        #endif
+
+        #define SGX_GENERAL_HEAP_BASE                            0x10000000
+        #define SGX_GENERAL_HEAP_SIZE                           (0xC2000000-0x00001000)
+
+        #define SGX_3DPARAMETERS_HEAP_BASE                       0xD2000000
+        #define SGX_3DPARAMETERS_HEAP_SIZE                      (0x10000000-0x00001000)
+
+        #define SGX_TADATA_HEAP_BASE                             0xE2000000
+        #define SGX_TADATA_HEAP_SIZE                            (0x0D000000-0x00001000)
+
+        #define SGX_SYNCINFO_HEAP_BASE                           0xEF000000
+        #define SGX_SYNCINFO_HEAP_SIZE                          (0x01000000-0x00001000)
+
+        #define SGX_PDSPIXEL_CODEDATA_HEAP_BASE          0xF0000000
+        #define SGX_PDSPIXEL_CODEDATA_HEAP_SIZE         (0x02000000-0x00001000)
+
+        #define SGX_KERNEL_CODE_HEAP_BASE                        0xF2000000
+        #define SGX_KERNEL_CODE_HEAP_SIZE                       (0x00080000-0x00001000)
+
+        #define SGX_PDSVERTEX_CODEDATA_HEAP_BASE         0xF2400000
+        #define SGX_PDSVERTEX_CODEDATA_HEAP_SIZE        (0x01C00000-0x00001000)
+
+        #define SGX_KERNEL_DATA_HEAP_BASE                        0xF4000000
+        #define SGX_KERNEL_DATA_HEAP_SIZE                       (0x05000000-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
+#endif 
+
+#if SGX_FEATURE_ADDRESS_SPACE_SIZE == 28
+        #if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+        #define SGX_GENERAL_MAPPING_HEAP_BASE            0x00001000
+        #define SGX_GENERAL_MAPPING_HEAP_SIZE           (0x01800000-0x00001000-0x00001000)
+        #endif
+                
+        #define SGX_GENERAL_HEAP_BASE                            0x01800000
+        #define SGX_GENERAL_HEAP_SIZE                           (0x07000000-0x00001000)
+
+        #define SGX_3DPARAMETERS_HEAP_BASE                       0x08800000
+        #define SGX_3DPARAMETERS_HEAP_SIZE                      (0x04000000-0x00001000)
+
+        #define SGX_TADATA_HEAP_BASE                             0x0C800000
+        #define SGX_TADATA_HEAP_SIZE                            (0x01000000-0x00001000)
+
+        #define SGX_SYNCINFO_HEAP_BASE                           0x0D800000
+        #define SGX_SYNCINFO_HEAP_SIZE                          (0x00400000-0x00001000)
+
+        #define SGX_PDSPIXEL_CODEDATA_HEAP_BASE          0x0DC00000
+        #define SGX_PDSPIXEL_CODEDATA_HEAP_SIZE         (0x00800000-0x00001000)
+
+        #define SGX_KERNEL_CODE_HEAP_BASE                        0x0E400000
+        #define SGX_KERNEL_CODE_HEAP_SIZE                       (0x00080000-0x00001000)
+
+        #define SGX_PDSVERTEX_CODEDATA_HEAP_BASE         0x0E800000
+        #define SGX_PDSVERTEX_CODEDATA_HEAP_SIZE        (0x00800000-0x00001000)
+
+        #define SGX_KERNEL_DATA_HEAP_BASE                        0x0F000000
+        #define SGX_KERNEL_DATA_HEAP_SIZE                       (0x00400000-0x00001000)
+
+        #define SGX_PIXELSHADER_HEAP_BASE                        0x0F400000
+        #define SGX_PIXELSHADER_HEAP_SIZE                       (0x00500000-0x00001000)
+
+        #define SGX_VERTEXSHADER_HEAP_BASE                       0x0FC00000
+        #define SGX_VERTEXSHADER_HEAP_SIZE                      (0x00200000-0x00001000)
+
+        
+        #define SGX_CORE_IDENTIFIED
+
+#endif 
+
+#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 
+
diff --git a/drivers/gpu/pvr/sgx/sgxinfokm.h b/drivers/gpu/pvr/sgx/sgxinfokm.h
new file mode 100644
index 00000000000..056db35831d
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxinfokm.h
@@ -0,0 +1,369 @@
+/**********************************************************************
+ *
+ * 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 __SGXINFOKM_H__
+#define __SGXINFOKM_H__
+
+#include "sgxdefs.h"
+#include "device.h"
+#include "power.h"
+#include "sysconfig.h"
+#include "sgxscript.h"
+#include "sgxinfo.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define         SGX_HOSTPORT_PRESENT                    0x00000001UL
+
+
+#define SGX_PDUMPREG_NAME               "SGXREG"
+
+typedef struct _PVRSRV_STUB_PBDESC_ PVRSRV_STUB_PBDESC;
+
+
+typedef struct _PVRSRV_SGX_CCB_INFO_ *PPVRSRV_SGX_CCB_INFO;
+
+typedef struct _PVRSRV_SGXDEV_INFO_
+{
+        PVRSRV_DEVICE_TYPE              eDeviceType;
+        PVRSRV_DEVICE_CLASS             eDeviceClass;
+
+        IMG_UINT8                               ui8VersionMajor;
+        IMG_UINT8                               ui8VersionMinor;
+        IMG_UINT32                              ui32CoreConfig;
+        IMG_UINT32                              ui32CoreFlags;
+
+        
+        IMG_PVOID                               pvRegsBaseKM;
+
+#if defined(SGX_FEATURE_HOST_PORT)
+        
+        IMG_PVOID                               pvHostPortBaseKM;
+        
+        IMG_UINT32                              ui32HPSize;
+        
+        IMG_SYS_PHYADDR                 sHPSysPAddr;
+#endif
+
+        
+        IMG_HANDLE                              hRegMapping;
+
+        
+        IMG_SYS_PHYADDR                 sRegsPhysBase;
+        
+        IMG_UINT32                              ui32RegSize;
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+        
+        IMG_UINT32                              ui32ExtSysCacheRegsSize;
+        
+        IMG_DEV_PHYADDR                 sExtSysCacheRegsDevPBase;
+        
+        IMG_UINT32                              *pui32ExtSystemCacheRegsPT;
+        
+        IMG_HANDLE                              hExtSystemCacheRegsPTPageOSMemHandle;
+        
+        IMG_SYS_PHYADDR                 sExtSystemCacheRegsPTSysPAddr;
+#endif
+
+        
+        IMG_UINT32                              ui32CoreClockSpeed;
+        IMG_UINT32                              ui32uKernelTimerClock;
+
+        PVRSRV_STUB_PBDESC              *psStubPBDescListKM;
+
+
+        
+        IMG_DEV_PHYADDR                 sKernelPDDevPAddr;
+
+        IMG_VOID                                *pvDeviceMemoryHeap;
+        PPVRSRV_KERNEL_MEM_INFO psKernelCCBMemInfo;                     
+        PVRSRV_SGX_KERNEL_CCB   *psKernelCCB;                   
+        PPVRSRV_SGX_CCB_INFO    psKernelCCBInfo;                
+        PPVRSRV_KERNEL_MEM_INFO psKernelCCBCtlMemInfo;  
+        PVRSRV_SGX_CCB_CTL              *psKernelCCBCtl;                
+        PPVRSRV_KERNEL_MEM_INFO psKernelCCBEventKickerMemInfo; 
+        IMG_UINT32                              *pui32KernelCCBEventKicker; 
+#if defined(PDUMP)
+        IMG_UINT32                              ui32KernelCCBEventKickerDumpVal; 
+#endif 
+        PVRSRV_KERNEL_MEM_INFO  *psKernelSGXMiscMemInfo;        
+        IMG_UINT32                              aui32HostKickAddr[SGXMKIF_CMD_MAX];             
+#if defined(SGX_SUPPORT_HWPROFILING)
+        PPVRSRV_KERNEL_MEM_INFO psKernelHWProfilingMemInfo;
+#endif
+        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
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG)
+        PPVRSRV_KERNEL_MEM_INFO psKernelEDMStatusBufferMemInfo; 
+#endif
+#if defined(SGX_FEATURE_OVERLAPPED_SPM)
+        PPVRSRV_KERNEL_MEM_INFO psKernelTmpRgnHeaderMemInfo; 
+#endif
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        PPVRSRV_KERNEL_MEM_INFO psKernelTmpDPMStateMemInfo; 
+#endif
+
+        
+        IMG_UINT32                              ui32ClientRefCount;
+
+        
+        IMG_UINT32                              ui32CacheControl;
+
+        
+        IMG_UINT32                              ui32ClientBuildOptions;
+
+        
+        SGX_MISCINFO_STRUCT_SIZES       sSGXStructSizes;
+
+        
+
+
+        IMG_VOID                                *pvMMUContextList;
+
+        
+        IMG_BOOL                                bForcePTOff;
+
+        IMG_UINT32                              ui32EDMTaskReg0;
+        IMG_UINT32                              ui32EDMTaskReg1;
+
+        IMG_UINT32                              ui32ClkGateStatusReg;
+        IMG_UINT32                              ui32ClkGateStatusMask;
+#if defined(SGX_FEATURE_MP)
+        IMG_UINT32                              ui32MasterClkGateStatusReg;
+        IMG_UINT32                              ui32MasterClkGateStatusMask;
+        IMG_UINT32                              ui32MasterClkGateStatus2Reg;
+        IMG_UINT32                              ui32MasterClkGateStatus2Mask;
+#endif 
+        SGX_INIT_SCRIPTS                sScripts;
+
+        
+        IMG_HANDLE                              hBIFResetPDOSMemHandle;
+        IMG_DEV_PHYADDR                 sBIFResetPDDevPAddr;
+        IMG_DEV_PHYADDR                 sBIFResetPTDevPAddr;
+        IMG_DEV_PHYADDR                 sBIFResetPageDevPAddr;
+        IMG_UINT32                              *pui32BIFResetPD;
+        IMG_UINT32                              *pui32BIFResetPT;
+
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
+        
+        IMG_HANDLE                              hBRN22997PTPageOSMemHandle;
+        IMG_HANDLE                              hBRN22997PDPageOSMemHandle;
+        IMG_DEV_PHYADDR                 sBRN22997PTDevPAddr;
+        IMG_DEV_PHYADDR                 sBRN22997PDDevPAddr;
+        IMG_UINT32                              *pui32BRN22997PT;
+        IMG_UINT32                              *pui32BRN22997PD;
+        IMG_SYS_PHYADDR                 sBRN22997SysPAddr;
+#endif 
+
+#if defined(SUPPORT_HW_RECOVERY)
+        
+        IMG_HANDLE                              hTimer;
+        
+        IMG_UINT32                              ui32TimeStamp;
+#endif
+
+        
+        IMG_UINT32                              ui32NumResets;
+
+        
+        PVRSRV_KERNEL_MEM_INFO                  *psKernelSGXHostCtlMemInfo;
+        SGXMKIF_HOST_CTL                                *psSGXHostCtl;
+
+        
+        PVRSRV_KERNEL_MEM_INFO                  *psKernelSGXTA3DCtlMemInfo;
+
+        IMG_UINT32                              ui32Flags;
+
+        
+        IMG_UINT32                              ui32MemTilingUsage;
+
+        #if defined(PDUMP)
+        PVRSRV_SGX_PDUMP_CONTEXT        sPDContext;
+        #endif
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE)
+        
+        IMG_VOID                                *pvDummyPTPageCpuVAddr;
+        IMG_DEV_PHYADDR                 sDummyPTDevPAddr;
+        IMG_HANDLE                              hDummyPTPageOSMemHandle;
+        IMG_VOID                                *pvDummyDataPageCpuVAddr;
+        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;
+
+
+typedef struct _SGX_TIMING_INFORMATION_
+{
+        IMG_UINT32                      ui32CoreClockSpeed;
+        IMG_UINT32                      ui32HWRecoveryFreq;
+        IMG_BOOL                        bEnableActivePM;
+        IMG_UINT32                      ui32ActivePowManLatencyms;
+        IMG_UINT32                      ui32uKernelFreq;
+} SGX_TIMING_INFORMATION;
+
+typedef struct _SGX_DEVICE_MAP_
+{
+        IMG_UINT32                              ui32Flags;
+
+        
+        IMG_SYS_PHYADDR                 sRegsSysPBase;
+        IMG_CPU_PHYADDR                 sRegsCpuPBase;
+        IMG_CPU_VIRTADDR                pvRegsCpuVBase;
+        IMG_UINT32                              ui32RegsSize;
+
+#if defined(SGX_FEATURE_HOST_PORT)
+        IMG_SYS_PHYADDR                 sHPSysPBase;
+        IMG_CPU_PHYADDR                 sHPCpuPBase;
+        IMG_UINT32                              ui32HPSize;
+#endif
+
+        
+        IMG_SYS_PHYADDR                 sLocalMemSysPBase;
+        IMG_DEV_PHYADDR                 sLocalMemDevPBase;
+        IMG_CPU_PHYADDR                 sLocalMemCpuPBase;
+        IMG_UINT32                              ui32LocalMemSize;
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+        IMG_UINT32                              ui32ExtSysCacheRegsSize;
+        IMG_DEV_PHYADDR                 sExtSysCacheRegsDevPBase;
+#endif
+
+        
+        IMG_UINT32                              ui32IRQ;
+
+#if !defined(SGX_DYNAMIC_TIMING_INFO)
+        
+        SGX_TIMING_INFORMATION  sTimingInfo;
+#endif
+#if defined(PDUMP)
+        
+        IMG_CHAR                                *pszPDumpDevName;
+#endif
+} SGX_DEVICE_MAP;
+
+
+struct _PVRSRV_STUB_PBDESC_
+{
+        IMG_UINT32              ui32RefCount;
+        IMG_UINT32              ui32TotalPBSize;
+        PVRSRV_KERNEL_MEM_INFO  *psSharedPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO  *psHWPBDescKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO  **ppsSubKernelMemInfos;
+        IMG_UINT32              ui32SubKernelMemInfosCount;
+        IMG_HANDLE              hDevCookie;
+        PVRSRV_KERNEL_MEM_INFO  *psBlockKernelMemInfo;
+        PVRSRV_KERNEL_MEM_INFO  *psHWBlockKernelMemInfo;
+        PVRSRV_STUB_PBDESC      *psNext;
+        PVRSRV_STUB_PBDESC      **ppsThis;
+};
+
+typedef struct _PVRSRV_SGX_CCB_INFO_
+{
+        PVRSRV_KERNEL_MEM_INFO  *psCCBMemInfo;                  
+        PVRSRV_KERNEL_MEM_INFO  *psCCBCtlMemInfo;               
+        SGXMKIF_COMMAND         *psCommands;                    
+        IMG_UINT32                              *pui32WriteOffset;              
+        volatile IMG_UINT32             *pui32ReadOffset;               
+#if defined(PDUMP)
+        IMG_UINT32                              ui32CCBDumpWOff;                
+#endif
+} PVRSRV_SGX_CCB_INFO;
+
+PVRSRV_ERROR SGXRegisterDevice (PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_VOID SGXOSTimer(IMG_VOID *pvData);
+
+IMG_VOID SGXReset(PVRSRV_SGXDEV_INFO    *psDevInfo,
+                                  IMG_BOOL                              bHardwareRecovery,
+                                  IMG_UINT32                    ui32PDUMPFlags);
+
+PVRSRV_ERROR SGXInitialise(PVRSRV_SGXDEV_INFO   *psDevInfo,
+                                                   IMG_BOOL                             bHardwareRecovery);
+PVRSRV_ERROR SGXDeinitialise(IMG_HANDLE hDevCookie);
+
+PVRSRV_ERROR SGXPrePowerState(IMG_HANDLE                                hDevHandle, 
+                                                          PVRSRV_DEV_POWER_STATE        eNewPowerState, 
+                                                          PVRSRV_DEV_POWER_STATE        eCurrentPowerState);
+
+PVRSRV_ERROR SGXPostPowerState(IMG_HANDLE                               hDevHandle, 
+                                                           PVRSRV_DEV_POWER_STATE       eNewPowerState, 
+                                                           PVRSRV_DEV_POWER_STATE       eCurrentPowerState);
+
+PVRSRV_ERROR SGXPreClockSpeedChange(IMG_HANDLE                          hDevHandle,
+                                                                        IMG_BOOL                                bIdleDevice,
+                                                                        PVRSRV_DEV_POWER_STATE  eCurrentPowerState);
+
+PVRSRV_ERROR SGXPostClockSpeedChange(IMG_HANDLE                         hDevHandle,
+                                                                         IMG_BOOL                               bIdleDevice,
+                                                                         PVRSRV_DEV_POWER_STATE eCurrentPowerState);
+
+IMG_VOID SGXPanic(PVRSRV_SGXDEV_INFO    *psDevInfo);
+
+PVRSRV_ERROR SGXDevInitCompatCheck(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+#if defined(SGX_DYNAMIC_TIMING_INFO)
+IMG_VOID SysGetSGXTimingInformation(SGX_TIMING_INFORMATION *psSGXTimingInfo);
+#endif
+
+#if defined(NO_HARDWARE)
+static INLINE IMG_VOID NoHardwareGenerateEvent(PVRSRV_SGXDEV_INFO               *psDevInfo,
+                                                                                                IMG_UINT32 ui32StatusRegister,
+                                                                                                IMG_UINT32 ui32StatusValue,
+                                                                                                IMG_UINT32 ui32StatusMask)
+{
+        IMG_UINT32 ui32RegVal;
+
+        ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, ui32StatusRegister);
+
+        ui32RegVal &= ~ui32StatusMask;
+        ui32RegVal |= (ui32StatusValue & ui32StatusMask);
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32StatusRegister, ui32RegVal);
+}
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx/sgxinit.c b/drivers/gpu/pvr/sgx/sgxinit.c
new file mode 100644
index 00000000000..2471915d10f
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxinit.c
@@ -0,0 +1,2507 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "sgxdefs.h"
+#include "sgxmmu.h"
+#include "services_headers.h"
+#include "buffer_manager.h"
+#include "sgxapi_km.h"
+#include "sgxinfo.h"
+#include "sgx_mkif_km.h"
+#include "sgxconfig.h"
+#include "sysconfig.h"
+#include "pvr_bridge_km.h"
+
+#include "sgx_bridge_km.h"
+
+#include "pdump_km.h"
+#include "ra.h"
+#include "mmu.h"
+#include "handle.h"
+#include "perproc.h"
+
+#include "sgxutils.h"
+#include "pvrversion.h"
+#include "sgx_options.h"
+
+#include "lists.h"
+#include "srvkm.h"
+
+#define VAR(x) #x
+
+ 
+#define CHECK_SIZE(NAME) \
+{       \
+        if (psSGXStructSizes->ui32Sizeof_##NAME != psDevInfo->sSGXStructSizes.ui32Sizeof_##NAME) \
+        {       \
+                PVR_DPF((PVR_DBG_ERROR, "SGXDevInitCompatCheck: Size check failed for SGXMKIF_%s (client) = %d bytes, (ukernel) = %d bytes\n", \
+                        VAR(NAME), \
+                        psDevInfo->sSGXStructSizes.ui32Sizeof_##NAME, \
+                        psSGXStructSizes->ui32Sizeof_##NAME )); \
+                bStructSizesFailed = IMG_TRUE; \
+        }       \
+}
+
+#if defined (SYS_USING_INTERRUPTS)
+IMG_BOOL SGX_ISRHandler(IMG_VOID *pvData);
+#endif
+
+
+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(OS_SUPPORTS_IN_LISR)
+        if (OSInLISR(psDeviceNode->psSysData))
+        {
+                
+                psDeviceNode->bReProcessDeviceCommandComplete = IMG_TRUE;
+        }
+        else
+        {
+                SGXScheduleProcessQueuesKM(psDeviceNode);
+        }
+#else
+        SGXScheduleProcessQueuesKM(psDeviceNode);
+#endif
+}
+
+static IMG_UINT32 DeinitDevInfo(PVRSRV_SGXDEV_INFO *psDevInfo)
+{
+        if (psDevInfo->psKernelCCBInfo != IMG_NULL)
+        {
+                
+
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_SGX_CCB_INFO), psDevInfo->psKernelCCBInfo, IMG_NULL);
+        }
+
+        return PVRSRV_OK;
+}
+
+static PVRSRV_ERROR InitDevInfo(PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                                                PVRSRV_DEVICE_NODE *psDeviceNode,
+                                                                SGX_BRIDGE_INIT_INFO *psInitInfo)
+{
+        PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
+        PVRSRV_ERROR            eError;
+
+        PVRSRV_SGX_CCB_INFO     *psKernelCCBInfo = IMG_NULL;
+
+        PVR_UNREFERENCED_PARAMETER(psPerProc);
+        psDevInfo->sScripts = psInitInfo->sScripts;
+
+        psDevInfo->psKernelCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelCCBMemInfo;
+        psDevInfo->psKernelCCB = (PVRSRV_SGX_KERNEL_CCB *) psDevInfo->psKernelCCBMemInfo->pvLinAddrKM;
+
+        psDevInfo->psKernelCCBCtlMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelCCBCtlMemInfo;
+        psDevInfo->psKernelCCBCtl = (PVRSRV_SGX_CCB_CTL *) psDevInfo->psKernelCCBCtlMemInfo->pvLinAddrKM;
+
+        psDevInfo->psKernelCCBEventKickerMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelCCBEventKickerMemInfo;
+        psDevInfo->pui32KernelCCBEventKicker = (IMG_UINT32 *)psDevInfo->psKernelCCBEventKickerMemInfo->pvLinAddrKM;
+
+        psDevInfo->psKernelSGXHostCtlMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelSGXHostCtlMemInfo;
+        psDevInfo->psSGXHostCtl = (SGXMKIF_HOST_CTL *)psDevInfo->psKernelSGXHostCtlMemInfo->pvLinAddrKM;
+
+        psDevInfo->psKernelSGXTA3DCtlMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelSGXTA3DCtlMemInfo;
+
+        psDevInfo->psKernelSGXMiscMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelSGXMiscMemInfo;
+
+#if defined(SGX_SUPPORT_HWPROFILING)
+        psDevInfo->psKernelHWProfilingMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelHWProfilingMemInfo;
+#endif
+#if defined(SUPPORT_SGX_HWPERF)
+        psDevInfo->psKernelHWPerfCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelHWPerfCBMemInfo;
+#endif
+        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
+#if defined(SGX_FEATURE_OVERLAPPED_SPM)
+        psDevInfo->psKernelTmpRgnHeaderMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelTmpRgnHeaderMemInfo;
+#endif
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        psDevInfo->psKernelTmpDPMStateMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psInitInfo->hKernelTmpDPMStateMemInfo;
+#endif
+        
+        psDevInfo->ui32ClientBuildOptions = psInitInfo->ui32ClientBuildOptions;
+
+        
+        psDevInfo->sSGXStructSizes = psInitInfo->sSGXStructSizes;
+
+        
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(PVRSRV_SGX_CCB_INFO),
+                                                (IMG_VOID **)&psKernelCCBInfo, 0,
+                                                "SGX Circular Command Buffer Info");
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"InitDevInfo: Failed to alloc memory"));
+                goto failed_allockernelccb;
+        }
+
+
+        OSMemSet(psKernelCCBInfo, 0, sizeof(PVRSRV_SGX_CCB_INFO));
+        psKernelCCBInfo->psCCBMemInfo           = psDevInfo->psKernelCCBMemInfo;
+        psKernelCCBInfo->psCCBCtlMemInfo        = psDevInfo->psKernelCCBCtlMemInfo;
+        psKernelCCBInfo->psCommands                     = psDevInfo->psKernelCCB->asCommands;
+        psKernelCCBInfo->pui32WriteOffset       = &psDevInfo->psKernelCCBCtl->ui32WriteOffset;
+        psKernelCCBInfo->pui32ReadOffset        = &psDevInfo->psKernelCCBCtl->ui32ReadOffset;
+        psDevInfo->psKernelCCBInfo = psKernelCCBInfo;
+
+        
+
+        OSMemCopy(psDevInfo->aui32HostKickAddr, psInitInfo->aui32HostKickAddr,
+                          SGXMKIF_CMD_MAX * sizeof(psDevInfo->aui32HostKickAddr[0]));
+
+        psDevInfo->bForcePTOff = IMG_FALSE;
+
+        psDevInfo->ui32CacheControl = psInitInfo->ui32CacheControl;
+
+        psDevInfo->ui32EDMTaskReg0 = psInitInfo->ui32EDMTaskReg0;
+        psDevInfo->ui32EDMTaskReg1 = psInitInfo->ui32EDMTaskReg1;
+        psDevInfo->ui32ClkGateStatusReg = psInitInfo->ui32ClkGateStatusReg;
+        psDevInfo->ui32ClkGateStatusMask = psInitInfo->ui32ClkGateStatusMask;
+#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));
+
+        return PVRSRV_OK;
+
+failed_allockernelccb:
+        DeinitDevInfo(psDevInfo);
+
+        return eError;
+}
+
+
+
+
+static PVRSRV_ERROR SGXRunScript(PVRSRV_SGXDEV_INFO *psDevInfo, SGX_INIT_COMMAND *psScript, IMG_UINT32 ui32NumInitCommands)
+{
+        IMG_UINT32 ui32PC;
+        SGX_INIT_COMMAND *psComm;
+
+        for (ui32PC = 0, psComm = psScript;
+                ui32PC < ui32NumInitCommands;
+                ui32PC++, psComm++)
+        {
+                switch (psComm->eOp)
+                {
+                        case SGX_INIT_OP_WRITE_HW_REG:
+                        {
+                                OSWriteHWReg(psDevInfo->pvRegsBaseKM, 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:
+                        {
+                                PDUMPCOMMENT("SGXRunScript: Dump HW reg operation");
+                                PDUMPREG(SGX_PDUMPREG_NAME, psComm->sPDumpHWReg.ui32Offset, psComm->sPDumpHWReg.ui32Value);
+                                break;
+                        }
+#endif
+                        case SGX_INIT_OP_HALT:
+                        {
+                                return PVRSRV_OK;
+                        }
+                        case SGX_INIT_OP_ILLEGAL:
+                        
+                        default:
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"SGXRunScript: PC %d: Illegal command: %d", ui32PC, psComm->eOp));
+                                return PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION;
+                        }
+                }
+
+        }
+
+        return PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION;
+}
+
+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;
+        static IMG_BOOL                 bFirstTime = IMG_TRUE;
+#if defined(PDUMP)
+        IMG_BOOL                                bPDumpIsSuspended = PDumpIsSuspended();
+#endif 
+
+        
+
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "SGX initialisation script part 1\n");
+        eError = SGXRunScript(psDevInfo, psDevInfo->sScripts.asInitCommandsPart1, SGX_MAX_INIT_COMMANDS);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXInitialise: SGXRunScript (part 1) failed (%d)", eError));
+                return eError;
+        }
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "End of SGX initialisation script part 1\n");
+
+        
+        SGXReset(psDevInfo, bFirstTime || bHardwareRecovery, PDUMP_FLAGS_CONTINUOUS);
+
+#if defined(EUR_CR_POWER)
+#if defined(SGX531)
+        
+
+
+
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_POWER, 1);
+        PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_POWER, 1);
+#else
+        
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_POWER, 0);
+        PDUMPREG(SGX_PDUMPREG_NAME, EUR_CR_POWER, 0);
+#endif
+#endif
+
+        
+        *psDevInfo->pui32KernelCCBEventKicker = 0;
+#if defined(PDUMP)
+        if (!bPDumpIsSuspended)
+        {
+                psDevInfo->ui32KernelCCBEventKickerDumpVal = 0;
+                PDUMPMEM(&psDevInfo->ui32KernelCCBEventKickerDumpVal,
+                                 psDevInfo->psKernelCCBEventKickerMemInfo, 0,
+                                 sizeof(*psDevInfo->pui32KernelCCBEventKicker), PDUMP_FLAGS_CONTINUOUS,
+                                 MAKEUNIQUETAG(psDevInfo->psKernelCCBEventKickerMemInfo));
+        }
+#endif 
+
+        
+
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "SGX initialisation script part 2\n");
+        eError = SGXRunScript(psDevInfo, psDevInfo->sScripts.asInitCommandsPart2, SGX_MAX_INIT_COMMANDS);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXInitialise: SGXRunScript (part 2) failed (%d)", eError));
+                return eError;
+        }
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS, "End of SGX initialisation script part 2\n");
+
+        
+        psSGXHostCtl->ui32HostClock = OSClockus();
+
+        psSGXHostCtl->ui32InitStatus = 0;
+#if defined(PDUMP)
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
+                                                  "Reset the SGX microkernel initialisation status\n");
+        PDUMPMEM(IMG_NULL, psSGXHostCtlMemInfo,
+                         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 (!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");
+                PDUMPMEM(&psDevInfo->ui32KernelCCBEventKickerDumpVal,
+                                 psDevInfo->psKernelCCBEventKickerMemInfo,
+                                 0,
+                                 sizeof(IMG_UINT32),
+                                 PDUMP_FLAGS_CONTINUOUS,
+                                 MAKEUNIQUETAG(psDevInfo->psKernelCCBEventKickerMemInfo));
+                PDUMPREG(SGX_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0), EUR_CR_EVENT_KICK_NOW_MASK);
+#endif 
+        }
+#endif 
+
+#if !defined(NO_HARDWARE)
+        
+
+        if (PollForValueKM(&psSGXHostCtl->ui32InitStatus,
+                                           PVRSRV_USSE_EDM_INIT_COMPLETE,
+                                           PVRSRV_USSE_EDM_INIT_COMPLETE,
+                                           MAX_HW_TIME_US/WAIT_TRY_COUNT,
+                                           WAIT_TRY_COUNT) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXInitialise: Wait for uKernel initialisation failed"));
+                PVR_DBG_BREAK;
+                return PVRSRV_ERROR_RETRY;
+        }
+#endif 
+
+#if defined(PDUMP)
+        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
+                                                  "Wait for the SGX microkernel initialisation to complete");
+        PDUMPMEMPOL(psSGXHostCtlMemInfo,
+                                offsetof(SGXMKIF_HOST_CTL, ui32InitStatus),
+                                PVRSRV_USSE_EDM_INIT_COMPLETE,
+                                PVRSRV_USSE_EDM_INIT_COMPLETE,
+                                PDUMP_POLL_OPERATOR_EQUAL,
+                                PDUMP_FLAGS_CONTINUOUS,
+                                MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+#endif 
+
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
+        
+
+
+        WorkaroundBRN22997ReadHostPort(psDevInfo);
+#endif 
+
+        PVR_ASSERT(psDevInfo->psKernelCCBCtl->ui32ReadOffset == psDevInfo->psKernelCCBCtl->ui32WriteOffset);
+
+        bFirstTime = IMG_FALSE;
+        
+        return PVRSRV_OK;
+}
+
+PVRSRV_ERROR SGXDeinitialise(IMG_HANDLE hDevCookie)
+
+{
+        PVRSRV_SGXDEV_INFO      *psDevInfo = (PVRSRV_SGXDEV_INFO *) hDevCookie;
+        PVRSRV_ERROR            eError;
+
+        
+        if (psDevInfo->pvRegsBaseKM == IMG_NULL)
+        {
+                return PVRSRV_OK;
+        }
+
+        eError = SGXRunScript(psDevInfo, psDevInfo->sScripts.asDeinitCommands, SGX_MAX_DEINIT_COMMANDS);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXDeinitialise: SGXRunScript failed (%d)", eError));
+                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;
+        IMG_UINT32              i;
+        PVRSRV_DEVICE_NODE  *psDeviceNode = (PVRSRV_DEVICE_NODE *)pvDeviceNode;
+        DEVICE_MEMORY_HEAP_INFO *psDeviceMemoryHeap = psDeviceNode->sDevMemoryInfo.psDeviceMemoryHeap;
+        PVRSRV_ERROR            eError;
+
+        
+        PDUMPCOMMENT("SGX Core Version Information: %s", SGX_CORE_FRIENDLY_NAME);
+        
+        #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: %d", SGX_CORE_REV);
+#endif
+
+        #if defined(SGX_FEATURE_SYSTEM_CACHE)
+        PDUMPCOMMENT("SGX System Level Cache is present\r\n");
+        #if defined(SGX_BYPASS_SYSTEM_CACHE)
+        PDUMPCOMMENT("SGX System Level Cache is bypassed\r\n");
+        #endif 
+        #endif 
+
+        PDUMPCOMMENT("SGX Initialisation Part 1");
+
+        
+        if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                         sizeof(PVRSRV_SGXDEV_INFO),
+                                         (IMG_VOID **)&psDevInfo, IMG_NULL,
+                                         "SGX Device Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart1 : Failed to alloc memory for DevInfo"));
+                return (PVRSRV_ERROR_OUT_OF_MEMORY);
+        }
+        OSMemSet (psDevInfo, 0, sizeof(PVRSRV_SGXDEV_INFO));
+
+        
+        psDevInfo->eDeviceType          = DEV_DEVICE_TYPE;
+        psDevInfo->eDeviceClass         = DEV_DEVICE_CLASS;
+
+        
+        psDeviceNode->pvDevice = (IMG_PVOID)psDevInfo;
+
+        
+        psDevInfo->pvDeviceMemoryHeap = (IMG_VOID*)psDeviceMemoryHeap;
+
+        
+        hKernelDevMemContext = BM_CreateContext(psDeviceNode,
+                                                                                        &sPDDevPAddr,
+                                                                                        IMG_NULL,
+                                                                                        IMG_NULL);
+        if (hKernelDevMemContext == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart1: Failed BM_CreateContext"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        psDevInfo->sKernelPDDevPAddr = sPDDevPAddr;
+
+        
+        for(i=0; i<psDeviceNode->sDevMemoryInfo.ui32HeapCount; i++)
+        {
+                switch(psDeviceMemoryHeap[i].DevMemHeapType)
+                {
+                        case DEVICE_MEMORY_HEAP_KERNEL:
+                        case DEVICE_MEMORY_HEAP_SHARED:
+                        case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+                        {
+                                hDevMemHeap = BM_CreateHeap (hKernelDevMemContext,
+                                                                                                &psDeviceMemoryHeap[i]);
+                                
+
+
+                                psDeviceMemoryHeap[i].hDevMemHeap = hDevMemHeap;
+                                break;
+                        }
+                }
+        }
+#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 eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGXGetInfoForSrvinitKM(IMG_HANDLE hDevHandle, SGX_BRIDGE_INFO_FOR_SRVINIT *psInitInfo)
+{
+        PVRSRV_DEVICE_NODE      *psDeviceNode;
+        PVRSRV_SGXDEV_INFO      *psDevInfo;
+        PVRSRV_ERROR            eError;
+
+        PDUMPCOMMENT("SGXGetInfoForSrvinit");
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevHandle;
+        psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
+
+        psInitInfo->sPDDevPAddr = psDevInfo->sKernelPDDevPAddr;
+
+        eError = PVRSRVGetDeviceMemHeapsKM(hDevHandle, &psInitInfo->asHeapInfo[0]);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXGetInfoForSrvinit: PVRSRVGetDeviceMemHeapsKM failed (%d)", eError));
+                return eError;
+        }
+
+        return eError;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR DevInitSGXPart2KM (PVRSRV_PER_PROCESS_DATA *psPerProc,
+                                IMG_HANDLE hDevHandle,
+                                SGX_BRIDGE_INIT_INFO *psInitInfo)
+{
+        PVRSRV_DEVICE_NODE              *psDeviceNode;
+        PVRSRV_SGXDEV_INFO              *psDevInfo;
+        PVRSRV_ERROR                    eError;
+        SGX_DEVICE_MAP                  *psSGXDeviceMap;
+        PVRSRV_DEV_POWER_STATE  eDefaultPowerState;
+
+        PDUMPCOMMENT("SGX Initialisation Part 2");
+
+        psDeviceNode = (PVRSRV_DEVICE_NODE *)hDevHandle;
+        psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
+
+        
+
+        eError = InitDevInfo(psPerProc, psDeviceNode, psInitInfo);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart2KM: Failed to load EDM program"));
+                goto failed_init_dev_info;
+        }
+
+
+        eError = SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE_SGX,
+                                                                        (IMG_VOID**)&psSGXDeviceMap);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart2KM: Failed to get device memory map!"));
+                return PVRSRV_ERROR_INIT_FAILURE;
+        }
+
+        
+        if (psSGXDeviceMap->pvRegsCpuVBase)
+        {
+                psDevInfo->pvRegsBaseKM = psSGXDeviceMap->pvRegsCpuVBase;
+        }
+        else
+        {
+                
+                psDevInfo->pvRegsBaseKM = OSMapPhysToLin(psSGXDeviceMap->sRegsCpuPBase,
+                                                                                           psSGXDeviceMap->ui32RegsSize,
+                                                                                           PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                                                                           IMG_NULL);
+                if (!psDevInfo->pvRegsBaseKM)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart2KM: Failed to map in regs\n"));
+                        return PVRSRV_ERROR_BAD_MAPPING;
+                }
+        }
+        psDevInfo->ui32RegSize = psSGXDeviceMap->ui32RegsSize;
+        psDevInfo->sRegsPhysBase = psSGXDeviceMap->sRegsSysPBase;
+
+
+#if defined(SGX_FEATURE_HOST_PORT)
+        if (psSGXDeviceMap->ui32Flags & SGX_HOSTPORT_PRESENT)
+        {
+                
+                psDevInfo->pvHostPortBaseKM = OSMapPhysToLin(psSGXDeviceMap->sHPCpuPBase,
+                                                                                           psSGXDeviceMap->ui32HPSize,
+                                                                                           PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                                                                           IMG_NULL);
+                if (!psDevInfo->pvHostPortBaseKM)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart2KM: Failed to map in host port\n"));
+                        return PVRSRV_ERROR_BAD_MAPPING;
+                }
+                psDevInfo->ui32HPSize = psSGXDeviceMap->ui32HPSize;
+                psDevInfo->sHPSysPAddr = psSGXDeviceMap->sHPSysPBase;
+        }
+#endif
+
+#if defined (SYS_USING_INTERRUPTS)
+
+        
+        psDeviceNode->pvISRData = psDeviceNode;
+        
+        PVR_ASSERT(psDeviceNode->pfnDeviceISR == SGX_ISRHandler);
+
+#endif 
+
+        
+        psDevInfo->psSGXHostCtl->ui32PowerStatus |= PVRSRV_USSE_EDM_POWMAN_NO_WORK;
+        eDefaultPowerState = PVRSRV_DEV_POWER_STATE_OFF;
+        
+        eError = PVRSRVRegisterPowerDevice (psDeviceNode->sDevId.ui32DeviceIndex,
+                                                                                &SGXPrePowerState, &SGXPostPowerState,
+                                                                                &SGXPreClockSpeedChange, &SGXPostClockSpeedChange,
+                                                                                (IMG_HANDLE)psDeviceNode,
+                                                                                PVRSRV_DEV_POWER_STATE_OFF,
+                                                                                eDefaultPowerState);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevInitSGXPart2KM: failed to register device with power manager"));
+                return eError;
+        }
+
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
+        eError = WorkaroundBRN22997Alloc(psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXInitialise : Failed to alloc memory for BRN22997 workaround"));
+                return eError;
+        }
+#endif 
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+        
+        psDevInfo->ui32ExtSysCacheRegsSize = psSGXDeviceMap->ui32ExtSysCacheRegsSize;
+        psDevInfo->sExtSysCacheRegsDevPBase = psSGXDeviceMap->sExtSysCacheRegsDevPBase;
+        eError = MMU_MapExtSystemCacheRegs(psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXInitialise : Failed to map external system cache registers"));
+                return eError;
+        }
+#endif 
+
+        
+
+        OSMemSet(psDevInfo->psKernelCCB, 0, sizeof(PVRSRV_SGX_KERNEL_CCB));
+        OSMemSet(psDevInfo->psKernelCCBCtl, 0, sizeof(PVRSRV_SGX_CCB_CTL));
+        OSMemSet(psDevInfo->pui32KernelCCBEventKicker, 0, sizeof(*psDevInfo->pui32KernelCCBEventKicker));
+        PDUMPCOMMENT("Initialise Kernel CCB");
+        PDUMPMEM(IMG_NULL, psDevInfo->psKernelCCBMemInfo, 0, sizeof(PVRSRV_SGX_KERNEL_CCB), PDUMP_FLAGS_CONTINUOUS, MAKEUNIQUETAG(psDevInfo->psKernelCCBMemInfo));
+        PDUMPCOMMENT("Initialise Kernel CCB Control");
+        PDUMPMEM(IMG_NULL, psDevInfo->psKernelCCBCtlMemInfo, 0, sizeof(PVRSRV_SGX_CCB_CTL), PDUMP_FLAGS_CONTINUOUS, MAKEUNIQUETAG(psDevInfo->psKernelCCBCtlMemInfo));
+        PDUMPCOMMENT("Initialise Kernel CCB Event Kicker");
+        PDUMPMEM(IMG_NULL, psDevInfo->psKernelCCBEventKickerMemInfo, 0, sizeof(*psDevInfo->pui32KernelCCBEventKicker), PDUMP_FLAGS_CONTINUOUS, MAKEUNIQUETAG(psDevInfo->psKernelCCBEventKickerMemInfo));
+
+        return PVRSRV_OK;
+
+failed_init_dev_info:
+        return eError;
+}
+
+static PVRSRV_ERROR DevDeInitSGX (IMG_VOID *pvDeviceNode)
+{
+        PVRSRV_DEVICE_NODE                      *psDeviceNode = (PVRSRV_DEVICE_NODE *)pvDeviceNode;
+        PVRSRV_SGXDEV_INFO                      *psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+        PVRSRV_ERROR                            eError;
+        IMG_UINT32                                      ui32Heap;
+        DEVICE_MEMORY_HEAP_INFO         *psDeviceMemoryHeap;
+        SGX_DEVICE_MAP                          *psSGXDeviceMap;
+
+        if (!psDevInfo)
+        {
+                
+                PVR_DPF((PVR_DBG_ERROR,"DevDeInitSGX: Null DevInfo"));
+                return PVRSRV_OK;
+        }
+
+#if defined(SUPPORT_HW_RECOVERY)
+        if (psDevInfo->hTimer)
+        {
+                eError = OSRemoveTimer(psDevInfo->hTimer);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"DevDeInitSGX: Failed to remove timer"));
+                        return  eError;
+                }
+                psDevInfo->hTimer = IMG_NULL;
+        }
+#endif 
+
+#if defined(SUPPORT_EXTERNAL_SYSTEM_CACHE)
+        
+        eError = MMU_UnmapExtSystemCacheRegs(psDeviceNode);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevDeInitSGX: Failed to unmap ext system cache registers"));
+                return eError;
+        }
+#endif 
+
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)
+        WorkaroundBRN22997Free(psDeviceNode);
+#endif 
+
+        MMU_BIFResetPDFree(psDevInfo);
+
+        
+
+        DeinitDevInfo(psDevInfo);
+
+        
+        psDeviceMemoryHeap = (DEVICE_MEMORY_HEAP_INFO *)psDevInfo->pvDeviceMemoryHeap;
+        for(ui32Heap=0; ui32Heap<psDeviceNode->sDevMemoryInfo.ui32HeapCount; ui32Heap++)
+        {
+                switch(psDeviceMemoryHeap[ui32Heap].DevMemHeapType)
+                {
+                        case DEVICE_MEMORY_HEAP_KERNEL:
+                        case DEVICE_MEMORY_HEAP_SHARED:
+                        case DEVICE_MEMORY_HEAP_SHARED_EXPORTED:
+                        {
+                                if (psDeviceMemoryHeap[ui32Heap].hDevMemHeap != IMG_NULL)
+                                {
+                                        BM_DestroyHeap(psDeviceMemoryHeap[ui32Heap].hDevMemHeap);
+                                }
+                                break;
+                        }
+                }
+        }
+
+        
+        eError = BM_DestroyContext(psDeviceNode->sDevMemoryInfo.pBMKernelContext, IMG_NULL);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevDeInitSGX : Failed to destroy kernel context"));
+                return eError;
+        }
+
+        
+        eError = PVRSRVRemovePowerDevice (((PVRSRV_DEVICE_NODE*)pvDeviceNode)->sDevId.ui32DeviceIndex);
+        if (eError != PVRSRV_OK)
+        {
+                return eError;
+        }
+
+        eError = SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE_SGX,
+                                                                        (IMG_VOID**)&psSGXDeviceMap);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"DevDeInitSGX: Failed to get device memory map!"));
+                return eError;
+        }
+
+        
+        if (!psSGXDeviceMap->pvRegsCpuVBase)
+        {
+                
+                if (psDevInfo->pvRegsBaseKM != IMG_NULL)
+                {
+                        OSUnMapPhysToLin(psDevInfo->pvRegsBaseKM,
+                                                         psDevInfo->ui32RegSize,
+                                                         PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                                         IMG_NULL);
+                }
+        }
+
+#if defined(SGX_FEATURE_HOST_PORT)
+        if (psSGXDeviceMap->ui32Flags & SGX_HOSTPORT_PRESENT)
+        {
+                
+                if (psDevInfo->pvHostPortBaseKM != IMG_NULL)
+                {
+                        OSUnMapPhysToLin(psDevInfo->pvHostPortBaseKM,
+                                                   psDevInfo->ui32HPSize,
+                                                   PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
+                                                   IMG_NULL);
+                }
+        }
+#endif 
+
+
+        
+        OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                sizeof(PVRSRV_SGXDEV_INFO),
+                                psDevInfo,
+                                0);
+
+        psDeviceNode->pvDevice = IMG_NULL;
+
+        if (psDeviceMemoryHeap != IMG_NULL)
+        {
+        
+                OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
+                                sizeof(DEVICE_MEMORY_HEAP_INFO) * SGX_MAX_HEAP_ID,
+                                psDeviceMemoryHeap,
+                                0);
+        }
+
+        return PVRSRV_OK;
+}
+
+
+static IMG_VOID SGXDumpDebugReg (PVRSRV_SGXDEV_INFO     *psDevInfo,
+                                                                 IMG_UINT32                     ui32CoreNum,
+                                                                 IMG_CHAR                       *pszName,
+                                                                 IMG_UINT32                     ui32RegAddr)
+{
+        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", (IMG_UINTPTR_T)psDevInfo->pvRegsBaseKM));
+                PVR_DPF((PVR_DBG_ERROR,"SGX Register Base Address (Physical): 0x%08X", psDevInfo->sRegsPhysBase.uiAddr));
+
+                for (ui32CoreNum = 0; ui32CoreNum < SGX_FEATURE_MP_CORE_COUNT; ui32CoreNum++)
+                {
+                
+                        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
+                }
+        }
+
+        
+
+        QueueDumpDebugInfo();
+
+        {
+                
+
+                IMG_UINT32      *pui32HostCtlBuffer = (IMG_UINT32 *)psDevInfo->psSGXHostCtl;
+                IMG_UINT32      ui32LoopCounter;
+
+                PVR_LOG(("SGX Host control:"));
+
+                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]));
+                }
+        }
+
+        {
+                
+
+                IMG_UINT32      *pui32TA3DCtlBuffer = psDevInfo->psKernelSGXTA3DCtlMemInfo->pvLinAddrKM;
+                IMG_UINT32      ui32LoopCounter;
+
+                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;
+                IMG_UINT32      ui32LastStatusCode, ui32WriteOffset;
+
+                ui32LastStatusCode = *pui32MKTraceBuffer;
+                pui32MKTraceBuffer++;
+                ui32WriteOffset = *pui32MKTraceBuffer;
+                pui32MKTraceBuffer++;
+
+                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(("\t(MKT-%X) %08X %08X %08X %08X", ui32LoopCounter,
+                                                 pui32BufPtr[2], pui32BufPtr[3], pui32BufPtr[1], pui32BufPtr[0]));
+                        }
+                }
+                #endif 
+        }
+        #endif 
+
+        {
+                
+
+                PVR_LOG(("SGX Kernel CCB WO:0x%X RO:0x%X",
+                                psDevInfo->psKernelCCBCtl->ui32WriteOffset,
+                                psDevInfo->psKernelCCBCtl->ui32ReadOffset));
+
+                #if defined(PVRSRV_DUMP_KERNEL_CCB)
+                {
+                        IMG_UINT32      ui32LoopCounter;
+
+                        for (ui32LoopCounter = 0;
+                                 ui32LoopCounter < sizeof(psDevInfo->psKernelCCB->asCommands) /
+                                                                        sizeof(psDevInfo->psKernelCCB->asCommands[0]);
+                                 ui32LoopCounter++)
+                        {
+                                SGXMKIF_COMMAND *psCommand = &psDevInfo->psKernelCCB->asCommands[ui32LoopCounter];
+
+                                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 
+        }
+}
+
+
+#if defined(SYS_USING_INTERRUPTS) || defined(SUPPORT_HW_RECOVERY)
+static
+IMG_VOID HWRecoveryResetSGX (PVRSRV_DEVICE_NODE *psDeviceNode,
+                                                         IMG_UINT32             ui32Component,
+                                                         IMG_UINT32                     ui32CallerID)
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = (PVRSRV_SGXDEV_INFO*)psDeviceNode->pvDevice;
+        SGXMKIF_HOST_CTL        *psSGXHostCtl = (SGXMKIF_HOST_CTL *)psDevInfo->psSGXHostCtl;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Component);
+
+        
+
+        eError = PVRSRVPowerLock(ui32CallerID, IMG_FALSE);
+        if(eError != PVRSRV_OK)
+        {
+                
+
+
+                PVR_DPF((PVR_DBG_WARNING,"HWRecoveryResetSGX: Power transition in progress"));
+                return;
+        }
+
+        psSGXHostCtl->ui32InterruptClearFlags |= PVRSRV_USSE_EDM_INTERRUPT_HWR;
+
+        PVR_LOG(("HWRecoveryResetSGX: SGX Hardware Recovery triggered"));
+
+        SGXDumpDebugInfo(psDeviceNode->pvDevice, IMG_TRUE);
+
+        
+        PDUMPSUSPEND();
+
+        
+        eError = SGXInitialise(psDevInfo, IMG_TRUE);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"HWRecoveryResetSGX: SGXInitialise failed (%d)", eError));
+        }
+
+        
+        PDUMPRESUME();
+
+        PVRSRVPowerUnlock(ui32CallerID);
+
+        
+        SGXScheduleProcessQueuesKM(psDeviceNode);
+
+        
+        
+        PVRSRVProcessQueues(ui32CallerID, IMG_TRUE);
+}
+#endif 
+
+
+#if defined(SUPPORT_HW_RECOVERY)
+IMG_VOID SGXOSTimer(IMG_VOID *pvData)
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode = pvData;
+        PVRSRV_SGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
+        static IMG_UINT32       ui32EDMTasks = 0;
+        static IMG_UINT32       ui32LockupCounter = 0; 
+        static IMG_UINT32       ui32NumResets = 0;
+        IMG_UINT32              ui32CurrentEDMTasks;
+        IMG_BOOL                bLockup = IMG_FALSE;
+        IMG_BOOL                bPoweredDown;
+
+        
+        psDevInfo->ui32TimeStamp++;
+
+#if defined(NO_HARDWARE)
+        bPoweredDown = IMG_TRUE;
+#else
+        bPoweredDown = (SGXIsDevicePowered(psDeviceNode)) ? IMG_FALSE : IMG_TRUE;
+#endif 
+
+        
+        
+        if (bPoweredDown)
+        {
+                ui32LockupCounter = 0;
+        }
+        else
+        {
+                
+                ui32CurrentEDMTasks = OSReadHWReg(psDevInfo->pvRegsBaseKM, psDevInfo->ui32EDMTaskReg0);
+                if (psDevInfo->ui32EDMTaskReg1 != 0)
+                {
+                        ui32CurrentEDMTasks ^= OSReadHWReg(psDevInfo->pvRegsBaseKM, psDevInfo->ui32EDMTaskReg1);
+                }
+                if ((ui32CurrentEDMTasks == ui32EDMTasks) &&
+                        (psDevInfo->ui32NumResets == ui32NumResets))
+                {
+                        ui32LockupCounter++;
+                        if (ui32LockupCounter == 3)
+                        {
+                                ui32LockupCounter = 0;
+                                PVR_DPF((PVR_DBG_ERROR, "SGXOSTimer() detected SGX lockup (0x%x tasks)", ui32EDMTasks));
+
+                                bLockup = IMG_TRUE;
+                        }
+                }
+                else
+                {
+                        ui32LockupCounter = 0;
+                        ui32EDMTasks = ui32CurrentEDMTasks;
+                        ui32NumResets = psDevInfo->ui32NumResets;
+                }
+        }
+
+        if (bLockup)
+        {
+                SGXMKIF_HOST_CTL        *psSGXHostCtl = (SGXMKIF_HOST_CTL *)psDevInfo->psSGXHostCtl;
+
+                
+                psSGXHostCtl->ui32HostDetectedLockups ++;
+
+                
+                HWRecoveryResetSGX(psDeviceNode, 0, KERNEL_ID);
+        }
+}
+#endif 
+
+
+#if defined(SYS_USING_INTERRUPTS)
+
+IMG_BOOL SGX_ISRHandler (IMG_VOID *pvData)
+{
+        IMG_BOOL bInterruptProcessed = IMG_FALSE;
+
+
+        
+        {
+                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;
+
+                
+                if(pvData == IMG_NULL)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "SGX_ISRHandler: Invalid params\n"));
+                        return bInterruptProcessed;
+                }
+
+                psDeviceNode = (PVRSRV_DEVICE_NODE *)pvData;
+                psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNode->pvDevice;
+
+                ui32EventStatus = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_STATUS);
+                ui32EventEnable = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_ENABLE);
+
+                
+                ui32EventStatus &= ui32EventEnable;
+
+#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 
+
+                
+
+                if (ui32EventStatus & EUR_CR_EVENT_STATUS_SW_EVENT_MASK)
+                {
+                        ui32EventClear |= EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_MASK;
+                }
+
+#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;
+
+                        
+                        ui32EventClear |= EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_MASK;
+
+                        
+                        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR, ui32EventClear);
+                        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_EVENT_HOST_CLEAR2, ui32EventClear2);
+                }
+        }
+
+        return bInterruptProcessed;
+}
+
+
+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;
+        SGXMKIF_HOST_CTL        *psSGXHostCtl = (SGXMKIF_HOST_CTL *)psDevInfo->psSGXHostCtl;
+
+        if (((psSGXHostCtl->ui32InterruptFlags & PVRSRV_USSE_EDM_INTERRUPT_HWR) != 0UL) &&
+                ((psSGXHostCtl->ui32InterruptClearFlags & PVRSRV_USSE_EDM_INTERRUPT_HWR) == 0UL))
+        {
+                HWRecoveryResetSGX(psDeviceNode, 0, ISR_ID);
+        }
+
+#if defined(OS_SUPPORTS_IN_LISR)
+        if (psDeviceNode->bReProcessDeviceCommandComplete)
+        {
+                SGXScheduleProcessQueuesKM(psDeviceNode);
+        }
+#endif
+
+        SGXTestActivePowerEvent(psDeviceNode, ISR_ID);
+}
+#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;
+#if defined(PDUMP)
+        {
+                
+                SGX_DEVICE_MAP *psSGXDeviceMemMap;
+                SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE_SGX,
+                                                          (IMG_VOID**)&psSGXDeviceMemMap);
+
+                psDeviceNode->sDevId.pszPDumpDevName = psSGXDeviceMemMap->pszPDumpDevName;
+                PVR_ASSERT(psDeviceNode->sDevId.pszPDumpDevName != IMG_NULL);
+        }
+        
+        psDeviceNode->sDevId.pszPDumpRegName    = SGX_PDUMPREG_NAME;
+#endif 
+
+        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;
+
+#if defined (SYS_USING_INTERRUPTS)
+        
+
+        psDeviceNode->pfnDeviceISR = SGX_ISRHandler;
+        psDeviceNode->pfnDeviceMISR = SGX_MISRHandler;
+#endif
+
+#if defined(SUPPORT_MEMORY_TILING)
+        psDeviceNode->pfnAllocMemTilingRange = SGX_AllocMemTilingRange;
+        psDeviceNode->pfnFreeMemTilingRange = SGX_FreeMemTilingRange;
+#endif
+
+        
+
+        psDeviceNode->pfnDeviceCommandComplete = &SGXCommandComplete;
+
+        
+
+        psDevMemoryInfo = &psDeviceNode->sDevMemoryInfo;
+        
+        psDevMemoryInfo->ui32AddressSpaceSizeLog2 = SGX_FEATURE_ADDRESS_SPACE_SIZE;
+
+        
+        psDevMemoryInfo->ui32Flags = 0;
+
+        
+        if(OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
+                                         sizeof(DEVICE_MEMORY_HEAP_INFO) * SGX_MAX_HEAP_ID,
+                                         (IMG_VOID **)&psDevMemoryInfo->psDeviceMemoryHeap, 0,
+                                         "Array of Device Memory Heap Info") != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXRegisterDevice : Failed to alloc memory for DEVICE_MEMORY_HEAP_INFO"));
+                return (PVRSRV_ERROR_OUT_OF_MEMORY);
+        }
+        OSMemSet(psDevMemoryInfo->psDeviceMemoryHeap, 0, sizeof(DEVICE_MEMORY_HEAP_INFO) * SGX_MAX_HEAP_ID);
+
+        psDeviceMemoryHeap = psDevMemoryInfo->psDeviceMemoryHeap;
+
+        
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_GENERAL_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_GENERAL_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_GENERAL_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->pszName = "General";
+        psDeviceMemoryHeap->pszBSName = "General BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+#if !defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+        
+        psDevMemoryInfo->ui32MappingHeapID = (IMG_UINT32)(psDeviceMemoryHeap - psDevMemoryInfo->psDeviceMemoryHeap);
+#endif
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_TADATA_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_TADATA_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_TADATA_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->pszName = "TA Data";
+        psDeviceMemoryHeap->pszBSName = "TA Data BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_KERNEL_CODE_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_KERNEL_CODE_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_KERNEL_CODE_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                        | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                        | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->pszName = "Kernel Code";
+        psDeviceMemoryHeap->pszBSName = "Kernel Code BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_KERNEL_DATA_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_KERNEL_DATA_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_KERNEL_DATA_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                                | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->pszName = "KernelData";
+        psDeviceMemoryHeap->pszBSName = "KernelData BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_PIXELSHADER_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_PIXELSHADER_HEAP_BASE;
+        
+
+
+
+
+
+        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->pszName = "PixelShaderUSSE";
+        psDeviceMemoryHeap->pszBSName = "PixelShaderUSSE BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_VERTEXSHADER_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_VERTEXSHADER_HEAP_BASE;
+        
+        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->pszName = "VertexShaderUSSE";
+        psDeviceMemoryHeap->pszBSName = "VertexShaderUSSE BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_PDSPIXEL_CODEDATA_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_PDSPIXEL_CODEDATA_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_PDSPIXEL_CODEDATA_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                                | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->pszName = "PDSPixelCodeData";
+        psDeviceMemoryHeap->pszBSName = "PDSPixelCodeData BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_PDSVERTEX_CODEDATA_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_PDSVERTEX_CODEDATA_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_PDSVERTEX_CODEDATA_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                                | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->pszName = "PDSVertexCodeData";
+        psDeviceMemoryHeap->pszBSName = "PDSVertexCodeData BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_SYNCINFO_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_SYNCINFO_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_SYNCINFO_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->pszName = "CacheCoherent";
+        psDeviceMemoryHeap->pszBSName = "CacheCoherent BS";
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        
+        psDevMemoryInfo->ui32SyncHeapID = (IMG_UINT32)(psDeviceMemoryHeap - psDevMemoryInfo->psDeviceMemoryHeap);
+        psDeviceMemoryHeap++;
+
+
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_3DPARAMETERS_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_3DPARAMETERS_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_3DPARAMETERS_HEAP_SIZE;
+        psDeviceMemoryHeap->pszName = "3DParameters";
+        psDeviceMemoryHeap->pszBSName = "3DParameters BS";
+#if defined(SUPPORT_PERCONTEXT_PB)
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                        | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                        | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+#else
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                        | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                        | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+#endif
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+
+
+#if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_GENERAL_MAPPING_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_GENERAL_MAPPING_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_GENERAL_MAPPING_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE | PVRSRV_HAP_MULTI_PROCESS;
+        psDeviceMemoryHeap->pszName = "GeneralMapping";
+        psDeviceMemoryHeap->pszBSName = "GeneralMapping BS";
+        #if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS) && defined(FIX_HW_BRN_23410)
+        
+
+
+
+
+
+
+                psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+        #else 
+                psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        #endif 
+
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        
+        psDevMemoryInfo->ui32MappingHeapID = (IMG_UINT32)(psDeviceMemoryHeap - psDevMemoryInfo->psDeviceMemoryHeap);
+        psDeviceMemoryHeap++;
+#endif 
+
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_2D_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_2D_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_2D_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->pszName = "2D";
+        psDeviceMemoryHeap->pszBSName = "2D BS";
+        
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_SHARED_EXPORTED;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+#endif 
+
+
+#if defined(FIX_HW_BRN_26915)
+        
+        
+        psDeviceMemoryHeap->ui32HeapID = HEAP_ID( PVRSRV_DEVICE_TYPE_SGX, SGX_CGBUFFER_HEAP_ID);
+        psDeviceMemoryHeap->sDevVAddrBase.uiAddr = SGX_CGBUFFER_HEAP_BASE;
+        psDeviceMemoryHeap->ui32HeapSize = SGX_CGBUFFER_HEAP_SIZE;
+        psDeviceMemoryHeap->ui32Attribs = PVRSRV_HAP_WRITECOMBINE
+                                                                                                                | PVRSRV_MEM_RAM_BACKED_ALLOCATION
+                                                                                                                | PVRSRV_HAP_SINGLE_PROCESS;
+        psDeviceMemoryHeap->pszName = "CGBuffer";
+        psDeviceMemoryHeap->pszBSName = "CGBuffer BS";
+
+        psDeviceMemoryHeap->DevMemHeapType = DEVICE_MEMORY_HEAP_PERCONTEXT;
+        
+        psDeviceMemoryHeap->ui32DataPageSize = SGX_MMU_PAGE_SIZE;
+        psDeviceMemoryHeap++;
+#endif 
+
+        
+        psDevMemoryInfo->ui32HeapCount = (IMG_UINT32)(psDeviceMemoryHeap - psDevMemoryInfo->psDeviceMemoryHeap);
+
+        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)
+{
+        PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
+
+        
+
+        psDevInfo->ui32ClientRefCount++;
+
+        
+
+        psClientInfo->ui32ProcessID = OSGetCurrentProcessIDKM();
+
+        
+
+        OSMemCopy(&psClientInfo->asDevData, &psDevInfo->asSGXDevData, sizeof(psClientInfo->asDevData));
+
+        
+        return PVRSRV_OK;
+}
+
+
+IMG_VOID SGXPanic(PVRSRV_SGXDEV_INFO    *psDevInfo)
+{
+        PVR_LOG(("SGX panic"));
+        SGXDumpDebugInfo(psDevInfo, IMG_FALSE);
+        OSPanic();
+}
+
+
+PVRSRV_ERROR SGXDevInitCompatCheck(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR    eError;
+        PVRSRV_SGXDEV_INFO                              *psDevInfo;
+        IMG_UINT32                      ui32BuildOptions, ui32BuildOptionsMismatch;
+#if !defined(NO_HARDWARE)
+        PPVRSRV_KERNEL_MEM_INFO                 psMemInfo;
+        PVRSRV_SGX_MISCINFO_INFO                *psSGXMiscInfoInt;      
+        PVRSRV_SGX_MISCINFO_FEATURES    *psSGXFeatures;
+        SGX_MISCINFO_STRUCT_SIZES               *psSGXStructSizes;      
+        IMG_BOOL                                                bStructSizesFailed;
+
+        
+        IMG_BOOL        bCheckCoreRev;
+        const IMG_UINT32 aui32CoreRevExceptions[] =
+        {
+                0x10100, 0x10101
+        };
+        const IMG_UINT32        ui32NumCoreExceptions = sizeof(aui32CoreRevExceptions) / (2*sizeof(IMG_UINT32));
+        IMG_UINT        i;
+#endif
+
+        
+        if(psDeviceNode->sDevId.eDeviceType != PVRSRV_DEVICE_TYPE_SGX)
+        {
+                PVR_LOG(("(FAIL) SGXInit: Device not of type SGX"));
+                eError = PVRSRV_ERROR_INVALID_PARAMS;
+                goto chk_exit;
+        }
+
+        psDevInfo = psDeviceNode->pvDevice;
+
+        
+        
+        ui32BuildOptions = (SGX_BUILD_OPTIONS);
+        if (ui32BuildOptions != psDevInfo->ui32ClientBuildOptions)
+        {
+                ui32BuildOptionsMismatch = ui32BuildOptions ^ psDevInfo->ui32ClientBuildOptions;
+                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%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%x). Please check sgx_options.h",
+                                ui32BuildOptions & ui32BuildOptionsMismatch ));
+                }
+                eError = PVRSRV_ERROR_BUILD_MISMATCH;
+                goto chk_exit;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: Client-side and KM driver build options match. [ OK ]"));
+        }
+
+#if !defined (NO_HARDWARE)
+        psMemInfo = psDevInfo->psKernelSGXMiscMemInfo;
+
+        
+        psSGXMiscInfoInt = psMemInfo->pvLinAddrKM;
+        psSGXMiscInfoInt->ui32MiscInfoFlags = 0;
+        psSGXMiscInfoInt->ui32MiscInfoFlags |= PVRSRV_USSE_MISCINFO_GET_STRUCT_SIZES;
+        eError = SGXGetMiscInfoUkernel(psDevInfo, psDeviceNode);
+
+        
+        if(eError != PVRSRV_OK)
+        {
+                PVR_LOG(("(FAIL) SGXInit: Unable to validate device DDK version"));
+                goto chk_exit;
+        }
+        psSGXFeatures = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXFeatures;
+        if( (psSGXFeatures->ui32DDKVersion !=
+                ((PVRVERSION_MAJ << 16) |
+                 (PVRVERSION_MIN << 8) |
+                  PVRVERSION_BRANCH) ) ||
+                (psSGXFeatures->ui32DDKBuild != PVRVERSION_BUILD) )
+        {
+                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;
+                goto chk_exit;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: driver DDK (%d) and device DDK (%d) match. [ OK ]",
+                                PVRVERSION_BUILD, psSGXFeatures->ui32DDKBuild));
+        }
+
+        
+        if (psSGXFeatures->ui32CoreRevSW == 0)
+        {
+                
+
+                PVR_LOG(("SGXInit: HW core rev (%x) check skipped.",
+                                psSGXFeatures->ui32CoreRev));
+        }
+        else
+        {
+                
+                bCheckCoreRev = IMG_TRUE;
+                for(i=0; i<ui32NumCoreExceptions; i+=2)
+                {
+                        if( (psSGXFeatures->ui32CoreRev==aui32CoreRevExceptions[i]) &&
+                                (psSGXFeatures->ui32CoreRevSW==aui32CoreRevExceptions[i+1])     )
+                        {
+                                PVR_LOG(("SGXInit: HW core rev (%x), SW core rev (%x) check skipped.",
+                                                psSGXFeatures->ui32CoreRev,
+                                                psSGXFeatures->ui32CoreRevSW));
+                                bCheckCoreRev = IMG_FALSE;
+                        }
+                }
+
+                if (bCheckCoreRev)
+                {
+                        if (psSGXFeatures->ui32CoreRev != psSGXFeatures->ui32CoreRevSW)
+                        {
+                                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 (%x) and SW core rev (%x) match. [ OK ]",
+                                                psSGXFeatures->ui32CoreRev, psSGXFeatures->ui32CoreRevSW));
+                        }
+                }
+        }
+
+        
+        psSGXStructSizes = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXStructSizes;
+
+        bStructSizesFailed = IMG_FALSE;
+
+        CHECK_SIZE(HOST_CTL);
+        CHECK_SIZE(COMMAND);
+#if defined(SGX_FEATURE_2D_HARDWARE)
+        CHECK_SIZE(2DCMD);
+        CHECK_SIZE(2DCMD_SHARED);
+#endif
+        CHECK_SIZE(CMDTA);
+        CHECK_SIZE(CMDTA_SHARED);
+        CHECK_SIZE(TRANSFERCMD);
+        CHECK_SIZE(TRANSFERCMD_SHARED);
+
+        CHECK_SIZE(3DREGISTERS);
+        CHECK_SIZE(HWPBDESC);
+        CHECK_SIZE(HWRENDERCONTEXT);
+        CHECK_SIZE(HWRENDERDETAILS);
+        CHECK_SIZE(HWRTDATA);
+        CHECK_SIZE(HWRTDATASET);
+        CHECK_SIZE(HWTRANSFERCONTEXT);
+
+        if (bStructSizesFailed == IMG_TRUE)
+        {
+                PVR_LOG(("(FAIL) SGXInit: Mismatch in SGXMKIF structure sizes."));
+                eError = PVRSRV_ERROR_BUILD_MISMATCH;
+                goto chk_exit;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: SGXMKIF structure sizes match. [ OK ]"));
+        }
+
+        
+        ui32BuildOptions = psSGXFeatures->ui32BuildOptions;
+        if (ui32BuildOptions != (SGX_BUILD_OPTIONS))
+        {
+                ui32BuildOptionsMismatch = ui32BuildOptions ^ (SGX_BUILD_OPTIONS);
+                if ( ((SGX_BUILD_OPTIONS) & ui32BuildOptionsMismatch) != 0)
+                {
+                        PVR_LOG(("(FAIL) SGXInit: Mismatch in driver and microkernel build options; "
+                                "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%x). Please check sgx_options.h",
+                                ui32BuildOptions & ui32BuildOptionsMismatch ));
+                }
+                eError = PVRSRV_ERROR_BUILD_MISMATCH;
+                goto chk_exit;
+        }
+        else
+        {
+                PVR_DPF((PVR_DBG_MESSAGE, "SGXInit: Driver and microkernel build options match. [ OK ]"));
+        }
+#endif 
+
+        eError = PVRSRV_OK;
+chk_exit:
+#if defined(IGNORE_SGX_INIT_COMPATIBILITY_CHECK)
+        return PVRSRV_OK;
+#else
+        return eError;
+#endif
+}
+
+static
+PVRSRV_ERROR SGXGetMiscInfoUkernel(PVRSRV_SGXDEV_INFO   *psDevInfo,
+                                                                   PVRSRV_DEVICE_NODE   *psDeviceNode)
+{
+        PVRSRV_ERROR            eError;
+        SGXMKIF_COMMAND         sCommandData;  
+        PVRSRV_SGX_MISCINFO_INFO                        *psSGXMiscInfoInt;      
+        PVRSRV_SGX_MISCINFO_FEATURES            *psSGXFeatures;         
+        SGX_MISCINFO_STRUCT_SIZES                       *psSGXStructSizes;      
+
+        PPVRSRV_KERNEL_MEM_INFO psMemInfo = psDevInfo->psKernelSGXMiscMemInfo;
+
+        if (! psMemInfo->pvLinAddrKM)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXGetMiscInfoUkernel: Invalid address."));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        psSGXMiscInfoInt = psMemInfo->pvLinAddrKM;
+        psSGXFeatures = &psSGXMiscInfoInt->sSGXFeatures;
+        psSGXStructSizes = &psSGXMiscInfoInt->sSGXStructSizes;
+
+        psSGXMiscInfoInt->ui32MiscInfoFlags &= ~PVRSRV_USSE_MISCINFO_READY;
+
+        
+        OSMemSet(psSGXFeatures, 0, sizeof(*psSGXFeatures));
+        OSMemSet(psSGXStructSizes, 0, sizeof(*psSGXStructSizes));
+
+        
+        sCommandData.ui32Data[1] = psMemInfo->sDevVAddr.uiAddr; 
+
+        PDUMPCOMMENT("Microkernel kick for SGXGetMiscInfo");
+        eError = SGXScheduleCCBCommandKM(psDeviceNode,
+                                                                         SGXMKIF_CMD_GETMISCINFO,
+                                                                         &sCommandData,
+                                                                         KERNEL_ID,
+                                                                         0);
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXGetMiscInfoUkernel: SGXScheduleCCBCommandKM failed."));
+                return eError;
+        }
+
+        
+#if !defined(NO_HARDWARE)
+        {
+                IMG_BOOL bExit;
+
+                bExit = IMG_FALSE;
+                LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+                {
+                        if ((psSGXMiscInfoInt->ui32MiscInfoFlags & PVRSRV_USSE_MISCINFO_READY) != 0)
+                        {
+                                bExit = IMG_TRUE;
+                                break;
+                        }
+                } END_LOOP_UNTIL_TIMEOUT();
+
+                
+                if (!bExit)
+                {
+                        PVR_DPF((PVR_DBG_ERROR, "SGXGetMiscInfoUkernel: Timeout occurred waiting for misc info."));
+                        return PVRSRV_ERROR_TIMEOUT;
+                }
+        }
+#endif 
+
+        return PVRSRV_OK;
+}
+
+
+
+IMG_EXPORT
+PVRSRV_ERROR SGXGetMiscInfoKM(PVRSRV_SGXDEV_INFO        *psDevInfo,
+                                                          SGX_MISC_INFO                 *psMiscInfo,
+                                                          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;
+
+        
+        *pui32MiscInfoFlags = 0;
+
+#if !defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
+        PVR_UNREFERENCED_PARAMETER(hDevMemContext);
+#endif
+
+        switch(psMiscInfo->eRequest)
+        {
+#if defined(SGX_FEATURE_DATA_BREAKPOINTS)
+                case SGX_MISC_INFO_REQUEST_SET_BREAKPOINT:
+                {
+                        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;
+
+                                
+                                ui32StartRegVal = sBPDevVAddr.uiAddr & EUR_CR_BREAKPOINT0_START_ADDRESS_MASK;
+                                ui32EndRegVal = sBPDevVAddrEnd.uiAddr & EUR_CR_BREAKPOINT0_END_ADDRESS_MASK;
+
+                                ui32MaskDM = psMiscInfo->uData.sSGXBreakpointInfo.ui32DataMasterMask;
+                                ui32CtrlWEnable = psMiscInfo->uData.sSGXBreakpointInfo.bWrite;
+                                ui32CtrlREnable = psMiscInfo->uData.sSGXBreakpointInfo.bRead;
+                                ui32CtrlTrapEnable = psMiscInfo->uData.sSGXBreakpointInfo.bTrapped;
+
+                                
+                                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 = 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 
+
+                case SGX_MISC_INFO_REQUEST_CLOCKSPEED:
+                {
+                        psMiscInfo->uData.ui32SGXClockSpeed = psDevInfo->ui32CoreClockSpeed;
+                        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_SGX_MISCINFO_FEATURES            *psSGXFeatures;
+                        eError = SGXGetMiscInfoUkernel(psDevInfo, psDeviceNode);
+                        if(eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "An error occurred in SGXGetMiscInfoUkernel: %d\n",
+                                                eError));
+                                return eError;
+                        }
+                        psSGXFeatures = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXFeatures;
+
+                        
+                        psMiscInfo->uData.sSGXFeatures = *psSGXFeatures;
+
+                        
+                        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%x, DDK build 0x%x\n",
+                                        psSGXFeatures->ui32DDKVersion,
+                                        psSGXFeatures->ui32DDKBuild));
+
+                        
+                        return PVRSRV_OK;
+                }
+
+                case SGX_MISC_INFO_REQUEST_DRIVER_SGXREV:
+                {
+                        PVRSRV_SGX_MISCINFO_FEATURES            *psSGXFeatures;
+
+                        psSGXFeatures = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXFeatures;
+
+                        
+                        OSMemSet(psMemInfo->pvLinAddrKM, 0,
+                                        sizeof(PVRSRV_SGX_MISCINFO_INFO));
+
+                        psSGXFeatures->ui32DDKVersion =
+                                (PVRVERSION_MAJ << 16) |
+                                (PVRVERSION_MIN << 8) |
+                                PVRVERSION_BRANCH;
+                        psSGXFeatures->ui32DDKBuild = PVRVERSION_BUILD;
+
+                        
+                        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;
+                        PVRSRV_SGX_MISCINFO_FEATURES            *psSGXFeatures;
+                        PVRSRV_SGX_MISCINFO_MEMACCESS           *psSGXMemSrc;   
+                        PVRSRV_SGX_MISCINFO_MEMACCESS           *psSGXMemDest;  
+
+                        {                               
+                                
+                                *pui32MiscInfoFlags |= PVRSRV_USSE_MISCINFO_MEMREAD;
+                                psSGXMemSrc = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXMemAccessSrc;
+
+                                if(psMiscInfo->sDevVAddrSrc.uiAddr != 0)
+                                {
+                                        psSGXMemSrc->sDevVAddr = psMiscInfo->sDevVAddrSrc; 
+                                }
+                                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->hDevMemContext != IMG_NULL)
+                        {
+                                SGXGetMMUPDAddrKM( (IMG_HANDLE)psDeviceNode, hDevMemContext, &psSGXMemSrc->sPDDevPAddr);
+                                
+                                
+                                psSGXMemDest->sPDDevPAddr = psSGXMemSrc->sPDDevPAddr;
+                        }
+                        else
+                        {
+                                return PVRSRV_ERROR_INVALID_PARAMS;
+                        }
+
+                        
+                        eError = SGXGetMiscInfoUkernel(psDevInfo, psDeviceNode);
+                        if(eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR, "An error occurred in SGXGetMiscInfoUkernel: %d\n",
+                                                eError));
+                                return eError;
+                        }
+                        psSGXFeatures = &((PVRSRV_SGX_MISCINFO_INFO*)(psMemInfo->pvLinAddrKM))->sSGXFeatures;
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+                        if(*pui32MiscInfoFlags & PVRSRV_USSE_MISCINFO_MEMREAD_FAIL)
+                        {
+                                return PVRSRV_ERROR_INVALID_MISCINFO;
+                        }
+#endif
+                        
+                        psMiscInfo->uData.sSGXFeatures = *psSGXFeatures;
+                        return PVRSRV_OK;
+                }
+#endif 
+
+#if defined(SUPPORT_SGX_HWPERF)
+                case SGX_MISC_INFO_REQUEST_SET_HWPERF_STATUS:
+                {
+                        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 ((psSetHWPerfStatus->ui32NewHWPerfStatus & ~ui32ValidFlags) != 0)
+                        {
+                                return PVRSRV_ERROR_INVALID_PARAMS;
+                        }
+
+                        #if defined(PDUMP)
+                        PDUMPCOMMENTWITHFLAGS(PDUMP_FLAGS_CONTINUOUS,
+                                                                  "SGX ukernel HWPerf status %u\n",
+                                                                  psSetHWPerfStatus->ui32NewHWPerfStatus);
+                        #endif 
+
+                        
+                        #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)
+                        PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+                                         offsetof(SGXMKIF_HOST_CTL, ui32PerfGroup),
+                                         sizeof(psDevInfo->psSGXHostCtl->ui32PerfGroup),
+                                         PDUMP_FLAGS_CONTINUOUS,
+                                         MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+                        #endif 
+                        #endif 
+
+                        
+                        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->pvDevice, IMG_FALSE);
+
+                        return PVRSRV_OK;
+                }
+
+                case SGX_MISC_INFO_PANIC:
+                {
+                        PVR_LOG(("User requested SGX panic"));
+
+                        SGXPanic(psDeviceNode->pvDevice);
+
+                        return PVRSRV_OK;
+                }
+
+                default:
+                {
+                        
+                        return PVRSRV_ERROR_INVALID_PARAMS;
+                }
+        }
+}
+
+
+IMG_EXPORT
+PVRSRV_ERROR SGXReadHWPerfCBKM(IMG_HANDLE                                       hDevHandle,
+                                                           IMG_UINT32                                   ui32ArraySize,
+                                                           PVRSRV_SGX_HWPERF_CB_ENTRY   *psClientHWPerfEntry,
+                                                           IMG_UINT32                                   *pui32DataCount,
+                                                           IMG_UINT32                                   *pui32ClockSpeed,
+                                                           IMG_UINT32                                   *pui32HostTimeStamp)
+{
+        PVRSRV_ERROR            eError = PVRSRV_OK;
+        PVRSRV_DEVICE_NODE      *psDeviceNode = hDevHandle;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+        SGXMKIF_HWPERF_CB       *psHWPerfCB = psDevInfo->psKernelHWPerfCBMemInfo->pvLinAddrKM;
+        IMG_UINT                        i;
+
+        for (i = 0;
+                 psHWPerfCB->ui32Woff != psHWPerfCB->ui32Roff && i < ui32ArraySize;
+                 i++)
+        {
+                SGXMKIF_HWPERF_CB_ENTRY *psMKPerfEntry = &psHWPerfCB->psHWPerfCBData[psHWPerfCB->ui32Roff];
+
+                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][0],
+                                  &psMKPerfEntry->ui32Counters[0][0],
+                                  sizeof(psMKPerfEntry->ui32Counters));
+
+                psHWPerfCB->ui32Roff = (psHWPerfCB->ui32Roff + 1) & (SGXMKIF_HWPERF_CB_SIZE - 1);
+        }
+
+        *pui32DataCount = i;
+        *pui32ClockSpeed = psDevInfo->ui32CoreClockSpeed;
+        *pui32HostTimeStamp = OSClockus();
+
+        return eError;
+}
+
+
diff --git a/drivers/gpu/pvr/sgx/sgxkick.c b/drivers/gpu/pvr/sgx/sgxkick.c
new file mode 100644
index 00000000000..8a229c9fd3c
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxkick.c
@@ -0,0 +1,713 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h> 
+#include "services_headers.h"
+#include "sgxinfo.h"
+#include "sgxinfokm.h"
+#if defined (PDUMP)
+#include "sgxapi_km.h"
+#include "pdump_km.h"
+#endif
+#include "sgx_bridge_km.h"
+#include "osfunc.h"
+#include "pvr_debug.h"
+#include "sgxutils.h"
+
+IMG_EXPORT
+PVRSRV_ERROR SGXDoKickKM(IMG_HANDLE hDevHandle, SGX_CCB_KICK *psCCBKick)
+{
+        PVRSRV_ERROR eError;
+        PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+        PVRSRV_KERNEL_MEM_INFO  *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *) psCCBKick->hCCBKernelMemInfo;
+        SGXMKIF_CMDTA_SHARED *psTACmd;
+        IMG_UINT32 i;
+
+        if (!CCB_OFFSET_IS_VALID(SGXMKIF_CMDTA_SHARED, psCCBMemInfo, psCCBKick, ui32CCBOffset))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXDoKickKM: Invalid CCB offset"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        
+        psTACmd = CCB_DATA_FROM_OFFSET(SGXMKIF_CMDTA_SHARED, psCCBMemInfo, psCCBKick, ui32CCBOffset);
+
+        
+        if (psCCBKick->hTA3DSyncInfo)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTA3DSyncInfo;
+                psTACmd->sTA3DDependency.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+
+                psTACmd->sTA3DDependency.ui32WriteOpsPendingVal   = psSyncInfo->psSyncData->ui32WriteOpsPending;
+
+                if (psCCBKick->bTADependency)
+                {
+                        psSyncInfo->psSyncData->ui32WriteOpsPending++;
+                }
+        }
+
+        if (psCCBKick->hTASyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTASyncInfo;
+
+                psTACmd->sTATQSyncReadOpsCompleteDevVAddr  = psSyncInfo->sReadOpsCompleteDevVAddr;
+                psTACmd->sTATQSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+
+                psTACmd->ui32TATQSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                psTACmd->ui32TATQSyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+
+        if (psCCBKick->h3DSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->h3DSyncInfo;
+
+                psTACmd->s3DTQSyncReadOpsCompleteDevVAddr  = psSyncInfo->sReadOpsCompleteDevVAddr;
+                psTACmd->s3DTQSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+
+                psTACmd->ui323DTQSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                psTACmd->ui323DTQSyncWriteOpsPendingVal  = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+
+        psTACmd->ui32NumTAStatusVals = psCCBKick->ui32NumTAStatusVals;
+        if (psCCBKick->ui32NumTAStatusVals != 0)
+        {
+                
+                for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
+                {
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                        psTACmd->sCtlTAStatusInfo[i] = psCCBKick->asTAStatusUpdate[i].sCtlStatus;
+#else
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
+                        psTACmd->sCtlTAStatusInfo[i].sStatusDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+                        psTACmd->sCtlTAStatusInfo[i].ui32StatusValue = psSyncInfo->psSyncData->ui32ReadOpsPending;
+#endif
+                }
+        }
+
+        psTACmd->ui32Num3DStatusVals = psCCBKick->ui32Num3DStatusVals;
+        if (psCCBKick->ui32Num3DStatusVals != 0)
+        {
+                
+                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
+                {
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                        psTACmd->sCtl3DStatusInfo[i] = psCCBKick->as3DStatusUpdate[i].sCtlStatus;
+#else
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
+                        psTACmd->sCtl3DStatusInfo[i].sStatusDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+                        psTACmd->sCtl3DStatusInfo[i].ui32StatusValue = psSyncInfo->psSyncData->ui32ReadOpsPending;
+#endif
+                }
+        }
+
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+        
+        psTACmd->ui32NumTASrcSyncs = psCCBKick->ui32NumTASrcSyncs;
+        for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
+
+                psTACmd->asTASrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psTACmd->asTASrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                
+                psTACmd->asTASrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                
+                psTACmd->asTASrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+
+        psTACmd->ui32NumTADstSyncs = psCCBKick->ui32NumTADstSyncs;
+        for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
+
+                psTACmd->asTADstSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psTACmd->asTADstSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                
+                psTACmd->asTADstSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+                
+                psTACmd->asTADstSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+        }
+
+        psTACmd->ui32Num3DSrcSyncs = psCCBKick->ui32Num3DSrcSyncs;
+        for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
+
+                psTACmd->as3DSrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psTACmd->as3DSrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                
+                psTACmd->as3DSrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                
+                psTACmd->as3DSrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+#else 
+        
+        psTACmd->ui32NumSrcSyncs = psCCBKick->ui32NumSrcSyncs;
+        for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
+
+                psTACmd->asSrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psTACmd->asSrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                
+                psTACmd->asSrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                
+                psTACmd->asSrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+#endif
+
+        if (psCCBKick->bFirstKickOrResume && psCCBKick->ui32NumDstSyncObjects > 0)
+        {
+                PVRSRV_KERNEL_MEM_INFO  *psHWDstSyncListMemInfo =
+                                                                (PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo;
+                SGXMKIF_HWDEVICE_SYNC_LIST *psHWDeviceSyncList = psHWDstSyncListMemInfo->pvLinAddrKM;
+                IMG_UINT32      ui32NumDstSyncs = psCCBKick->ui32NumDstSyncObjects;
+
+                PVR_ASSERT(((PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo)->ui32AllocSize >= (sizeof(SGXMKIF_HWDEVICE_SYNC_LIST) +
+                                                                (sizeof(PVRSRV_DEVICE_SYNC_OBJECT) * ui32NumDstSyncs)));
+
+                psHWDeviceSyncList->ui32NumSyncObjects = ui32NumDstSyncs;
+#if defined(PDUMP)
+                if (PDumpIsCaptureFrameKM())
+                {
+                        PDUMPCOMMENT("HWDeviceSyncList for TACmd\r\n");
+                        PDUMPMEM(IMG_NULL,
+                                         psHWDstSyncListMemInfo,
+                                         0,
+                                         sizeof(SGXMKIF_HWDEVICE_SYNC_LIST),
+                                         0,
+                                         MAKEUNIQUETAG(psHWDstSyncListMemInfo));
+                }
+#endif
+
+                for (i=0; i<ui32NumDstSyncs; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
+
+                        if (psSyncInfo)
+                        {
+                                psHWDeviceSyncList->asSyncData[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                                psHWDeviceSyncList->asSyncData[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                                psHWDeviceSyncList->asSyncData[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+                                psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+
+        #if defined(PDUMP)
+                                if (PDumpIsCaptureFrameKM())
+                                {
+                                        IMG_UINT32 ui32ModifiedValue;
+                                        IMG_UINT32 ui32SyncOffset = offsetof(SGXMKIF_HWDEVICE_SYNC_LIST, asSyncData)
+                                                                                                + (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT));
+                                        IMG_UINT32 ui32WOpsOffset = ui32SyncOffset
+                                                                                                + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal);
+                                        IMG_UINT32 ui32ROpsOffset = ui32SyncOffset
+                                                                                                + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal);
+
+                                        PDUMPCOMMENT("HWDeviceSyncObject for RT: %i\r\n", i);
+
+                                        PDUMPMEM(IMG_NULL,
+                                                         psHWDstSyncListMemInfo,
+                                                         ui32SyncOffset,
+                                                         sizeof(PVRSRV_DEVICE_SYNC_OBJECT),
+                                                         0,
+                                                         MAKEUNIQUETAG(psHWDstSyncListMemInfo));
+
+                                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
+                                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
+                                        {
+                                                
+                                                PDUMPCOMMENT("Init RT ROpsComplete\r\n");
+                                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                                        psSyncInfo->psSyncDataMemInfoKM,
+                                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+                                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
+                                                        0,
+                                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                                
+                                                PDUMPCOMMENT("Init RT WOpsComplete\r\n");
+                                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                                                psSyncInfo->psSyncDataMemInfoKM,
+                                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+                                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
+                                                                0,
+                                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                        }
+
+                                        psSyncInfo->psSyncData->ui32LastOpDumpVal++;
+
+                                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastOpDumpVal - 1;
+
+                                        PDUMPCOMMENT("Modify RT %d WOpPendingVal in HWDevSyncList\r\n", i);
+
+                                        PDUMPMEM(&ui32ModifiedValue,
+                                                psHWDstSyncListMemInfo,
+                                                ui32WOpsOffset,
+                                                sizeof(IMG_UINT32),
+                                                0,
+                                                MAKEUNIQUETAG(psHWDstSyncListMemInfo));
+
+                                        ui32ModifiedValue = 0;
+                                        PDUMPCOMMENT("Modify RT %d ROpsPendingVal in HWDevSyncList\r\n", i);
+
+                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                                 psHWDstSyncListMemInfo,
+                                                 ui32ROpsOffset,
+                                                 sizeof(IMG_UINT32),
+                                                 0,
+                                                MAKEUNIQUETAG(psHWDstSyncListMemInfo));
+                                }
+        #endif  
+                        }
+                        else
+                        {
+                                psHWDeviceSyncList->asSyncData[i].sWriteOpsCompleteDevVAddr.uiAddr = 0;
+                                psHWDeviceSyncList->asSyncData[i].sReadOpsCompleteDevVAddr.uiAddr = 0;
+
+                                psHWDeviceSyncList->asSyncData[i].ui32ReadOpsPendingVal = 0;
+                                psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal = 0;
+                        }
+                }
+        }
+        
+        
+
+
+        psTACmd->ui32CtrlFlags |= SGXMKIF_CMDTA_CTRLFLAGS_READY;
+
+#if defined(PDUMP)
+        if (PDumpIsCaptureFrameKM())
+        {
+                PDUMPCOMMENT("Shared part of TA command\r\n");
+
+                PDUMPMEM(psTACmd,
+                                 psCCBMemInfo,
+                                 psCCBKick->ui32CCBDumpWOff,
+                                 sizeof(SGXMKIF_CMDTA_SHARED),
+                                 0,
+                                 MAKEUNIQUETAG(psCCBMemInfo));
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+                for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
+                {
+                        IMG_UINT32      ui32ModifiedValue;
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
+
+                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
+                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
+                        {
+                                
+                                PDUMPCOMMENT("Init RT TA-SRC ROpsComplete\r\n", i);
+                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psSyncInfo->psSyncDataMemInfoKM,
+                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
+                                        0,
+                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                
+                                PDUMPCOMMENT("Init RT TA-SRC WOpsComplete\r\n");
+                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                                psSyncInfo->psSyncDataMemInfoKM,
+                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
+                                                0,
+                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                        }
+
+                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+
+                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
+
+                        PDUMPCOMMENT("Modify TA SrcSync %d ROpsPendingVal\r\n", i);
+
+                        PDUMPMEM(&ui32ModifiedValue,
+                                 psCCBMemInfo,
+                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTASrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Modify TA SrcSync %d WOpPendingVal\r\n", i);
+
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                psCCBMemInfo,
+                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTASrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
+                                sizeof(IMG_UINT32),
+                                0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+                }
+
+                for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
+                {
+                        IMG_UINT32      ui32ModifiedValue;
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
+
+                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
+                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
+                        {
+                                
+                                PDUMPCOMMENT("Init RT TA-DST ROpsComplete\r\n", i);
+                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psSyncInfo->psSyncDataMemInfoKM,
+                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
+                                        0,
+                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                
+                                PDUMPCOMMENT("Init RT TA-DST WOpsComplete\r\n");
+                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                                psSyncInfo->psSyncDataMemInfoKM,
+                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
+                                                0,
+                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                        }
+
+                        psSyncInfo->psSyncData->ui32LastOpDumpVal++;
+
+                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastOpDumpVal - 1;
+
+                        PDUMPCOMMENT("Modify TA DstSync %d WOpPendingVal\r\n", i);
+
+                        PDUMPMEM(&ui32ModifiedValue,
+                                 psCCBMemInfo,
+                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTADstSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Modify TA DstSync %d ROpsPendingVal\r\n", i);
+
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                psCCBMemInfo,
+                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTADstSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+                                sizeof(IMG_UINT32),
+                                0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+                }
+
+                for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
+                {
+                        IMG_UINT32      ui32ModifiedValue;
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
+
+                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
+                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
+                        {
+                                
+                                PDUMPCOMMENT("Init RT 3D-SRC ROpsComplete\r\n", i);
+                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psSyncInfo->psSyncDataMemInfoKM,
+                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
+                                        0,
+                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                
+                                PDUMPCOMMENT("Init RT 3D-SRC WOpsComplete\r\n");
+                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                                psSyncInfo->psSyncDataMemInfoKM,
+                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
+                                                0,
+                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                        }
+
+                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+
+                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
+
+                        PDUMPCOMMENT("Modify 3D SrcSync %d ROpsPendingVal\r\n", i);
+
+                        PDUMPMEM(&ui32ModifiedValue,
+                                 psCCBMemInfo,
+                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, as3DSrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Modify 3D SrcSync %d WOpPendingVal\r\n", i);
+
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                psCCBMemInfo,
+                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, as3DSrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
+                                sizeof(IMG_UINT32),
+                                0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+                }
+#else
+                for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
+                {
+                        IMG_UINT32      ui32ModifiedValue;
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
+
+                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
+                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
+                        {
+                                
+                                PDUMPCOMMENT("Init RT ROpsComplete\r\n");
+                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psSyncInfo->psSyncDataMemInfoKM,
+                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
+                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
+                                        0,
+                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                                
+                                PDUMPCOMMENT("Init RT WOpsComplete\r\n");
+                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                                psSyncInfo->psSyncDataMemInfoKM,
+                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
+                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
+                                                0,
+                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
+                        }
+
+                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+
+                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
+
+                        PDUMPCOMMENT("Modify SrcSync %d ROpsPendingVal\r\n", i);
+
+                        PDUMPMEM(&ui32ModifiedValue,
+                                 psCCBMemInfo,
+                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asSrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Modify SrcSync %d WOpPendingVal\r\n", i);
+
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                psCCBMemInfo,
+                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asSrcSyncs) +
+                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
+                                sizeof(IMG_UINT32),
+                                0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+                }
+#endif
+
+                for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
+                {
+#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 + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtlTAStatusInfo[i].ui32StatusValue),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+#endif
+                }
+
+                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
+                {
+#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 + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtl3DStatusInfo[i].ui32StatusValue),
+                                 sizeof(IMG_UINT32),
+                                 0,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+#endif
+                }
+        }
+#endif  
+
+        eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_TA, &psCCBKick->sCommand, KERNEL_ID, 0);
+        if (eError == PVRSRV_ERROR_RETRY)
+        {
+                if (psCCBKick->bFirstKickOrResume && psCCBKick->ui32NumDstSyncObjects > 0)
+                {
+                        for (i=0; i < psCCBKick->ui32NumDstSyncObjects; i++)
+                        {
+                                
+                                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
+
+                                if (psSyncInfo)
+                                {
+                                        psSyncInfo->psSyncData->ui32WriteOpsPending--;
+#if defined(PDUMP)
+                                        if (PDumpIsCaptureFrameKM())
+                                        {
+                                                psSyncInfo->psSyncData->ui32LastOpDumpVal--;
+                                        }
+#endif
+                                }
+                        }
+                }
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+                for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
+                }
+                for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32WriteOpsPending--;
+                }
+                for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
+                }
+#else
+                for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
+                }
+#endif
+
+                return eError;
+        }
+        else if (PVRSRV_OK != eError)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXDoKickKM: SGXScheduleCCBCommandKM failed."));
+                return eError;
+        }
+
+
+#if defined(NO_HARDWARE)
+
+
+        
+        if (psCCBKick->hTA3DSyncInfo)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTA3DSyncInfo;
+
+                if (psCCBKick->bTADependency)
+                {
+                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                }
+        }
+
+        if (psCCBKick->hTASyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTASyncInfo;
+
+                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+
+        if (psCCBKick->h3DSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->h3DSyncInfo;
+
+                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+
+        
+        for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
+        {
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = (PVRSRV_KERNEL_MEM_INFO*)psCCBKick->asTAStatusUpdate[i].hKernelMemInfo;
+                
+                *(IMG_UINT32*)((IMG_UINTPTR_T)psKernelMemInfo->pvLinAddrKM
+                                                + (psTACmd->sCtlTAStatusInfo[i].sStatusDevAddr.uiAddr
+                                                - psKernelMemInfo->sDevVAddr.uiAddr)) = psTACmd->sCtlTAStatusInfo[i].ui32StatusValue;
+#else
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
+                psSyncInfo->psSyncData->ui32ReadOpsComplete = psTACmd->sCtlTAStatusInfo[i].ui32StatusValue;
+#endif
+        }
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+        
+        for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
+                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+        for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
+                psSyncInfo->psSyncData->ui32WriteOpsComplete =  psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+        for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
+                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+#else
+        
+        for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
+                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+#endif
+
+        if (psCCBKick->bTerminateOrAbort)
+        {
+                if (psCCBKick->ui32NumDstSyncObjects > 0)
+                {
+                        PVRSRV_KERNEL_MEM_INFO  *psHWDstSyncListMemInfo =
+                                                                (PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo;
+                        SGXMKIF_HWDEVICE_SYNC_LIST *psHWDeviceSyncList = psHWDstSyncListMemInfo->pvLinAddrKM;
+
+                        for (i=0; i<psCCBKick->ui32NumDstSyncObjects; i++)
+                        {
+                                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
+                                if (psSyncInfo)
+                                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal+1;
+                        }
+                }
+
+                
+                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
+                {
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+                        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = (PVRSRV_KERNEL_MEM_INFO*)psCCBKick->as3DStatusUpdate[i].hKernelMemInfo;
+                        
+                        *(IMG_UINT32*)((IMG_UINTPTR_T)psKernelMemInfo->pvLinAddrKM
+                                                        + (psTACmd->sCtl3DStatusInfo[i].sStatusDevAddr.uiAddr
+                                                        - psKernelMemInfo->sDevVAddr.uiAddr)) = psTACmd->sCtl3DStatusInfo[i].ui32StatusValue;
+#else
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32ReadOpsComplete = psTACmd->sCtl3DStatusInfo[i].ui32StatusValue;
+#endif
+                }
+        }
+#endif
+
+        return eError;
+}
+
diff --git a/drivers/gpu/pvr/sgx/sgxpower.c b/drivers/gpu/pvr/sgx/sgxpower.c
new file mode 100644
index 00000000000..aeac6e3db2b
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxpower.c
@@ -0,0 +1,472 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "sgxapi_km.h"
+#include "sgx_mkif_km.h"
+#include "sgxutils.h"
+#include "pdump_km.h"
+
+
+#if defined(SUPPORT_HW_RECOVERY)
+static PVRSRV_ERROR SGXAddTimer(PVRSRV_DEVICE_NODE              *psDeviceNode,
+                                                                SGX_TIMING_INFORMATION  *psSGXTimingInfo,
+                                                                IMG_HANDLE                              *phTimer)
+{
+        
+
+
+        *phTimer = OSAddTimer(SGXOSTimer, psDeviceNode,
+                                                  1000 * 50 / psSGXTimingInfo->ui32uKernelFreq);
+        if(*phTimer == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXAddTimer : Failed to register timer callback function"));
+                return PVRSRV_ERROR_OUT_OF_MEMORY;
+        }
+
+        return PVRSRV_OK;
+}
+#endif 
+
+
+static PVRSRV_ERROR SGXUpdateTimingInfo(PVRSRV_DEVICE_NODE      *psDeviceNode)
+{
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+#if defined(SGX_DYNAMIC_TIMING_INFO)
+        SGX_TIMING_INFORMATION  sSGXTimingInfo = {0};
+#else
+        SGX_DEVICE_MAP          *psSGXDeviceMap;
+#endif
+        IMG_UINT32              ui32ActivePowManSampleRate;
+        SGX_TIMING_INFORMATION  *psSGXTimingInfo;
+
+
+#if defined(SGX_DYNAMIC_TIMING_INFO)
+        psSGXTimingInfo = &sSGXTimingInfo;
+        SysGetSGXTimingInformation(psSGXTimingInfo);
+#else
+        SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE_SGX,
+                                                  (IMG_VOID**)&psSGXDeviceMap);
+        psSGXTimingInfo = &psSGXDeviceMap->sTimingInfo;
+#endif
+
+#if defined(SUPPORT_HW_RECOVERY)
+        {
+                PVRSRV_ERROR                    eError;
+                IMG_UINT32      ui32OlduKernelFreq;
+
+                if (psDevInfo->hTimer != IMG_NULL)
+                {
+                        ui32OlduKernelFreq = psDevInfo->ui32CoreClockSpeed / psDevInfo->ui32uKernelTimerClock;
+                        if (ui32OlduKernelFreq != psSGXTimingInfo->ui32uKernelFreq)
+                        {
+                                
+
+                                IMG_HANDLE hNewTimer;
+                                
+                                eError = SGXAddTimer(psDeviceNode, psSGXTimingInfo, &hNewTimer);
+                                if (eError == PVRSRV_OK)
+                                {
+                                        eError = OSRemoveTimer(psDevInfo->hTimer);
+                                        if (eError != PVRSRV_OK)
+                                        {
+                                                PVR_DPF((PVR_DBG_ERROR,"SGXUpdateTimingInfo: Failed to remove timer"));
+                                        }
+                                        psDevInfo->hTimer = hNewTimer;
+                                }
+                                else
+                                {
+                                        
+                                }
+                        }
+                }
+                else
+                {
+                        eError = SGXAddTimer(psDeviceNode, psSGXTimingInfo, &psDevInfo->hTimer);
+                        if (eError != PVRSRV_OK)
+                        {
+                                return eError;
+                        }
+                }
+
+                psDevInfo->psSGXHostCtl->ui32HWRecoverySampleRate =
+                        psSGXTimingInfo->ui32uKernelFreq / psSGXTimingInfo->ui32HWRecoveryFreq;
+        }
+#endif 
+
+        
+        psDevInfo->ui32CoreClockSpeed = psSGXTimingInfo->ui32CoreClockSpeed;
+        psDevInfo->ui32uKernelTimerClock = psSGXTimingInfo->ui32CoreClockSpeed / psSGXTimingInfo->ui32uKernelFreq;
+
+        
+        psDevInfo->psSGXHostCtl->ui32uKernelTimerClock = psDevInfo->ui32uKernelTimerClock;
+#if defined(PDUMP)
+        PDUMPCOMMENT("Host Control - Microkernel clock");
+        PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+                         offsetof(SGXMKIF_HOST_CTL, ui32uKernelTimerClock),
+                         sizeof(IMG_UINT32), PDUMP_FLAGS_CONTINUOUS,
+                         MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+#endif 
+
+        if (psSGXTimingInfo->bEnableActivePM)
+        {
+                ui32ActivePowManSampleRate =
+                        psSGXTimingInfo->ui32uKernelFreq * psSGXTimingInfo->ui32ActivePowManLatencyms / 1000;
+                
+
+
+
+
+
+
+                ui32ActivePowManSampleRate += 1;
+        }
+        else
+        {
+                ui32ActivePowManSampleRate = 0;
+        }
+
+        psDevInfo->psSGXHostCtl->ui32ActivePowManSampleRate = ui32ActivePowManSampleRate;
+#if defined(PDUMP)
+        PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+                         offsetof(SGXMKIF_HOST_CTL, ui32ActivePowManSampleRate),
+                         sizeof(IMG_UINT32), PDUMP_FLAGS_CONTINUOUS,
+                         MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+#endif 
+
+        return PVRSRV_OK;
+}
+
+
+static IMG_VOID SGXStartTimer(PVRSRV_SGXDEV_INFO        *psDevInfo)
+{
+        #if defined(SUPPORT_HW_RECOVERY)
+        PVRSRV_ERROR    eError;
+
+        eError = OSEnableTimer(psDevInfo->hTimer);
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXStartTimer : Failed to enable host timer"));
+        }
+        #else
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+        #endif 
+}
+
+
+static IMG_VOID SGXPollForClockGating (PVRSRV_SGXDEV_INFO       *psDevInfo,
+                                                                           IMG_UINT32                   ui32Register,
+                                                                           IMG_UINT32                   ui32RegisterValue,
+                                                                           IMG_CHAR                             *pszComment)
+{
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+        PVR_UNREFERENCED_PARAMETER(ui32Register);
+        PVR_UNREFERENCED_PARAMETER(ui32RegisterValue);
+        PVR_UNREFERENCED_PARAMETER(pszComment);
+
+        #if !defined(NO_HARDWARE)
+        PVR_ASSERT(psDevInfo != IMG_NULL);
+
+         
+        if (PollForValueKM((IMG_UINT32 *)psDevInfo->pvRegsBaseKM + (ui32Register >> 2),
+                                                0,
+                                                ui32RegisterValue,
+                                                MAX_HW_TIME_US/WAIT_TRY_COUNT,
+                                                WAIT_TRY_COUNT) != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXPollForClockGating: %s failed.", pszComment));
+                PVR_DBG_BREAK;
+        }
+        #endif 
+
+        PDUMPCOMMENT("%s", pszComment);
+        PDUMPREGPOL(SGX_PDUMPREG_NAME, ui32Register, 0, ui32RegisterValue);
+}
+
+
+PVRSRV_ERROR SGXPrePowerState (IMG_HANDLE                               hDevHandle,
+                                                           PVRSRV_DEV_POWER_STATE       eNewPowerState,
+                                                           PVRSRV_DEV_POWER_STATE       eCurrentPowerState)
+{
+        if ((eNewPowerState != eCurrentPowerState) &&
+                (eNewPowerState != PVRSRV_DEV_POWER_STATE_ON))
+        {
+                PVRSRV_ERROR            eError;
+                PVRSRV_DEVICE_NODE      *psDeviceNode = hDevHandle;
+                PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+                IMG_UINT32                      ui32PowerCmd, ui32CompleteStatus;
+                SGXMKIF_COMMAND         sCommand = {0};
+                IMG_UINT32                      ui32Core;
+
+                #if defined(SUPPORT_HW_RECOVERY)
+                
+                eError = OSDisableTimer(psDevInfo->hTimer);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: Failed to disable timer"));
+                        return eError;
+                }
+                #endif 
+
+                if (eNewPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+                {
+                        
+                        ui32PowerCmd = PVRSRV_POWERCMD_POWEROFF;
+                        ui32CompleteStatus = PVRSRV_USSE_EDM_POWMAN_POWEROFF_COMPLETE;
+                        PDUMPCOMMENT("SGX power off request");
+                }
+                else
+                {
+                        
+                        ui32PowerCmd = PVRSRV_POWERCMD_IDLE;
+                        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)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: Failed to submit power down command"));
+                        return eError;
+                }
+
+                
+                #if !defined(NO_HARDWARE)
+                if (PollForValueKM(&psDevInfo->psSGXHostCtl->ui32PowerStatus,
+                                                        ui32CompleteStatus,
+                                                        ui32CompleteStatus,
+                                                        MAX_HW_TIME_US/WAIT_TRY_COUNT,
+                                                        WAIT_TRY_COUNT) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXPrePowerState: Wait for SGX ukernel power transition failed."));
+                        PVR_DBG_BREAK;
+                }
+                #endif 
+
+                #if defined(PDUMP)
+                PDUMPCOMMENT("TA/3D CCB Control - Wait for power event on uKernel.");
+                PDUMPMEMPOL(psDevInfo->psKernelSGXHostCtlMemInfo,
+                                        offsetof(SGXMKIF_HOST_CTL, ui32PowerStatus),
+                                        ui32CompleteStatus,
+                                        ui32CompleteStatus,
+                                        PDUMP_POLL_OPERATOR_EQUAL,
+                                        0,
+                                        MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+                #endif 
+
+                for (ui32Core = 0; ui32Core < SGX_FEATURE_MP_CORE_COUNT; ui32Core++)
+                {
+                        
+                        SGXPollForClockGating(psDevInfo,
+                                                                  SGX_MP_CORE_SELECT(psDevInfo->ui32ClkGateStatusReg, ui32Core),
+                                                                  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: %u", eError));
+                                return eError;
+                        }
+                }
+        }
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SGXPostPowerState (IMG_HANDLE                              hDevHandle,
+                                                                PVRSRV_DEV_POWER_STATE  eNewPowerState,
+                                                                PVRSRV_DEV_POWER_STATE  eCurrentPowerState)
+{
+        if ((eNewPowerState != eCurrentPowerState) &&
+                (eCurrentPowerState != PVRSRV_DEV_POWER_STATE_ON))
+        {
+                PVRSRV_ERROR            eError;
+                PVRSRV_DEVICE_NODE      *psDeviceNode = hDevHandle;
+                PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+                SGXMKIF_HOST_CTL *psSGXHostCtl = psDevInfo->psSGXHostCtl;
+
+                
+                psSGXHostCtl->ui32PowerStatus = 0;
+                #if defined(PDUMP)
+                PDUMPCOMMENT("Host Control - Reset power status");
+                PDUMPMEM(IMG_NULL, psDevInfo->psKernelSGXHostCtlMemInfo,
+                                 offsetof(SGXMKIF_HOST_CTL, ui32PowerStatus),
+                                 sizeof(IMG_UINT32), PDUMP_FLAGS_CONTINUOUS,
+                                 MAKEUNIQUETAG(psDevInfo->psKernelSGXHostCtlMemInfo));
+                #endif 
+
+                if (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_OFF)
+                {
+                        
+
+                        
+
+                        eError = SGXUpdateTimingInfo(psDeviceNode);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState: SGXUpdateTimingInfo failed"));
+                                return eError;
+                        }
+
+                        
+
+                        eError = SGXInitialise(psDevInfo, IMG_FALSE);
+                        if (eError != PVRSRV_OK)
+                        {
+                                PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState: SGXInitialise failed"));
+                                return eError;
+                        }
+                }
+                else
+                {
+                        
+
+                        SGXMKIF_COMMAND         sCommand = {0};
+
+                        sCommand.ui32Data[1] = PVRSRV_POWERCMD_RESUME;
+                        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: %u", eError));
+                                return eError;
+                        }
+                }
+
+                SGXStartTimer(psDevInfo);
+        }
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SGXPreClockSpeedChange (IMG_HANDLE                         hDevHandle,
+                                                                         IMG_BOOL                               bIdleDevice,
+                                                                         PVRSRV_DEV_POWER_STATE eCurrentPowerState)
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_DEVICE_NODE      *psDeviceNode = hDevHandle;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+
+        if (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON)
+        {
+                if (bIdleDevice)
+                {
+                        
+                        PDUMPSUSPEND();
+
+                        eError = SGXPrePowerState(hDevHandle, PVRSRV_DEV_POWER_STATE_IDLE,
+                                                                          PVRSRV_DEV_POWER_STATE_ON);
+
+                        if (eError != PVRSRV_OK)
+                        {
+                                PDUMPRESUME();
+                                return eError;
+                        }
+                }
+        }
+
+        PVR_DPF((PVR_DBG_MESSAGE,"SGXPreClockSpeedChange: SGX clock speed was %uHz",
+                        psDevInfo->ui32CoreClockSpeed));
+
+        return PVRSRV_OK;
+}
+
+
+PVRSRV_ERROR SGXPostClockSpeedChange (IMG_HANDLE                                hDevHandle,
+                                                                          IMG_BOOL                                      bIdleDevice,
+                                                                          PVRSRV_DEV_POWER_STATE        eCurrentPowerState)
+{
+        PVRSRV_DEVICE_NODE      *psDeviceNode = hDevHandle;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+        IMG_UINT32                      ui32OldClockSpeed = psDevInfo->ui32CoreClockSpeed;
+
+        PVR_UNREFERENCED_PARAMETER(ui32OldClockSpeed);
+
+        if (eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON)
+        {
+                PVRSRV_ERROR eError;
+
+                
+
+                eError = SGXUpdateTimingInfo(psDeviceNode);
+                if (eError != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXPostPowerState: SGXUpdateTimingInfo failed"));
+                        return eError;
+                }
+
+                if (bIdleDevice)
+                {
+                        
+                        eError = SGXPostPowerState(hDevHandle, PVRSRV_DEV_POWER_STATE_ON,
+                                                                           PVRSRV_DEV_POWER_STATE_IDLE);
+
+                        PDUMPRESUME();
+
+                        if (eError != PVRSRV_OK)
+                        {
+                                return eError;
+                        }
+                }
+                else
+                {
+                        SGXStartTimer(psDevInfo);
+                }
+        }
+
+        PVR_DPF((PVR_DBG_MESSAGE,"SGXPostClockSpeedChange: SGX clock speed changed from %uHz to %uHz",
+                        ui32OldClockSpeed, psDevInfo->ui32CoreClockSpeed));
+
+        return PVRSRV_OK;
+}
+
+
diff --git a/drivers/gpu/pvr/sgx/sgxreset.c b/drivers/gpu/pvr/sgx/sgxreset.c
new file mode 100644
index 00000000000..ee9f572ea74
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxreset.c
@@ -0,0 +1,499 @@
+/**********************************************************************
+ *
+ * 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 "sgxdefs.h"
+#include "sgxmmu.h"
+#include "services_headers.h"
+#include "sgxinfokm.h"
+#include "sgxconfig.h"
+
+#include "pdump_km.h"
+
+
+static IMG_VOID SGXResetSoftReset(PVRSRV_SGXDEV_INFO    *psDevInfo,
+                                                                  IMG_BOOL                              bResetBIF,
+                                                                  IMG_UINT32                    ui32PDUMPFlags,
+                                                                  IMG_BOOL                              bPDump)
+{
+        IMG_UINT32 ui32SoftResetRegVal;
+
+#if defined(SGX_FEATURE_MP)
+        ui32SoftResetRegVal =
+                                        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
+
+        if (bResetBIF)
+        {
+                ui32SoftResetRegVal |= EUR_CR_MASTER_SOFT_RESET_BIF_RESET_MASK;
+        }
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SOFT_RESET, ui32SoftResetRegVal);
+        if (bPDump)
+        {
+                PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
+        }
+#endif 
+
+        ui32SoftResetRegVal =
+                                        
+                                        EUR_CR_SOFT_RESET_DPM_RESET_MASK |
+                                        EUR_CR_SOFT_RESET_TA_RESET_MASK  |
+                                        EUR_CR_SOFT_RESET_USE_RESET_MASK |
+                                        EUR_CR_SOFT_RESET_ISP_RESET_MASK |
+                                        EUR_CR_SOFT_RESET_TSP_RESET_MASK;
+
+#ifdef EUR_CR_SOFT_RESET_TWOD_RESET_MASK
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_TWOD_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_TE_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_TE_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_MTE_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_MTE_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_ISP2_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_ISP2_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_PDS_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_PDS_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_PBE_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_PBE_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_CACHEL2_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_CACHEL2_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_TCU_L2_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_TCU_L2_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_UCACHEL2_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_UCACHEL2_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_MADD_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_MADD_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_ITR_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_ITR_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_TEX_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_TEX_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_IDXFIFO_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_IDXFIFO_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_VDM_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_VDM_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_DCU_L2_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_DCU_L2_RESET_MASK;
+#endif
+#if defined(EUR_CR_SOFT_RESET_DCU_L0L1_RESET_MASK)
+        ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_DCU_L0L1_RESET_MASK;
+#endif
+
+#if !defined(PDUMP)
+        PVR_UNREFERENCED_PARAMETER(ui32PDUMPFlags);
+#endif 
+
+        if (bResetBIF)
+        {
+                ui32SoftResetRegVal |= EUR_CR_SOFT_RESET_BIF_RESET_MASK;
+        }
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_SOFT_RESET, ui32SoftResetRegVal);
+        if (bPDump)
+        {
+                PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32SoftResetRegVal, ui32PDUMPFlags);
+        }
+}
+
+
+static IMG_VOID SGXResetSleep(PVRSRV_SGXDEV_INFO        *psDevInfo,
+                                                          IMG_UINT32                    ui32PDUMPFlags,
+                                                          IMG_BOOL                              bPDump)
+{
+#if !defined(PDUMP)
+        PVR_UNREFERENCED_PARAMETER(ui32PDUMPFlags);
+#endif 
+
+        
+        OSWaitus(100 * 1000000 / psDevInfo->ui32CoreClockSpeed);
+        if (bPDump)
+        {
+                PDUMPIDLWITHFLAGS(30, ui32PDUMPFlags);
+#if defined(PDUMP)
+                PDumpRegRead(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32PDUMPFlags);
+#endif
+        }
+
+}
+
+
+static IMG_VOID SGXResetInvalDC(PVRSRV_SGXDEV_INFO      *psDevInfo,
+                                                            IMG_UINT32                  ui32PDUMPFlags,
+                                                                IMG_BOOL                        bPDump)
+{
+        IMG_UINT32 ui32RegVal;
+
+        
+#if defined(EUR_CR_BIF_CTRL_INVAL)
+        ui32RegVal = EUR_CR_BIF_CTRL_INVAL_ALL_MASK;
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL_INVAL, ui32RegVal);
+        if (bPDump)
+        {
+                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(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+        }
+
+        ui32RegVal = 0;
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
+        if (bPDump)
+        {
+                PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+        }
+#endif
+        SGXResetSleep(psDevInfo, ui32PDUMPFlags, bPDump);
+
+#if !defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+        {
+                
+
+
+                if (PollForValueKM((IMG_UINT32 *)((IMG_UINT8*)psDevInfo->pvRegsBaseKM + EUR_CR_BIF_MEM_REQ_STAT),
+                                                        0,
+                                                        EUR_CR_BIF_MEM_REQ_STAT_READS_MASK,
+                                                        MAX_HW_TIME_US/WAIT_TRY_COUNT,
+                                                        WAIT_TRY_COUNT) != PVRSRV_OK)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"Wait for DC invalidate failed."));
+                        PVR_DBG_BREAK;
+                }
+
+                if (bPDump)
+                {
+                        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_BOOL                              bHardwareRecovery,
+                                  IMG_UINT32                    ui32PDUMPFlags)
+{
+        IMG_UINT32 ui32RegVal;
+#if defined(EUR_CR_BIF_INT_STAT_FAULT_REQ_MASK)
+        const IMG_UINT32 ui32BifFaultMask = EUR_CR_BIF_INT_STAT_FAULT_REQ_MASK;
+#else
+        const IMG_UINT32 ui32BifFaultMask = EUR_CR_BIF_INT_STAT_FAULT_MASK;
+#endif
+
+#ifndef PDUMP
+        PVR_UNREFERENCED_PARAMETER(ui32PDUMPFlags);
+#endif 
+
+        psDevInfo->ui32NumResets++;
+
+        PDUMPCOMMENTWITHFLAGS(ui32PDUMPFlags, "Start of SGX reset sequence\r\n");
+
+#if defined(FIX_HW_BRN_23944)
+        
+        ui32RegVal = EUR_CR_BIF_CTRL_PAUSE_MASK;
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+
+        SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
+
+        ui32RegVal = OSReadHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_INT_STAT);
+        if (ui32RegVal & ui32BifFaultMask)
+        {
+                
+                ui32RegVal = EUR_CR_BIF_CTRL_PAUSE_MASK | EUR_CR_BIF_CTRL_CLEAR_FAULT_MASK;
+                OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_CTRL, ui32RegVal);
+                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(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+
+                SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
+        }
+#endif 
+
+        
+        SGXResetSoftReset(psDevInfo, IMG_TRUE, ui32PDUMPFlags, IMG_TRUE);
+
+        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(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(SGX_PDUMPREG_NAME, EUR_CR_BIF_CTRL, ui32RegVal, ui32PDUMPFlags);
+#if defined(SGX_FEATURE_MP)
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_BIF_CTRL, ui32RegVal);
+        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(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK_SET, ui32RegVal, ui32PDUMPFlags);
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK0, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
+#endif 
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_DIR_LIST_BASE0, ui32RegVal, ui32PDUMPFlags);
+
+#if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+        {
+                IMG_UINT32      ui32DirList, ui32DirListReg;
+
+                for (ui32DirList = 1;
+                         ui32DirList < SGX_FEATURE_BIF_NUM_DIRLISTS;
+                         ui32DirList++)
+                {
+                        ui32DirListReg = EUR_CR_BIF_DIR_LIST_BASE1 + 4 * (ui32DirList - 1);
+                        OSWriteHWReg(psDevInfo->pvRegsBaseKM, ui32DirListReg, ui32RegVal);
+                        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, ui32DirListReg, ui32RegVal, ui32PDUMPFlags);
+                }
+        }
+#endif 
+
+#if defined(EUR_CR_BIF_MEM_ARB_CONFIG)
+        
+
+        ui32RegVal      = (12UL << EUR_CR_BIF_MEM_ARB_CONFIG_PAGE_SIZE_SHIFT) |
+                                  (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(SGX_PDUMPREG_NAME, EUR_CR_BIF_MEM_ARB_CONFIG, ui32RegVal, ui32PDUMPFlags);
+#endif 
+
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+#if defined(SGX_FEATURE_MP)
+        #if defined(SGX_BYPASS_SYSTEM_CACHE)
+                #error SGX_BYPASS_SYSTEM_CACHE not supported
+        #else
+                ui32RegVal = EUR_CR_MASTER_SLC_CTRL_USSE_INVAL_REQ0_MASK |
+                                                (0xC << EUR_CR_MASTER_SLC_CTRL_ARB_PAGE_SIZE_SHIFT);
+                OSWriteHWReg(psDevInfo->pvRegsBaseKM, 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;
+                OSWriteHWReg(psDevInfo->pvRegsBaseKM, 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 = MNE_CR_CTRL_BYPASS_ALL_MASK;
+        #else
+                #if defined(FIX_HW_BRN_26620)
+                        ui32RegVal = 0;
+                #else
+                        
+                        ui32RegVal = MNE_CR_CTRL_BYP_CC_MASK;
+                #endif
+        #endif 
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, MNE_CR_CTRL, ui32RegVal);
+        PDUMPREG(SGX_PDUMPREG_NAME, MNE_CR_CTRL, ui32RegVal);
+#endif 
+#endif 
+
+        if (bHardwareRecovery)
+        {
+                
+
+
+
+
+
+
+                ui32RegVal = (IMG_UINT32)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);
+
+                SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+
+                
+
+                for (;;)
+                {
+                        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;
+
+                        
+                        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;
+
+                        
+                        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);
+
+                        
+                        SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_FALSE);
+                        SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+
+                        
+                        SGXResetInvalDC(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+
+                        
+                        psDevInfo->pui32BIFResetPD[ui32PDIndex] = 0;
+                        psDevInfo->pui32BIFResetPT[ui32PTIndex] = 0;
+                }
+        }
+        else
+        {
+                
+                SGXResetSoftReset(psDevInfo, IMG_FALSE, ui32PDUMPFlags, IMG_TRUE);
+                SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_FALSE);
+        }       
+
+        
+
+        #if defined(SGX_FEATURE_MULTIPLE_MEM_CONTEXTS)
+        
+        ui32RegVal = (SGX_BIF_DIR_LIST_INDEX_EDM << EUR_CR_BIF_BANK0_INDEX_EDM_SHIFT);
+
+        #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 
+
+        #if defined(FIX_HW_BRN_23410)
+        
+        ui32RegVal |= (SGX_BIF_DIR_LIST_INDEX_EDM << EUR_CR_BIF_BANK0_INDEX_TA_SHIFT);
+        #endif 
+
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_BIF_BANK0, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_BIF_BANK0, ui32RegVal, ui32PDUMPFlags);
+        #endif 
+
+        {
+                IMG_UINT32      ui32EDMDirListReg;
+
+                
+                #if (SGX_BIF_DIR_LIST_INDEX_EDM == 0)
+                ui32EDMDirListReg = EUR_CR_BIF_DIR_LIST_BASE0;
+                #else
+                
+                ui32EDMDirListReg = EUR_CR_BIF_DIR_LIST_BASE1 + 4 * (SGX_BIF_DIR_LIST_INDEX_EDM - 1);
+                #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(&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(&psDevInfo->sMMUAttrib, ui32EDMDirListReg, psDevInfo->sKernelPDDevPAddr.uiAddr>>SGX_MMU_PDE_ADDR_ALIGNSHIFT, ui32PDUMPFlags, PDUMP_PD_UNIQUETAG);
+        }
+
+#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(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"));
+
+        
+        ui32RegVal = 0;
+#if defined(SGX_FEATURE_MP)
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_MASTER_SOFT_RESET, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_MASTER_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
+#endif 
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM, EUR_CR_SOFT_RESET, ui32RegVal);
+        PDUMPREGWITHFLAGS(SGX_PDUMPREG_NAME, EUR_CR_SOFT_RESET, ui32RegVal, ui32PDUMPFlags);
+
+        
+        SGXResetSleep(psDevInfo, ui32PDUMPFlags, IMG_TRUE);
+
+        PDUMPCOMMENTWITHFLAGS(ui32PDUMPFlags, "End of SGX reset sequence\r\n");
+}
+
+
diff --git a/drivers/gpu/pvr/sgx/sgxtransfer.c b/drivers/gpu/pvr/sgx/sgxtransfer.c
new file mode 100644
index 00000000000..abe5767e25d
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxtransfer.c
@@ -0,0 +1,573 @@
+/**********************************************************************
+ *
+ * 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(TRANSFER_QUEUE)
+
+#include <stddef.h>
+
+#include "sgxdefs.h"
+#include "services_headers.h"
+#include "buffer_manager.h"
+#include "sgxinfo.h"
+#include "sysconfig.h"
+#include "regpaths.h"
+#include "pdump_km.h"
+#include "mmu.h"
+#include "pvr_bridge.h"
+#include "sgx_bridge_km.h"
+#include "sgxinfokm.h"
+#include "osfunc.h"
+#include "pvr_debug.h"
+#include "sgxutils.h"
+
+IMG_EXPORT PVRSRV_ERROR SGXSubmitTransferKM(IMG_HANDLE hDevHandle, PVRSRV_TRANSFER_SGX_KICK *psKick)
+{
+        PVRSRV_KERNEL_MEM_INFO  *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psKick->hCCBMemInfo;
+        SGXMKIF_COMMAND sCommand = {0};
+        SGXMKIF_TRANSFERCMD_SHARED *psSharedTransferCmd;
+        PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
+        PVRSRV_ERROR eError;
+
+#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))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXSubmitTransferKM: Invalid CCB offset"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        
+        psSharedTransferCmd =  CCB_DATA_FROM_OFFSET(SGXMKIF_TRANSFERCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset);
+
+        if (psKick->hTASyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+
+                psSharedTransferCmd->ui32TASyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+                psSharedTransferCmd->ui32TASyncReadOpsPendingVal  = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                psSharedTransferCmd->sTASyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psSharedTransferCmd->sTASyncReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+        else
+        {
+                psSharedTransferCmd->sTASyncWriteOpsCompleteDevVAddr.uiAddr = 0;
+                psSharedTransferCmd->sTASyncReadOpsCompleteDevVAddr.uiAddr = 0;
+        }
+
+        if (psKick->h3DSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+
+                psSharedTransferCmd->ui323DSyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+                psSharedTransferCmd->ui323DSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                psSharedTransferCmd->s3DSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                psSharedTransferCmd->s3DSyncReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+        else
+        {
+                psSharedTransferCmd->s3DSyncWriteOpsCompleteDevVAddr.uiAddr = 0;
+                psSharedTransferCmd->s3DSyncReadOpsCompleteDevVAddr.uiAddr = 0;
+        }
+
+        if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
+        {
+                if (psKick->ui32NumSrcSync > 0)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+
+                        psSharedTransferCmd->ui32SrcWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                        psSharedTransferCmd->ui32SrcReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                        psSharedTransferCmd->sSrcWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr; 
+                        psSharedTransferCmd->sSrcReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                }
+
+                if (psKick->ui32NumDstSync > 0)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+
+                        psSharedTransferCmd->ui32DstWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                        psSharedTransferCmd->ui32DstReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                        psSharedTransferCmd->sDstWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                        psSharedTransferCmd->sDstReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+
+                }
+
+                
+                if (psKick->ui32NumSrcSync > 0)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+                        psSyncInfo->psSyncData->ui32ReadOpsPending++;
+                }
+                if (psKick->ui32NumDstSync > 0)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+                        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)) 
+        &&  (bPersistentProcess == IMG_FALSE) )
+        {
+                PDUMPCOMMENT("Shared part of transfer command\r\n");
+                PDUMPMEM(psSharedTransferCmd,
+                                psCCBMemInfo,
+                                psKick->ui32CCBDumpWOff,
+                                sizeof(SGXMKIF_TRANSFERCMD_SHARED),
+                                psKick->ui32PDumpFlags,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                if((psKick->ui32NumSrcSync > 0) && ((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),
+                                        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));
+
+                }
+                if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
+                {
+                        psSyncInfo = psKick->ahDstSyncInfo[0];
+        
+                        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));
+
+                }
+
+                
+                if((psKick->ui32NumSrcSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING)== 0UL))
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
+                }
+
+                if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
+                        psSyncInfo->psSyncData->ui32LastOpDumpVal++;
+                }
+        }               
+#endif
+
+        sCommand.ui32Data[1] = psKick->sHWTransferContextDevVAddr.uiAddr;
+        
+        eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_TRANSFER, &sCommand, KERNEL_ID, psKick->ui32PDumpFlags);
+
+        if (eError == PVRSRV_ERROR_RETRY)
+        {
+                
+                if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
+                {
+                        if (psKick->ui32NumSrcSync > 0)
+                        {
+                                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
+                                psSyncInfo->psSyncData->ui32ReadOpsPending--;
+                        }
+                        if (psKick->ui32NumDstSync > 0)
+                        {
+                                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."));
+                return eError;
+        }
+        
+
+#if defined(NO_HARDWARE)
+        if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_NOSYNCUPDATE) == 0)
+        {
+                IMG_UINT32 i;
+
+                
+                for(i = 0; i < psKick->ui32NumSrcSync; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32ReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
+                }
+
+                for(i = 0; i < psKick->ui32NumDstSync; i++)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[i];
+                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+
+                }
+
+                if (psKick->hTASyncInfo != IMG_NULL)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+
+                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                }
+
+                if (psKick->h3DSyncInfo != IMG_NULL)
+                {
+                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+
+                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                }
+        }
+#endif
+
+        return eError;
+}
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+IMG_EXPORT PVRSRV_ERROR SGXSubmit2DKM(IMG_HANDLE hDevHandle, PVRSRV_2D_SGX_KICK *psKick)
+                                            
+{
+        PVRSRV_KERNEL_MEM_INFO  *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psKick->hCCBMemInfo;
+        SGXMKIF_COMMAND sCommand = {0};
+        SGXMKIF_2DCMD_SHARED *ps2DCmd;
+        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))
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXSubmit2DKM: Invalid CCB offset"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+        
+        
+        ps2DCmd =  CCB_DATA_FROM_OFFSET(SGXMKIF_2DCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset);
+
+        OSMemSet(ps2DCmd, 0, sizeof(*ps2DCmd));
+
+        
+        if (psKick->hTASyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+
+                ps2DCmd->sTASyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+                ps2DCmd->sTASyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                ps2DCmd->sTASyncData.sWriteOpsCompleteDevVAddr  = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                ps2DCmd->sTASyncData.sReadOpsCompleteDevVAddr   = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+
+        
+        if (psKick->h3DSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+
+                ps2DCmd->s3DSyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
+                ps2DCmd->s3DSyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                ps2DCmd->s3DSyncData.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                ps2DCmd->s3DSyncData.sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+
+        
+        ps2DCmd->ui32NumSrcSync = psKick->ui32NumSrcSync;
+        for (i = 0; i < psKick->ui32NumSrcSync; i++)
+        {
+                psSyncInfo = psKick->ahSrcSyncInfo[i];
+
+                ps2DCmd->sSrcSyncData[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                ps2DCmd->sSrcSyncData[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                ps2DCmd->sSrcSyncData[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                ps2DCmd->sSrcSyncData[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+
+        if (psKick->hDstSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = psKick->hDstSyncInfo;
+
+                ps2DCmd->sDstSyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
+                ps2DCmd->sDstSyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
+
+                ps2DCmd->sDstSyncData.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
+                ps2DCmd->sDstSyncData.sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
+        }
+
+        
+        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 defined(PDUMP)
+        if ((PDumpIsCaptureFrameKM()
+        || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+        &&  (bPersistentProcess == IMG_FALSE) )
+        {
+                
+                PDUMPCOMMENT("Shared part of 2D command\r\n");
+                PDUMPMEM(ps2DCmd,
+                                psCCBMemInfo,
+                                psKick->ui32CCBDumpWOff,
+                                sizeof(SGXMKIF_2DCMD_SHARED),
+                                psKick->ui32PDumpFlags,
+                                MAKEUNIQUETAG(psCCBMemInfo));
+
+                for (i = 0; i < psKick->ui32NumSrcSync; i++)
+                {
+                        psSyncInfo = psKick->ahSrcSyncInfo[i];
+
+                        PDUMPCOMMENT("Hack src surface write op in 2D cmd\r\n");
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                        psCCBMemInfo,
+                                        psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sSrcSyncData[i].ui32WriteOpsPendingVal),
+                                        sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
+                                        psKick->ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Hack src surface read op in 2D cmd\r\n");
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psCCBMemInfo,
+                                        psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sSrcSyncData[i].ui32ReadOpsPendingVal),
+                                        sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
+                                        psKick->ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psCCBMemInfo));
+                }
+
+                if (psKick->hDstSyncInfo != IMG_NULL)
+                {
+                        psSyncInfo = psKick->hDstSyncInfo;
+
+                        PDUMPCOMMENT("Hack dest surface write op in 2D cmd\r\n");
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
+                                        psCCBMemInfo,
+                                        psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sDstSyncData.ui32WriteOpsPendingVal),
+                                        sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
+                                        psKick->ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psCCBMemInfo));
+
+                        PDUMPCOMMENT("Hack dest surface read op in 2D cmd\r\n");
+                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
+                                        psCCBMemInfo,
+                                        psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sDstSyncData.ui32ReadOpsPendingVal),
+                                        sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
+                                        psKick->ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psCCBMemInfo));
+                }
+
+                
+                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
+
+        sCommand.ui32Data[1] = psKick->sHW2DContextDevVAddr.uiAddr;
+        
+        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)
+        
+        for(i = 0; i < psKick->ui32NumSrcSync; i++)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[i];
+                psSyncInfo->psSyncData->ui32ReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
+        }
+
+        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hDstSyncInfo;
+        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+
+        if (psKick->hTASyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
+
+                psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+
+        if (psKick->h3DSyncInfo != IMG_NULL)
+        {
+                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
+
+                psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
+        }
+#endif
+
+        return eError;
+}
+#endif  
+#endif  
diff --git a/drivers/gpu/pvr/sgx/sgxutils.c b/drivers/gpu/pvr/sgx/sgxutils.c
new file mode 100644
index 00000000000..3365af66425
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxutils.c
@@ -0,0 +1,955 @@
+/**********************************************************************
+ *
+ * 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 <stddef.h>
+
+#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 "sysconfig.h"
+#include "pdump_km.h"
+#include "mmu.h"
+#include "pvr_bridge_km.h"
+#include "osfunc.h"
+#include "pvr_debug.h"
+#include "sgxutils.h"
+
+#ifdef __linux__
+#include <linux/kernel.h>       
+#include <linux/string.h>       
+#else
+#include <stdio.h>
+#endif
+
+
+#if defined(SYS_CUSTOM_POWERDOWN)
+PVRSRV_ERROR SysPowerDownMISR(PVRSRV_DEVICE_NODE        * psDeviceNode, IMG_UINT32 ui32CallerID);
+#endif
+
+
+
+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)
+        {
+                
+
+
+                if (ui32CallerID == ISR_ID)
+                {
+                        psDeviceNode->bReProcessDeviceCommandComplete = IMG_TRUE;
+                }
+                else
+                {
+                        SGXScheduleProcessQueuesKM(psDeviceNode);
+                }
+        }
+}
+
+
+IMG_VOID SGXTestActivePowerEvent (PVRSRV_DEVICE_NODE    *psDeviceNode,
+                                                                  IMG_UINT32                    ui32CallerID)
+{
+        PVRSRV_ERROR            eError = PVRSRV_OK;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+        SGXMKIF_HOST_CTL        *psSGXHostCtl = psDevInfo->psSGXHostCtl;
+
+        if (((psSGXHostCtl->ui32InterruptFlags & PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER) != 0) &&
+                ((psSGXHostCtl->ui32InterruptClearFlags & PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER) == 0))
+        {
+                
+                psSGXHostCtl->ui32InterruptClearFlags |= PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER;
+
+                
+                PDUMPSUSPEND();
+
+#if defined(SYS_CUSTOM_POWERDOWN)
+                
+
+
+                eError = SysPowerDownMISR(psDeviceNode, ui32CallerID);
+#else
+                eError = PVRSRVSetDevicePowerStateKM(psDeviceNode->sDevId.ui32DeviceIndex,
+                                                                                         PVRSRV_DEV_POWER_STATE_OFF,
+                                                                                         ui32CallerID, IMG_FALSE);
+                if (eError == PVRSRV_OK)
+                {
+                        SGXPostActivePowerEvent(psDeviceNode, ui32CallerID);
+                }
+#endif
+                if (eError == PVRSRV_ERROR_RETRY)
+                {
+                        
+
+                        psSGXHostCtl->ui32InterruptClearFlags &= ~PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER;
+                        eError = PVRSRV_OK;
+                }
+
+                
+                PDUMPRESUME();
+        }
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXTestActivePowerEvent error:%u", eError));
+        }
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SGXAcquireKernelCCBSlot)
+#endif
+static INLINE SGXMKIF_COMMAND * SGXAcquireKernelCCBSlot(PVRSRV_SGX_CCB_INFO *psCCB)
+{
+        LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+        {
+                if(((*psCCB->pui32WriteOffset + 1) & 255) != *psCCB->pui32ReadOffset)
+                {
+                        return &psCCB->psCommands[*psCCB->pui32WriteOffset];
+                }
+
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+        } END_LOOP_UNTIL_TIMEOUT();
+
+        
+        return IMG_NULL;
+}
+
+PVRSRV_ERROR SGXScheduleCCBCommand(PVRSRV_SGXDEV_INFO   *psDevInfo,
+                                                                   SGXMKIF_CMD_TYPE             eCmdType,
+                                                                   SGXMKIF_COMMAND              *psCommandData,
+                                                                   IMG_UINT32                   ui32CallerID,
+                                                                   IMG_UINT32                   ui32PDumpFlags)
+{
+        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(PDUMP)
+        
+        {
+                PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
+                if(psPerProc != IMG_NULL)
+                {
+                        bPersistentProcess = psPerProc->bPDumpPersistent;
+                }
+        }
+#endif 
+        psKernelCCB = psDevInfo->psKernelCCBInfo;
+
+        psSGXCommand = SGXAcquireKernelCCBSlot(psKernelCCB);
+
+        
+        if(!psSGXCommand)
+        {
+                eError = PVRSRV_ERROR_TIMEOUT;
+                goto Exit;
+        }
+
+        
+        psCommandData->ui32CacheControl = psDevInfo->ui32CacheControl;
+
+#if defined(PDUMP)
+        
+        psDevInfo->sPDContext.ui32CacheControl |= psDevInfo->ui32CacheControl;
+#endif
+
+        
+        psDevInfo->ui32CacheControl = 0;
+
+        
+        *psSGXCommand = *psCommandData;
+
+        if (eCmdType >= SGXMKIF_CMD_MAX)
+        {
+                PVR_DPF((PVR_DBG_ERROR,"SGXScheduleCCBCommandKM: Unknown command type: %d", eCmdType)) ;
+                eError = PVRSRV_ERROR_INVALID_CCB_COMMAND;
+                goto Exit;
+        }
+
+        
+        SysAcquireData(&psSysData);
+
+        if(psSysData->ePendingCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_FLUSH)
+        {
+                OSFlushCPUCacheKM();
+        }
+        else if(psSysData->ePendingCacheOpType == PVRSRV_MISC_INFO_CPUCACHEOP_CLEAN)
+        {
+                OSCleanCPUCacheKM();
+        }
+
+        
+        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) &&
+                (bPersistentProcess == IMG_FALSE) )
+        {
+                
+                PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Poll for space in the Kernel CCB\r\n");
+                PDUMPMEMPOL(psKernelCCB->psCCBCtlMemInfo,
+                                        offsetof(PVRSRV_SGX_CCB_CTL, ui32ReadOffset),
+                                        (psKernelCCB->ui32CCBDumpWOff + 1) & 0xff,
+                                        0xff,
+                                        PDUMP_POLL_OPERATOR_NOTEQUAL,
+                                        ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psKernelCCB->psCCBCtlMemInfo));
+
+                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->psCCBMemInfo,
+                                        psKernelCCB->ui32CCBDumpWOff * sizeof(SGXMKIF_COMMAND),
+                                        sizeof(SGXMKIF_COMMAND),
+                                        ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psKernelCCB->psCCBMemInfo));
+
+                
+                PDUMPMEM(&psDevInfo->sPDContext.ui32CacheControl,
+                                        psKernelCCB->psCCBMemInfo,
+                                        psKernelCCB->ui32CCBDumpWOff * sizeof(SGXMKIF_COMMAND) +
+                                        offsetof(SGXMKIF_COMMAND, ui32CacheControl),
+                                        sizeof(IMG_UINT32),
+                                        ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psKernelCCB->psCCBMemInfo));
+
+                if (PDumpIsCaptureFrameKM()
+                || ((ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+                {
+                        
+                        psDevInfo->sPDContext.ui32CacheControl = 0;
+                }
+        }
+#endif
+
+#if defined(FIX_HW_BRN_26620) && defined(SGX_FEATURE_SYSTEM_CACHE) && !defined(SGX_BYPASS_SYSTEM_CACHE)
+        
+        eError = PollForValueKM (psKernelCCB->pui32ReadOffset,
+                                                                *psKernelCCB->pui32WriteOffset,
+                                                                0xFF,
+                                                                MAX_HW_TIME_US/WAIT_TRY_COUNT,
+                                                                WAIT_TRY_COUNT);
+        if (eError != PVRSRV_OK)
+        {
+                eError = PVRSRV_ERROR_TIMEOUT;
+                goto Exit;
+        }
+#endif
+
+        
+
+        *psKernelCCB->pui32WriteOffset = (*psKernelCCB->pui32WriteOffset + 1) & 255;
+
+#if defined(PDUMP)
+        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");
+                PDUMPMEMPOL(psKernelCCB->psCCBCtlMemInfo,
+                                        offsetof(PVRSRV_SGX_CCB_CTL, ui32ReadOffset),
+                                        (psKernelCCB->ui32CCBDumpWOff),
+                                        0xFF,
+                                        PDUMP_POLL_OPERATOR_EQUAL,
+                                        ui32PDumpFlags,
+                                        MAKEUNIQUETAG(psKernelCCB->psCCBCtlMemInfo));
+        #endif
+
+                if (PDumpIsCaptureFrameKM()
+                || ((ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
+                {
+                        psKernelCCB->ui32CCBDumpWOff = (psKernelCCB->ui32CCBDumpWOff + 1) & 0xFF;
+                        psDevInfo->ui32KernelCCBEventKickerDumpVal = (psDevInfo->ui32KernelCCBEventKickerDumpVal + 1) & 0xFF;
+                }
+
+                PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Kernel CCB write offset\r\n");
+                PDUMPMEM(&psKernelCCB->ui32CCBDumpWOff,
+                                 psKernelCCB->psCCBCtlMemInfo,
+                                 offsetof(PVRSRV_SGX_CCB_CTL, ui32WriteOffset),
+                                 sizeof(IMG_UINT32),
+                                 ui32PDumpFlags,
+                                 MAKEUNIQUETAG(psKernelCCB->psCCBCtlMemInfo));
+                PDUMPCOMMENTWITHFLAGS(ui32PDumpFlags, "Kernel CCB event kicker\r\n");
+                PDUMPMEM(&psDevInfo->ui32KernelCCBEventKickerDumpVal,
+                                 psDevInfo->psKernelCCBEventKickerMemInfo,
+                                 0,
+                                 sizeof(IMG_UINT32),
+                                 ui32PDumpFlags,
+                                 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_PDUMPREG_NAME, SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK2, 0), EUR_CR_EVENT_KICK2_NOW_MASK, ui32PDumpFlags);
+        #else
+                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_KICK2_NOW_MASK);
+#else
+        OSWriteHWReg(psDevInfo->pvRegsBaseKM,
+                                SGX_MP_CORE_SELECT(EUR_CR_EVENT_KICK, 0),
+                                EUR_CR_EVENT_KICK_NOW_MASK);
+#endif
+
+        OSMemoryBarrier();
+
+#if defined(NO_HARDWARE)
+        
+        *psKernelCCB->pui32ReadOffset = (*psKernelCCB->pui32ReadOffset + 1) & 255;
+#endif
+
+Exit:
+        return eError;
+}
+
+
+PVRSRV_ERROR SGXScheduleCCBCommandKM(PVRSRV_DEVICE_NODE         *psDeviceNode,
+                                                                         SGXMKIF_CMD_TYPE               eCmdType,
+                                                                         SGXMKIF_COMMAND                *psCommandData,
+                                                                         IMG_UINT32                             ui32CallerID,
+                                                                         IMG_UINT32                             ui32PDumpFlags)
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+
+        
+        PDUMPSUSPEND();
+
+        
+        eError = PVRSRVSetDevicePowerStateKM(psDeviceNode->sDevId.ui32DeviceIndex,
+                                                                                 PVRSRV_DEV_POWER_STATE_ON,
+                                                                                 ui32CallerID,
+                                                                                 IMG_TRUE);
+
+        PDUMPRESUME();
+
+        if (eError == PVRSRV_OK)
+        {
+                psDeviceNode->bReProcessDeviceCommandComplete = IMG_FALSE;
+        }
+        else
+        {
+                if (eError == PVRSRV_ERROR_RETRY)
+                {
+                        if (ui32CallerID == ISR_ID)
+                        {
+                                
+
+
+                                psDeviceNode->bReProcessDeviceCommandComplete = IMG_TRUE;
+                                eError = PVRSRV_OK;
+                        }
+                        else
+                        {
+                                
+
+                        }
+                }
+                else
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXScheduleCCBCommandKM failed to acquire lock - "
+                                         "ui32CallerID:%d eError:%u", ui32CallerID, eError));
+                }
+
+                return eError;
+        }
+
+        eError = SGXScheduleCCBCommand(psDevInfo, eCmdType, psCommandData, ui32CallerID, ui32PDumpFlags);
+
+        PVRSRVPowerUnlock(ui32CallerID);
+
+        
+        if (ui32CallerID != ISR_ID)
+        {
+                
+
+
+                SGXTestActivePowerEvent(psDeviceNode, ui32CallerID);
+        }
+
+        return eError;
+}
+
+
+PVRSRV_ERROR SGXScheduleProcessQueuesKM(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        PVRSRV_ERROR            eError;
+        PVRSRV_SGXDEV_INFO      *psDevInfo = psDeviceNode->pvDevice;
+        SGXMKIF_HOST_CTL        *psHostCtl = psDevInfo->psKernelSGXHostCtlMemInfo->pvLinAddrKM;
+        IMG_UINT32              ui32PowerStatus;
+        SGXMKIF_COMMAND         sCommand = {0};
+
+        ui32PowerStatus = psHostCtl->ui32PowerStatus;
+        if ((ui32PowerStatus & PVRSRV_USSE_EDM_POWMAN_NO_WORK) != 0)
+        {
+                
+                return PVRSRV_OK;
+        }
+
+        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: %u", eError));
+                return eError;
+        }
+
+        return PVRSRV_OK;
+}
+
+
+IMG_BOOL SGXIsDevicePowered(PVRSRV_DEVICE_NODE *psDeviceNode)
+{
+        return PVRSRVIsDevicePowered(psDeviceNode->sDevId.ui32DeviceIndex);
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGXGetInternalDevInfoKM(IMG_HANDLE hDevCookie,
+                                                                        SGX_INTERNAL_DEVINFO *psSGXInternalDevInfo)
+{
+        PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
+
+        psSGXInternalDevInfo->ui32Flags = psDevInfo->ui32Flags;
+        psSGXInternalDevInfo->bForcePTOff = (IMG_BOOL)psDevInfo->bForcePTOff;
+
+        
+        psSGXInternalDevInfo->hHostCtlKernelMemInfoHandle =
+                (IMG_HANDLE)psDevInfo->psKernelSGXHostCtlMemInfo;
+
+        return PVRSRV_OK;
+}
+
+
+IMG_VOID SGXCleanupRequest(PVRSRV_DEVICE_NODE   *psDeviceNode,
+                                                   IMG_DEV_VIRTADDR             *psHWDataDevVAddr,
+                                                   IMG_UINT32                   ui32CleanupType)
+{
+        PVRSRV_ERROR                    eError;
+        PVRSRV_SGXDEV_INFO              *psSGXDevInfo = psDeviceNode->pvDevice;
+        PVRSRV_KERNEL_MEM_INFO  *psSGXHostCtlMemInfo = psSGXDevInfo->psKernelSGXHostCtlMemInfo;
+        SGXMKIF_HOST_CTL                *psSGXHostCtl = psSGXHostCtlMemInfo->pvLinAddrKM;
+
+        if ((psSGXHostCtl->ui32PowerStatus & PVRSRV_USSE_EDM_POWMAN_NO_WORK) != 0)
+        {
+                
+        }
+        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)
+                {
+                        PVR_DPF((PVR_DBG_ERROR,"SGXCleanupRequest: Failed to submit clean-up command"));
+                        PVR_DBG_BREAK;
+                }
+
+                
+                #if !defined(NO_HARDWARE)
+                if(PollForValueKM(&psSGXHostCtl->ui32CleanupStatus,
+                                                  PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
+                                                  PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
+                                                  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 (%u) failed", ui32CleanupType));
+                        PVR_DBG_BREAK;
+                }
+                #endif
+
+                #if defined(PDUMP)
+                
+                PDUMPCOMMENTWITHFLAGS(0, "Host Control - Poll for clean-up request to complete");
+                PDUMPMEMPOL(psSGXHostCtlMemInfo,
+                                        offsetof(SGXMKIF_HOST_CTL, ui32CleanupStatus),
+                                        PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
+                                        PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE,
+                                        PDUMP_POLL_OPERATOR_EQUAL,
+                                        0,
+                                        MAKEUNIQUETAG(psSGXHostCtlMemInfo));
+                #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
+        }
+}
+
+
+typedef struct _SGX_HW_RENDER_CONTEXT_CLEANUP_
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_DEV_VIRTADDR sHWRenderContextDevVAddr;
+        IMG_HANDLE hBlockAlloc;
+        PRESMAN_ITEM psResItem;
+} SGX_HW_RENDER_CONTEXT_CLEANUP;
+
+
+static PVRSRV_ERROR SGXCleanupHWRenderContextCallback(IMG_PVOID         pvParam,
+                                                                                                          IMG_UINT32    ui32Param)
+{
+        SGX_HW_RENDER_CONTEXT_CLEANUP *psCleanup = pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        SGXCleanupRequest(psCleanup->psDeviceNode,
+                                          &psCleanup->sHWRenderContextDevVAddr,
+                                          PVRSRV_CLEANUPCMD_RC);
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          sizeof(SGX_HW_RENDER_CONTEXT_CLEANUP),
+                          psCleanup,
+                          psCleanup->hBlockAlloc);
+        
+
+        return PVRSRV_OK;
+}
+
+typedef struct _SGX_HW_TRANSFER_CONTEXT_CLEANUP_
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_DEV_VIRTADDR sHWTransferContextDevVAddr;
+        IMG_HANDLE hBlockAlloc;
+        PRESMAN_ITEM psResItem;
+} SGX_HW_TRANSFER_CONTEXT_CLEANUP;
+
+
+static PVRSRV_ERROR SGXCleanupHWTransferContextCallback(IMG_PVOID       pvParam,
+                                                                                                                IMG_UINT32      ui32Param)
+{
+        SGX_HW_TRANSFER_CONTEXT_CLEANUP *psCleanup = (SGX_HW_TRANSFER_CONTEXT_CLEANUP *)pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        SGXCleanupRequest(psCleanup->psDeviceNode,
+                                          &psCleanup->sHWTransferContextDevVAddr,
+                                          PVRSRV_CLEANUPCMD_TC);
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          sizeof(SGX_HW_TRANSFER_CONTEXT_CLEANUP),
+                          psCleanup,
+                          psCleanup->hBlockAlloc);
+        
+
+        return PVRSRV_OK;
+}
+
+IMG_EXPORT
+IMG_HANDLE SGXRegisterHWRenderContextKM(IMG_HANDLE                              psDeviceNode,
+                                                                                IMG_DEV_VIRTADDR                *psHWRenderContextDevVAddr,
+                                                                                PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hBlockAlloc;
+        SGX_HW_RENDER_CONTEXT_CLEANUP *psCleanup;
+        PRESMAN_ITEM psResItem;
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(SGX_HW_RENDER_CONTEXT_CLEANUP),
+                                                (IMG_VOID **)&psCleanup,
+                                                &hBlockAlloc,
+                                                "SGX Hardware Render Context Cleanup");
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHWRenderContextKM: Couldn't allocate memory for SGX_HW_RENDER_CONTEXT_CLEANUP structure"));
+                return IMG_NULL;
+        }
+
+        psCleanup->hBlockAlloc = hBlockAlloc;
+        psCleanup->psDeviceNode = psDeviceNode;
+        psCleanup->sHWRenderContextDevVAddr = *psHWRenderContextDevVAddr;
+
+        psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                  RESMAN_TYPE_HW_RENDER_CONTEXT,
+                                                                  (IMG_VOID *)psCleanup,
+                                                                  0,
+                                                                  &SGXCleanupHWRenderContextCallback);
+
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHWRenderContextKM: ResManRegisterRes failed"));
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(SGX_HW_RENDER_CONTEXT_CLEANUP),
+                                  psCleanup,
+                                  psCleanup->hBlockAlloc);
+                
+
+                return IMG_NULL;
+        }
+
+        psCleanup->psResItem = psResItem;
+
+        return (IMG_HANDLE)psCleanup;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGXUnregisterHWRenderContextKM(IMG_HANDLE hHWRenderContext)
+{
+        PVRSRV_ERROR eError;
+        SGX_HW_RENDER_CONTEXT_CLEANUP *psCleanup;
+
+        PVR_ASSERT(hHWRenderContext != IMG_NULL);
+
+        psCleanup = (SGX_HW_RENDER_CONTEXT_CLEANUP *)hHWRenderContext;
+
+        if (psCleanup == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXUnregisterHWRenderContextKM: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        eError = ResManFreeResByPtr(psCleanup->psResItem);
+
+        return eError;
+}
+
+
+IMG_EXPORT
+IMG_HANDLE SGXRegisterHWTransferContextKM(IMG_HANDLE                            psDeviceNode,
+                                                                                  IMG_DEV_VIRTADDR                      *psHWTransferContextDevVAddr,
+                                                                                  PVRSRV_PER_PROCESS_DATA       *psPerProc)
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hBlockAlloc;
+        SGX_HW_TRANSFER_CONTEXT_CLEANUP *psCleanup;
+        PRESMAN_ITEM psResItem;
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(SGX_HW_TRANSFER_CONTEXT_CLEANUP),
+                                                (IMG_VOID **)&psCleanup,
+                                                &hBlockAlloc,
+                                                "SGX Hardware Transfer Context Cleanup");
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHWTransferContextKM: Couldn't allocate memory for SGX_HW_TRANSFER_CONTEXT_CLEANUP structure"));
+                return IMG_NULL;
+        }
+
+        psCleanup->hBlockAlloc = hBlockAlloc;
+        psCleanup->psDeviceNode = psDeviceNode;
+        psCleanup->sHWTransferContextDevVAddr = *psHWTransferContextDevVAddr;
+
+        psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                  RESMAN_TYPE_HW_TRANSFER_CONTEXT,
+                                                                  psCleanup,
+                                                                  0,
+                                                                  &SGXCleanupHWTransferContextCallback);
+
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHWTransferContextKM: ResManRegisterRes failed"));
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(SGX_HW_TRANSFER_CONTEXT_CLEANUP),
+                                  psCleanup,
+                                  psCleanup->hBlockAlloc);
+                
+
+                return IMG_NULL;
+        }
+
+        psCleanup->psResItem = psResItem;
+
+        return (IMG_HANDLE)psCleanup;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGXUnregisterHWTransferContextKM(IMG_HANDLE hHWTransferContext)
+{
+        PVRSRV_ERROR eError;
+        SGX_HW_TRANSFER_CONTEXT_CLEANUP *psCleanup;
+
+        PVR_ASSERT(hHWTransferContext != IMG_NULL);
+
+        psCleanup = (SGX_HW_TRANSFER_CONTEXT_CLEANUP *)hHWTransferContext;
+
+        if (psCleanup == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXUnregisterHWTransferContextKM: invalid parameter"));
+                return PVRSRV_ERROR_INVALID_PARAMS;
+        }
+
+        eError = ResManFreeResByPtr(psCleanup->psResItem);
+
+        return eError;
+}
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+typedef struct _SGX_HW_2D_CONTEXT_CLEANUP_
+{
+        PVRSRV_DEVICE_NODE *psDeviceNode;
+        IMG_DEV_VIRTADDR sHW2DContextDevVAddr;
+        IMG_HANDLE hBlockAlloc;
+        PRESMAN_ITEM psResItem;
+} SGX_HW_2D_CONTEXT_CLEANUP;
+
+static PVRSRV_ERROR SGXCleanupHW2DContextCallback(IMG_PVOID pvParam, IMG_UINT32 ui32Param)
+{
+        SGX_HW_2D_CONTEXT_CLEANUP *psCleanup = (SGX_HW_2D_CONTEXT_CLEANUP *)pvParam;
+
+        PVR_UNREFERENCED_PARAMETER(ui32Param);
+
+        SGXCleanupRequest(psCleanup->psDeviceNode,
+                                          &psCleanup->sHW2DContextDevVAddr,
+                                          PVRSRV_CLEANUPCMD_2DC);
+
+        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                          sizeof(SGX_HW_2D_CONTEXT_CLEANUP),
+                          psCleanup,
+                          psCleanup->hBlockAlloc);
+        
+
+        return PVRSRV_OK;
+}
+
+IMG_EXPORT
+IMG_HANDLE SGXRegisterHW2DContextKM(IMG_HANDLE                          psDeviceNode,
+                                                                        IMG_DEV_VIRTADDR                *psHW2DContextDevVAddr,
+                                                                        PVRSRV_PER_PROCESS_DATA *psPerProc)
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hBlockAlloc;
+        SGX_HW_2D_CONTEXT_CLEANUP *psCleanup;
+        PRESMAN_ITEM psResItem;
+
+        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                                sizeof(SGX_HW_2D_CONTEXT_CLEANUP),
+                                                (IMG_VOID **)&psCleanup,
+                                                &hBlockAlloc,
+                                                "SGX Hardware 2D Context Cleanup");
+
+        if (eError != PVRSRV_OK)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHW2DContextKM: Couldn't allocate memory for SGX_HW_2D_CONTEXT_CLEANUP structure"));
+                return IMG_NULL;
+        }
+
+        psCleanup->hBlockAlloc = hBlockAlloc;
+        psCleanup->psDeviceNode = psDeviceNode;
+        psCleanup->sHW2DContextDevVAddr = *psHW2DContextDevVAddr;
+
+        psResItem = ResManRegisterRes(psPerProc->hResManContext,
+                                                                  RESMAN_TYPE_HW_2D_CONTEXT,
+                                                                  psCleanup,
+                                                                  0,
+                                                                  &SGXCleanupHW2DContextCallback);
+
+        if (psResItem == IMG_NULL)
+        {
+                PVR_DPF((PVR_DBG_ERROR, "SGXRegisterHW2DContextKM: ResManRegisterRes failed"));
+                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
+                                  sizeof(SGX_HW_2D_CONTEXT_CLEANUP),
+                                  psCleanup,
+                                  psCleanup->hBlockAlloc);
+                
+
+                return IMG_NULL;
+        }
+
+        psCleanup->psResItem = psResItem;
+
+        return (IMG_HANDLE)psCleanup;
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGXUnregisterHW2DContextKM(IMG_HANDLE hHW2DContext)
+{
+        PVRSRV_ERROR eError;
+        SGX_HW_2D_CONTEXT_CLEANUP *psCleanup;
+
+        PVR_ASSERT(hHW2DContext != IMG_NULL);
+
+        if (hHW2DContext == IMG_NULL)
+        {
+                return (PVRSRV_ERROR_INVALID_PARAMS);
+        }
+
+        psCleanup = (SGX_HW_2D_CONTEXT_CLEANUP *)hHW2DContext;
+
+        eError = ResManFreeResByPtr(psCleanup->psResItem);
+
+        return eError;
+}
+#endif 
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SGX2DQuerySyncOpsComplete)
+#endif
+static INLINE
+IMG_BOOL SGX2DQuerySyncOpsComplete(PVRSRV_KERNEL_SYNC_INFO      *psSyncInfo,
+                                                                   IMG_UINT32                           ui32ReadOpsPending,
+                                                                   IMG_UINT32                           ui32WriteOpsPending)
+{
+        PVRSRV_SYNC_DATA *psSyncData = psSyncInfo->psSyncData;
+
+        return (IMG_BOOL)(
+                                          (psSyncData->ui32ReadOpsComplete >= ui32ReadOpsPending) &&
+                                          (psSyncData->ui32WriteOpsComplete >= ui32WriteOpsPending)
+                                         );
+}
+
+IMG_EXPORT
+PVRSRV_ERROR SGX2DQueryBlitsCompleteKM(PVRSRV_SGXDEV_INFO       *psDevInfo,
+                                                                           PVRSRV_KERNEL_SYNC_INFO *psSyncInfo,
+                                                                           IMG_BOOL bWaitForComplete)
+{
+        IMG_UINT32      ui32ReadOpsPending, ui32WriteOpsPending;
+
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+
+        PVR_DPF((PVR_DBG_CALLTRACE, "SGX2DQueryBlitsCompleteKM: Start"));
+
+        ui32ReadOpsPending = psSyncInfo->psSyncData->ui32ReadOpsPending;
+        ui32WriteOpsPending = psSyncInfo->psSyncData->ui32WriteOpsPending;
+
+        if(SGX2DQuerySyncOpsComplete(psSyncInfo, ui32ReadOpsPending, ui32WriteOpsPending))
+        {
+                
+                PVR_DPF((PVR_DBG_CALLTRACE, "SGX2DQueryBlitsCompleteKM: No wait. Blits complete."));
+                return PVRSRV_OK;
+        }
+
+        
+        if (!bWaitForComplete)
+        {
+                
+                PVR_DPF((PVR_DBG_CALLTRACE, "SGX2DQueryBlitsCompleteKM: No wait. Ops pending."));
+                return PVRSRV_ERROR_CMD_NOT_PROCESSED;
+        }
+
+        
+        PVR_DPF((PVR_DBG_MESSAGE, "SGX2DQueryBlitsCompleteKM: Ops pending. Start polling."));
+
+        LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
+        {
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+
+                if(SGX2DQuerySyncOpsComplete(psSyncInfo, ui32ReadOpsPending, ui32WriteOpsPending))
+                {
+                        
+                        PVR_DPF((PVR_DBG_CALLTRACE, "SGX2DQueryBlitsCompleteKM: Wait over.  Blits complete."));
+                        return PVRSRV_OK;
+                }
+
+                OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
+        } END_LOOP_UNTIL_TIMEOUT();
+
+        
+        PVR_DPF((PVR_DBG_ERROR,"SGX2DQueryBlitsCompleteKM: Timed out. Ops pending."));
+
+#if defined(DEBUG)
+        {
+                PVRSRV_SYNC_DATA *psSyncData = 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));
+
+        }
+#endif
+
+        return PVRSRV_ERROR_TIMEOUT;
+}
+
+
+IMG_EXPORT
+IMG_VOID SGXFlushHWRenderTargetKM(IMG_HANDLE psDeviceNode, IMG_DEV_VIRTADDR sHWRTDataSetDevVAddr)
+{
+        PVR_ASSERT(sHWRTDataSetDevVAddr.uiAddr != IMG_NULL);
+
+        SGXCleanupRequest(psDeviceNode,
+                                          &sHWRTDataSetDevVAddr,
+                                          PVRSRV_CLEANUPCMD_RT);
+}
+
+
+IMG_UINT32 SGXConvertTimeStamp(PVRSRV_SGXDEV_INFO       *psDevInfo,
+                                                           IMG_UINT32                   ui32TimeWraps,
+                                                           IMG_UINT32                   ui32Time)
+{
+#if defined(EUR_CR_TIMER)
+        PVR_UNREFERENCED_PARAMETER(psDevInfo);
+        PVR_UNREFERENCED_PARAMETER(ui32TimeWraps);
+        return ui32Time;
+#else
+        IMG_UINT64      ui64Clocks;
+        IMG_UINT32      ui32Clocksx16;
+
+        ui64Clocks = ((IMG_UINT64)ui32TimeWraps * psDevInfo->ui32uKernelTimerClock) +
+                                        (psDevInfo->ui32uKernelTimerClock - (ui32Time & EUR_CR_EVENT_TIMER_VALUE_MASK));
+        ui32Clocksx16 = (IMG_UINT32)(ui64Clocks / 16);
+
+        return ui32Clocksx16;
+#endif 
+}
+
+
+
diff --git a/drivers/gpu/pvr/sgx/sgxutils.h b/drivers/gpu/pvr/sgx/sgxutils.h
new file mode 100644
index 00000000000..bc4c0536795
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxutils.h
@@ -0,0 +1,99 @@
+/**********************************************************************
+ *
+ * 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 "perproc.h"
+#include "sgxinfokm.h"
+
+#define CCB_OFFSET_IS_VALID(type, psCCBMemInfo, psCCBKick, offset) \
+        ((sizeof(type) <= (psCCBMemInfo)->ui32AllocSize) && \
+        ((psCCBKick)->offset <= (psCCBMemInfo)->ui32AllocSize - sizeof(type)))
+
+#define CCB_DATA_FROM_OFFSET(type, psCCBMemInfo, psCCBKick, offset) \
+        ((type *)(((IMG_CHAR *)(psCCBMemInfo)->pvLinAddrKM) + \
+                (psCCBKick)->offset))
+
+
+IMG_IMPORT
+IMG_VOID SGXTestActivePowerEvent(PVRSRV_DEVICE_NODE     *psDeviceNode,
+                                                                 IMG_UINT32                     ui32CallerID);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXScheduleCCBCommand(PVRSRV_SGXDEV_INFO   *psDevInfo,
+                                                                   SGXMKIF_CMD_TYPE             eCommandType,
+                                                                   SGXMKIF_COMMAND              *psCommandData,
+                                                                   IMG_UINT32                   ui32CallerID,
+                                                                   IMG_UINT32                   ui32PDumpFlags);
+IMG_IMPORT
+PVRSRV_ERROR SGXScheduleCCBCommandKM(PVRSRV_DEVICE_NODE         *psDeviceNode,
+                                                                         SGXMKIF_CMD_TYPE               eCommandType,
+                                                                         SGXMKIF_COMMAND                *psCommandData,
+                                                                         IMG_UINT32                             ui32CallerID,
+                                                                         IMG_UINT32                             ui32PDumpFlags);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXScheduleProcessQueuesKM(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_IMPORT
+IMG_BOOL SGXIsDevicePowered(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_IMPORT
+IMG_HANDLE SGXRegisterHWRenderContextKM(IMG_HANDLE                              psDeviceNode,
+                                                                                IMG_DEV_VIRTADDR                *psHWRenderContextDevVAddr,
+                                                                                PVRSRV_PER_PROCESS_DATA *psPerProc);
+
+IMG_IMPORT
+IMG_HANDLE SGXRegisterHWTransferContextKM(IMG_HANDLE                            psDeviceNode,
+                                                                                  IMG_DEV_VIRTADDR                      *psHWTransferContextDevVAddr,
+                                                                                  PVRSRV_PER_PROCESS_DATA       *psPerProc);
+
+IMG_IMPORT
+IMG_VOID SGXFlushHWRenderTargetKM(IMG_HANDLE psSGXDevInfo, IMG_DEV_VIRTADDR psHWRTDataSetDevVAddr);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXUnregisterHWRenderContextKM(IMG_HANDLE hHWRenderContext);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXUnregisterHWTransferContextKM(IMG_HANDLE hHWTransferContext);
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+IMG_IMPORT
+IMG_HANDLE SGXRegisterHW2DContextKM(IMG_HANDLE                          psDeviceNode,
+                                                                        IMG_DEV_VIRTADDR                *psHW2DContextDevVAddr,
+                                                                        PVRSRV_PER_PROCESS_DATA *psPerProc);
+
+IMG_IMPORT
+PVRSRV_ERROR SGXUnregisterHW2DContextKM(IMG_HANDLE hHW2DContext);
+#endif
+
+IMG_UINT32 SGXConvertTimeStamp(PVRSRV_SGXDEV_INFO       *psDevInfo,
+                                                           IMG_UINT32                   ui32TimeWraps,
+                                                           IMG_UINT32                   ui32Time);
+
+IMG_VOID SGXCleanupRequest(PVRSRV_DEVICE_NODE   *psDeviceNode,
+                                                        IMG_DEV_VIRTADDR        *psHWDataDevVAddr,
+                                                        IMG_UINT32                      ui32CleanupType);
+                                                           
+
diff --git a/drivers/gpu/pvr/sgx530defs.h b/drivers/gpu/pvr/sgx530defs.h
new file mode 100644
index 00000000000..525f51d6569
--- /dev/null
+++ b/drivers/gpu/pvr/sgx530defs.h
@@ -0,0 +1,488 @@
+/**********************************************************************
+ *
+ * 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 _SGX530DEFS_KM_H_
+#define _SGX530DEFS_KM_H_
+
+#define EUR_CR_CLKGATECTL                   0x0000
+#define EUR_CR_CLKGATECTL_2D_CLKG_MASK      0x00000003U
+#define EUR_CR_CLKGATECTL_2D_CLKG_SHIFT     0
+#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK     0x00000030U
+#define EUR_CR_CLKGATECTL_ISP_CLKG_SHIFT    4
+#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK     0x00000300U
+#define EUR_CR_CLKGATECTL_TSP_CLKG_SHIFT    8
+#define EUR_CR_CLKGATECTL_TA_CLKG_MASK      0x00003000U
+#define EUR_CR_CLKGATECTL_TA_CLKG_SHIFT     12
+#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK     0x00030000U
+#define EUR_CR_CLKGATECTL_DPM_CLKG_SHIFT    16
+#define EUR_CR_CLKGATECTL_USE_CLKG_MASK     0x00300000U
+#define EUR_CR_CLKGATECTL_USE_CLKG_SHIFT    20
+#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   0x00000001U
+#define EUR_CR_CLKGATESTATUS_2D_CLKS_SHIFT  0
+#define EUR_CR_CLKGATESTATUS_ISP_CLKS_MASK  0x00000010U
+#define EUR_CR_CLKGATESTATUS_ISP_CLKS_SHIFT 4
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK  0x00000100U
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_SHIFT 8
+#define EUR_CR_CLKGATESTATUS_TA_CLKS_MASK   0x00001000U
+#define EUR_CR_CLKGATESTATUS_TA_CLKS_SHIFT  12
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK  0x00010000U
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_SHIFT 16
+#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   0x00000003U
+#define EUR_CR_CLKGATECTLOVR_2D_CLKO_SHIFT  0
+#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_MASK  0x00000030U
+#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_SHIFT 4
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK  0x00000300U
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_SHIFT 8
+#define EUR_CR_CLKGATECTLOVR_TA_CLKO_MASK   0x00003000U
+#define EUR_CR_CLKGATECTLOVR_TA_CLKO_SHIFT  12
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK  0x00030000U
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_SHIFT 16
+#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          0x0000FFFFU
+#define EUR_CR_CORE_ID_CONFIG_SHIFT         0
+#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 0x000000FFU
+#define EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT 0
+#define EUR_CR_CORE_REVISION_MINOR_MASK     0x0000FF00U
+#define EUR_CR_CORE_REVISION_MINOR_SHIFT    8
+#define EUR_CR_CORE_REVISION_MAJOR_MASK     0x00FF0000U
+#define EUR_CR_CORE_REVISION_MAJOR_SHIFT    16
+#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 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 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    0x00000001U
+#define EUR_CR_SOFT_RESET_BIF_RESET_SHIFT   0
+#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    0x00000004U
+#define EUR_CR_SOFT_RESET_DPM_RESET_SHIFT   2
+#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    0x00000010U
+#define EUR_CR_SOFT_RESET_USE_RESET_SHIFT   4
+#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    0x00000040U
+#define EUR_CR_SOFT_RESET_TSP_RESET_SHIFT   6
+#define EUR_CR_EVENT_HOST_ENABLE2           0x0110
+#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 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 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 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   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 0x00000001U
+#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_SHIFT 0
+#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      0x20000000U
+#define EUR_CR_EVENT_STATUS_TIMER_SHIFT     29
+#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 0x08000000U
+#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_SHIFT 27
+#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 0x02000000U
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
+#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 0x00800000U
+#define EUR_CR_EVENT_STATUS_ISP_END_TILE_SHIFT 23
+#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 0x00200000U
+#define EUR_CR_EVENT_STATUS_OTPM_LOADED_SHIFT 21
+#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 0x00080000U
+#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_SHIFT 19
+#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   0x00020000U
+#define EUR_CR_EVENT_STATUS_ISP_HALT_SHIFT  17
+#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 0x00008000U
+#define EUR_CR_EVENT_STATUS_BREAKPOINT_SHIFT 15
+#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 0x00002000U
+#define EUR_CR_EVENT_STATUS_TA_FINISHED_SHIFT 13
+#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  0x00000800U
+#define EUR_CR_EVENT_STATUS_TPC_CLEAR_SHIFT 11
+#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 0x00000200U
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_SHIFT 9
+#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 0x00000080U
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_SHIFT 7
+#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 0x00000020U
+#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_SHIFT 5
+#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 0x00000008U
+#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_SHIFT 3
+#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 0x00000002U
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_SHIFT 1
+#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 0x80000000U
+#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_SHIFT 31
+#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 0x10000000U
+#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_SHIFT 28
+#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 0x04000000U
+#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_SHIFT 26
+#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 0x01000000U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_SHIFT 24
+#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 0x00400000U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_SHIFT 22
+#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 0x00100000U
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_SHIFT 20
+#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 0x00040000U
+#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_SHIFT 18
+#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 0x00010000U
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_SHIFT 16
+#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 0x00004000U
+#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_SHIFT 14
+#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 0x00001000U
+#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_SHIFT 12
+#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 0x00000400U
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_SHIFT 10
+#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 0x00000100U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_SHIFT 8
+#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 0x00000040U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_SHIFT 6
+#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 0x00000010U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_SHIFT 4
+#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 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 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 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 0x80000000U
+#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_SHIFT 31
+#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 0x10000000U
+#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_SHIFT 28
+#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 0x04000000U
+#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_SHIFT 26
+#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 0x01000000U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_SHIFT 24
+#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 0x00400000U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_SHIFT 22
+#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 0x00100000U
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_SHIFT 20
+#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 0x00040000U
+#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_SHIFT 18
+#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 0x00010000U
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_SHIFT 16
+#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 0x00004000U
+#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_SHIFT 14
+#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 0x00001000U
+#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_SHIFT 12
+#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 0x00000400U
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_SHIFT 10
+#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 0x00000100U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_SHIFT 8
+#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 0x00000040U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_SHIFT 6
+#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 0x00000010U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_SHIFT 4
+#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 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 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 0x00000001U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_SHIFT 0
+#define EUR_CR_PDS_EXEC_BASE                0x0AB8
+#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    0x0FFFFFF0U
+#define EUR_CR_EVENT_KICKER_ADDRESS_SHIFT   4
+#define EUR_CR_EVENT_KICK                   0x0AC8
+#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      0x01000000U
+#define EUR_CR_EVENT_TIMER_ENABLE_SHIFT     24
+#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            0x00000001U
+#define EUR_CR_PDS_INV0_DSC_SHIFT           0
+#define EUR_CR_PDS_INV1                     0x0AD4
+#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            0x00000001U
+#define EUR_CR_PDS_INV2_DSC_SHIFT           0
+#define EUR_CR_PDS_INV3                     0x0ADC
+#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        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     0x3FFFFFFFU
+#define EUR_CR_PDS_PC_BASE_ADDRESS_SHIFT    0
+#define EUR_CR_BIF_CTRL                     0x0C00
+#define EUR_CR_BIF_CTRL_NOREORDER_MASK      0x00000001U
+#define EUR_CR_BIF_CTRL_NOREORDER_SHIFT     0
+#define EUR_CR_BIF_CTRL_PAUSE_MASK          0x00000002U
+#define EUR_CR_BIF_CTRL_PAUSE_SHIFT         1
+#define EUR_CR_BIF_CTRL_FLUSH_MASK          0x00000004U
+#define EUR_CR_BIF_CTRL_FLUSH_SHIFT         2
+#define EUR_CR_BIF_CTRL_INVALDC_MASK        0x00000008U
+#define EUR_CR_BIF_CTRL_INVALDC_SHIFT       3
+#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 0x00000100U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_SHIFT 8
+#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  0x00000400U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_SHIFT 10
+#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 0x00001000U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_PBE_SHIFT 12
+#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 0x00004000U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_ISP_SHIFT 14
+#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      0x00003FFFU
+#define EUR_CR_BIF_INT_STAT_FAULT_SHIFT     0
+#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          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 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  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    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  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    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   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 0x00FFFFFFU
+#define EUR_CR_2D_BLIT_STATUS_COMPLETE_SHIFT 0
+#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 0x00000001U
+#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_SHIFT 0
+#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 0x00000FF0U
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_SHIFT 4
+#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 0x00000FFFU
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_SHIFT 0
+#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 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      0x00FFFFFFU
+#define EUR_CR_USE_CODE_BASE_ADDR_SHIFT     0
+#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 
+
diff --git a/drivers/gpu/pvr/sgx540defs.h b/drivers/gpu/pvr/sgx540defs.h
new file mode 100644
index 00000000000..dadbb1eaa01
--- /dev/null
+++ b/drivers/gpu/pvr/sgx540defs.h
@@ -0,0 +1,547 @@
+/**********************************************************************
+ *
+ * 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 _SGX540DEFS_KM_H_
+#define _SGX540DEFS_KM_H_
+
+#define EUR_CR_CLKGATECTL                   0x0000
+#define EUR_CR_CLKGATECTL_ISP_CLKG_MASK     0x00000003U
+#define EUR_CR_CLKGATECTL_ISP_CLKG_SHIFT    0
+#define EUR_CR_CLKGATECTL_ISP2_CLKG_MASK    0x0000000CU
+#define EUR_CR_CLKGATECTL_ISP2_CLKG_SHIFT   2
+#define EUR_CR_CLKGATECTL_TSP_CLKG_MASK     0x00000030U
+#define EUR_CR_CLKGATECTL_TSP_CLKG_SHIFT    4
+#define EUR_CR_CLKGATECTL_TE_CLKG_MASK      0x000000C0U
+#define EUR_CR_CLKGATECTL_TE_CLKG_SHIFT     6
+#define EUR_CR_CLKGATECTL_MTE_CLKG_MASK     0x00000300U
+#define EUR_CR_CLKGATECTL_MTE_CLKG_SHIFT    8
+#define EUR_CR_CLKGATECTL_DPM_CLKG_MASK     0x00000C00U
+#define EUR_CR_CLKGATECTL_DPM_CLKG_SHIFT    10
+#define EUR_CR_CLKGATECTL_VDM_CLKG_MASK     0x00003000U
+#define EUR_CR_CLKGATECTL_VDM_CLKG_SHIFT    12
+#define EUR_CR_CLKGATECTL_PDS_CLKG_MASK     0x0000C000U
+#define EUR_CR_CLKGATECTL_PDS_CLKG_SHIFT    14
+#define EUR_CR_CLKGATECTL_IDXFIFO_CLKG_MASK 0x00030000U
+#define EUR_CR_CLKGATECTL_IDXFIFO_CLKG_SHIFT 16
+#define EUR_CR_CLKGATECTL_TA_CLKG_MASK      0x000C0000U
+#define EUR_CR_CLKGATECTL_TA_CLKG_SHIFT     18
+#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  0x10000000U
+#define EUR_CR_CLKGATECTL_SYSTEM_CLKG_SHIFT 28
+#define EUR_CR_CLKGATECTL2                  0x0004
+#define EUR_CR_CLKGATECTL2_PBE_CLKG_MASK    0x00000003U
+#define EUR_CR_CLKGATECTL2_PBE_CLKG_SHIFT   0
+#define EUR_CR_CLKGATECTL2_CACHEL2_CLKG_MASK 0x0000000CU
+#define EUR_CR_CLKGATECTL2_CACHEL2_CLKG_SHIFT 2
+#define EUR_CR_CLKGATECTL2_UCACHEL2_CLKG_MASK 0x00000030U
+#define EUR_CR_CLKGATECTL2_UCACHEL2_CLKG_SHIFT 4
+#define EUR_CR_CLKGATECTL2_USE0_CLKG_MASK   0x000000C0U
+#define EUR_CR_CLKGATECTL2_USE0_CLKG_SHIFT  6
+#define EUR_CR_CLKGATECTL2_ITR0_CLKG_MASK   0x00000300U
+#define EUR_CR_CLKGATECTL2_ITR0_CLKG_SHIFT  8
+#define EUR_CR_CLKGATECTL2_TEX0_CLKG_MASK   0x00000C00U
+#define EUR_CR_CLKGATECTL2_TEX0_CLKG_SHIFT  10
+#define EUR_CR_CLKGATECTL2_MADD0_CLKG_MASK  0x00003000U
+#define EUR_CR_CLKGATECTL2_MADD0_CLKG_SHIFT 12
+#define EUR_CR_CLKGATECTL2_USE1_CLKG_MASK   0x0000C000U
+#define EUR_CR_CLKGATECTL2_USE1_CLKG_SHIFT  14
+#define EUR_CR_CLKGATECTL2_ITR1_CLKG_MASK   0x00030000U
+#define EUR_CR_CLKGATECTL2_ITR1_CLKG_SHIFT  16
+#define EUR_CR_CLKGATECTL2_TEX1_CLKG_MASK   0x000C0000U
+#define EUR_CR_CLKGATECTL2_TEX1_CLKG_SHIFT  18
+#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  0x00000001U
+#define EUR_CR_CLKGATESTATUS_ISP_CLKS_SHIFT 0
+#define EUR_CR_CLKGATESTATUS_ISP2_CLKS_MASK 0x00000002U
+#define EUR_CR_CLKGATESTATUS_ISP2_CLKS_SHIFT 1
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_MASK  0x00000004U
+#define EUR_CR_CLKGATESTATUS_TSP_CLKS_SHIFT 2
+#define EUR_CR_CLKGATESTATUS_TE_CLKS_MASK   0x00000008U
+#define EUR_CR_CLKGATESTATUS_TE_CLKS_SHIFT  3
+#define EUR_CR_CLKGATESTATUS_MTE_CLKS_MASK  0x00000010U
+#define EUR_CR_CLKGATESTATUS_MTE_CLKS_SHIFT 4
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_MASK  0x00000020U
+#define EUR_CR_CLKGATESTATUS_DPM_CLKS_SHIFT 5
+#define EUR_CR_CLKGATESTATUS_VDM_CLKS_MASK  0x00000040U
+#define EUR_CR_CLKGATESTATUS_VDM_CLKS_SHIFT 6
+#define EUR_CR_CLKGATESTATUS_PDS_CLKS_MASK  0x00000080U
+#define EUR_CR_CLKGATESTATUS_PDS_CLKS_SHIFT 7
+#define EUR_CR_CLKGATESTATUS_PBE_CLKS_MASK  0x00000100U
+#define EUR_CR_CLKGATESTATUS_PBE_CLKS_SHIFT 8
+#define EUR_CR_CLKGATESTATUS_CACHEL2_CLKS_MASK 0x00000200U
+#define EUR_CR_CLKGATESTATUS_CACHEL2_CLKS_SHIFT 9
+#define EUR_CR_CLKGATESTATUS_UCACHEL2_CLKS_MASK 0x00000400U
+#define EUR_CR_CLKGATESTATUS_UCACHEL2_CLKS_SHIFT 10
+#define EUR_CR_CLKGATESTATUS_USE0_CLKS_MASK 0x00000800U
+#define EUR_CR_CLKGATESTATUS_USE0_CLKS_SHIFT 11
+#define EUR_CR_CLKGATESTATUS_ITR0_CLKS_MASK 0x00001000U
+#define EUR_CR_CLKGATESTATUS_ITR0_CLKS_SHIFT 12
+#define EUR_CR_CLKGATESTATUS_TEX0_CLKS_MASK 0x00002000U
+#define EUR_CR_CLKGATESTATUS_TEX0_CLKS_SHIFT 13
+#define EUR_CR_CLKGATESTATUS_MADD0_CLKS_MASK 0x00004000U
+#define EUR_CR_CLKGATESTATUS_MADD0_CLKS_SHIFT 14
+#define EUR_CR_CLKGATESTATUS_USE1_CLKS_MASK 0x00008000U
+#define EUR_CR_CLKGATESTATUS_USE1_CLKS_SHIFT 15
+#define EUR_CR_CLKGATESTATUS_ITR1_CLKS_MASK 0x00010000U
+#define EUR_CR_CLKGATESTATUS_ITR1_CLKS_SHIFT 16
+#define EUR_CR_CLKGATESTATUS_TEX1_CLKS_MASK 0x00020000U
+#define EUR_CR_CLKGATESTATUS_TEX1_CLKS_SHIFT 17
+#define EUR_CR_CLKGATESTATUS_MADD1_CLKS_MASK 0x00040000U
+#define EUR_CR_CLKGATESTATUS_MADD1_CLKS_SHIFT 18
+#define EUR_CR_CLKGATESTATUS_IDXFIFO_CLKS_MASK 0x00080000U
+#define EUR_CR_CLKGATESTATUS_IDXFIFO_CLKS_SHIFT 19
+#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  0x00000003U
+#define EUR_CR_CLKGATECTLOVR_ISP_CLKO_SHIFT 0
+#define EUR_CR_CLKGATECTLOVR_ISP2_CLKO_MASK 0x0000000CU
+#define EUR_CR_CLKGATECTLOVR_ISP2_CLKO_SHIFT 2
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_MASK  0x00000030U
+#define EUR_CR_CLKGATECTLOVR_TSP_CLKO_SHIFT 4
+#define EUR_CR_CLKGATECTLOVR_TE_CLKO_MASK   0x000000C0U
+#define EUR_CR_CLKGATECTLOVR_TE_CLKO_SHIFT  6
+#define EUR_CR_CLKGATECTLOVR_MTE_CLKO_MASK  0x00000300U
+#define EUR_CR_CLKGATECTLOVR_MTE_CLKO_SHIFT 8
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_MASK  0x00000C00U
+#define EUR_CR_CLKGATECTLOVR_DPM_CLKO_SHIFT 10
+#define EUR_CR_CLKGATECTLOVR_VDM_CLKO_MASK  0x00003000U
+#define EUR_CR_CLKGATECTLOVR_VDM_CLKO_SHIFT 12
+#define EUR_CR_CLKGATECTLOVR_PDS_CLKO_MASK  0x0000C000U
+#define EUR_CR_CLKGATECTLOVR_PDS_CLKO_SHIFT 14
+#define EUR_CR_CLKGATECTLOVR_IDXFIFO_CLKO_MASK 0x00030000U
+#define EUR_CR_CLKGATECTLOVR_IDXFIFO_CLKO_SHIFT 16
+#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      0x00000001U
+#define EUR_CR_POWER_PIPE_DISABLE_SHIFT     0
+#define EUR_CR_CORE_ID                      0x0020
+#define EUR_CR_CORE_ID_CONFIG_MASK          0x0000FFFFU
+#define EUR_CR_CORE_ID_CONFIG_SHIFT         0
+#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 0x000000FFU
+#define EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT 0
+#define EUR_CR_CORE_REVISION_MINOR_MASK     0x0000FF00U
+#define EUR_CR_CORE_REVISION_MINOR_SHIFT    8
+#define EUR_CR_CORE_REVISION_MAJOR_MASK     0x00FF0000U
+#define EUR_CR_CORE_REVISION_MAJOR_SHIFT    16
+#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 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 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    0x00000001U
+#define EUR_CR_SOFT_RESET_BIF_RESET_SHIFT   0
+#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    0x00000004U
+#define EUR_CR_SOFT_RESET_DPM_RESET_SHIFT   2
+#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    0x00000010U
+#define EUR_CR_SOFT_RESET_MTE_RESET_SHIFT   4
+#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   0x00000040U
+#define EUR_CR_SOFT_RESET_ISP2_RESET_SHIFT  6
+#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    0x00000100U
+#define EUR_CR_SOFT_RESET_PDS_RESET_SHIFT   8
+#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 0x00000400U
+#define EUR_CR_SOFT_RESET_CACHEL2_RESET_SHIFT 10
+#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   0x00001000U
+#define EUR_CR_SOFT_RESET_MADD_RESET_SHIFT  12
+#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    0x00004000U
+#define EUR_CR_SOFT_RESET_TEX_RESET_SHIFT   14
+#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 0x00010000U
+#define EUR_CR_SOFT_RESET_IDXFIFO_RESET_SHIFT 16
+#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 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 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 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 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   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 0x00000001U
+#define EUR_CR_EVENT_STATUS2_DPM_TA_FREE_LOAD_SHIFT 0
+#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      0x20000000U
+#define EUR_CR_EVENT_STATUS_TIMER_SHIFT     29
+#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 0x08000000U
+#define EUR_CR_EVENT_STATUS_TWOD_COMPLETE_SHIFT 27
+#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 0x02000000U
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_ZLS_SHIFT 25
+#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 0x00800000U
+#define EUR_CR_EVENT_STATUS_ISP_END_TILE_SHIFT 23
+#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 0x00200000U
+#define EUR_CR_EVENT_STATUS_OTPM_LOADED_SHIFT 21
+#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 0x00080000U
+#define EUR_CR_EVENT_STATUS_OTPM_FLUSHED_SHIFT 19
+#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   0x00020000U
+#define EUR_CR_EVENT_STATUS_ISP_HALT_SHIFT  17
+#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 0x00008000U
+#define EUR_CR_EVENT_STATUS_BREAKPOINT_SHIFT 15
+#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 0x00002000U
+#define EUR_CR_EVENT_STATUS_TA_FINISHED_SHIFT 13
+#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  0x00000800U
+#define EUR_CR_EVENT_STATUS_TPC_CLEAR_SHIFT 11
+#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 0x00000200U
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_CLEAR_SHIFT 9
+#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 0x00000080U
+#define EUR_CR_EVENT_STATUS_DPM_CONTROL_STORE_SHIFT 7
+#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 0x00000020U
+#define EUR_CR_EVENT_STATUS_DPM_STATE_LOAD_SHIFT 5
+#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 0x00000008U
+#define EUR_CR_EVENT_STATUS_DPM_REACHED_MEM_THRESH_SHIFT 3
+#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 0x00000002U
+#define EUR_CR_EVENT_STATUS_DPM_OUT_OF_MEMORY_MT_SHIFT 1
+#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 0x80000000U
+#define EUR_CR_EVENT_HOST_ENABLE_MASTER_INTERRUPT_SHIFT 31
+#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 0x10000000U
+#define EUR_CR_EVENT_HOST_ENABLE_TA_DPM_FAULT_SHIFT 28
+#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 0x04000000U
+#define EUR_CR_EVENT_HOST_ENABLE_MADD_CACHE_INVALCOMPLETE_SHIFT 26
+#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 0x01000000U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_TA_MEM_FREE_SHIFT 24
+#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 0x00400000U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_INITEND_SHIFT 22
+#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 0x00100000U
+#define EUR_CR_EVENT_HOST_ENABLE_OTPM_INV_SHIFT 20
+#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 0x00040000U
+#define EUR_CR_EVENT_HOST_ENABLE_PIXELBE_END_RENDER_SHIFT 18
+#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 0x00010000U
+#define EUR_CR_EVENT_HOST_ENABLE_ISP_VISIBILITY_FAIL_SHIFT 16
+#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 0x00004000U
+#define EUR_CR_EVENT_HOST_ENABLE_SW_EVENT_SHIFT 14
+#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 0x00001000U
+#define EUR_CR_EVENT_HOST_ENABLE_TA_TERMINATE_SHIFT 12
+#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 0x00000400U
+#define EUR_CR_EVENT_HOST_ENABLE_TPC_FLUSH_SHIFT 10
+#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 0x00000100U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_CONTROL_LOAD_SHIFT 8
+#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 0x00000040U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_CLEAR_SHIFT 6
+#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 0x00000010U
+#define EUR_CR_EVENT_HOST_ENABLE_DPM_STATE_STORE_SHIFT 4
+#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 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 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 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 0x80000000U
+#define EUR_CR_EVENT_HOST_CLEAR_MASTER_INTERRUPT_SHIFT 31
+#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 0x10000000U
+#define EUR_CR_EVENT_HOST_CLEAR_TA_DPM_FAULT_SHIFT 28
+#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 0x04000000U
+#define EUR_CR_EVENT_HOST_CLEAR_MADD_CACHE_INVALCOMPLETE_SHIFT 26
+#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 0x01000000U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_TA_MEM_FREE_SHIFT 24
+#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 0x00400000U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_INITEND_SHIFT 22
+#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 0x00100000U
+#define EUR_CR_EVENT_HOST_CLEAR_OTPM_INV_SHIFT 20
+#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 0x00040000U
+#define EUR_CR_EVENT_HOST_CLEAR_PIXELBE_END_RENDER_SHIFT 18
+#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 0x00010000U
+#define EUR_CR_EVENT_HOST_CLEAR_ISP_VISIBILITY_FAIL_SHIFT 16
+#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 0x00004000U
+#define EUR_CR_EVENT_HOST_CLEAR_SW_EVENT_SHIFT 14
+#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 0x00001000U
+#define EUR_CR_EVENT_HOST_CLEAR_TA_TERMINATE_SHIFT 12
+#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 0x00000400U
+#define EUR_CR_EVENT_HOST_CLEAR_TPC_FLUSH_SHIFT 10
+#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 0x00000100U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_CONTROL_LOAD_SHIFT 8
+#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 0x00000040U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_CLEAR_SHIFT 6
+#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 0x00000010U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_STATE_STORE_SHIFT 4
+#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 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 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 0x00000001U
+#define EUR_CR_EVENT_HOST_CLEAR_DPM_3D_MEM_FREE_SHIFT 0
+#define EUR_CR_TIMER                        0x0144
+#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         0x000000FFU
+#define EUR_CR_EVENT_KICK1_NOW_SHIFT        0
+#define EUR_CR_PDS_EXEC_BASE                0x0AB8
+#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         0x00000001U
+#define EUR_CR_EVENT_KICK2_NOW_SHIFT        0
+#define EUR_CR_EVENT_KICKER                 0x0AC4
+#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          0x00000001U
+#define EUR_CR_EVENT_KICK_NOW_SHIFT         0
+#define EUR_CR_EVENT_TIMER                  0x0ACC
+#define EUR_CR_EVENT_TIMER_ENABLE_MASK      0x01000000U
+#define EUR_CR_EVENT_TIMER_ENABLE_SHIFT     24
+#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            0x00000001U
+#define EUR_CR_PDS_INV0_DSC_SHIFT           0
+#define EUR_CR_PDS_INV1                     0x0AD4
+#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         0x00000001U
+#define EUR_CR_EVENT_KICK3_NOW_SHIFT        0
+#define EUR_CR_PDS_INV3                     0x0ADC
+#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        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     0x00FFFFFFU
+#define EUR_CR_PDS_PC_BASE_ADDRESS_SHIFT    0
+#define EUR_CR_BIF_CTRL                     0x0C00
+#define EUR_CR_BIF_CTRL_NOREORDER_MASK      0x00000001U
+#define EUR_CR_BIF_CTRL_NOREORDER_SHIFT     0
+#define EUR_CR_BIF_CTRL_PAUSE_MASK          0x00000002U
+#define EUR_CR_BIF_CTRL_PAUSE_SHIFT         1
+#define EUR_CR_BIF_CTRL_FLUSH_MASK          0x00000004U
+#define EUR_CR_BIF_CTRL_FLUSH_SHIFT         2
+#define EUR_CR_BIF_CTRL_INVALDC_MASK        0x00000008U
+#define EUR_CR_BIF_CTRL_INVALDC_SHIFT       3
+#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 0x00000100U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_CACHE_SHIFT 8
+#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  0x00000400U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TE_SHIFT 10
+#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 0x00002000U
+#define EUR_CR_BIF_CTRL_MMU_BYPASS_TSPP_SHIFT 13
+#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 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      0x00003FFFU
+#define EUR_CR_BIF_INT_STAT_FAULT_SHIFT     0
+#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_SB_MASK            0x000001F0U
+#define EUR_CR_BIF_FAULT_SB_SHIFT           4
+#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 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    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  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    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   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 0x00FFFFFFU
+#define EUR_CR_2D_BLIT_STATUS_COMPLETE_SHIFT 0
+#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 0x00000001U
+#define EUR_CR_2D_VIRTUAL_FIFO_0_ENABLE_SHIFT 0
+#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 0x00000FF0U
+#define EUR_CR_2D_VIRTUAL_FIFO_0_FLOWRATE_DIV_SHIFT 4
+#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 0x00000FFFU
+#define EUR_CR_2D_VIRTUAL_FIFO_1_MIN_ACC_SHIFT 0
+#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 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      0x00FFFFFFU
+#define EUR_CR_USE_CODE_BASE_ADDR_SHIFT     0
+#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
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx_bridge.h b/drivers/gpu/pvr/sgx_bridge.h
new file mode 100644
index 00000000000..10e59196ef9
--- /dev/null
+++ b/drivers/gpu/pvr/sgx_bridge.h
@@ -0,0 +1,466 @@
+/**********************************************************************
+ *
+ * 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(__SGX_BRIDGE_H__)
+#define __SGX_BRIDGE_H__
+
+#include "sgxapi_km.h"
+#include "sgxinfo.h"
+#include "pvr_bridge.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+#define PVRSRV_BRIDGE_SGX_CMD_BASE (PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD+1)
+#define PVRSRV_BRIDGE_SGX_GETCLIENTINFO                 PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+0)
+#define PVRSRV_BRIDGE_SGX_RELEASECLIENTINFO             PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+1)
+#define PVRSRV_BRIDGE_SGX_GETINTERNALDEVINFO    PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+2)
+#define PVRSRV_BRIDGE_SGX_DOKICK                                PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+3)
+#define PVRSRV_BRIDGE_SGX_GETPHYSPAGEADDR               PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+4)
+#define PVRSRV_BRIDGE_SGX_READREGISTRYDWORD             PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+5)
+
+#define PVRSRV_BRIDGE_SGX_2DQUERYBLTSCOMPLETE   PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+9)
+
+#define PVRSRV_BRIDGE_SGX_GETMMUPDADDR                  PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+10)  
+
+#if defined(TRANSFER_QUEUE)
+#define PVRSRV_BRIDGE_SGX_SUBMITTRANSFER                        PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+13)
+#endif
+#define PVRSRV_BRIDGE_SGX_GETMISCINFO                           PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+14)
+#define PVRSRV_BRIDGE_SGXINFO_FOR_SRVINIT                       PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+15)
+#define PVRSRV_BRIDGE_SGX_DEVINITPART2                          PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+16)
+
+#define PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC                      PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+17)
+#define PVRSRV_BRIDGE_SGX_UNREFSHAREDPBDESC                     PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+18)
+#define PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC                       PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+19)
+#define PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT    PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+20)
+#define PVRSRV_BRIDGE_SGX_FLUSH_HW_RENDER_TARGET        PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+21)
+#define PVRSRV_BRIDGE_SGX_UNREGISTER_HW_RENDER_CONTEXT  PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+22)
+#if defined(SGX_FEATURE_2D_HARDWARE)
+#define PVRSRV_BRIDGE_SGX_SUBMIT2D                                      PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+23)
+#define PVRSRV_BRIDGE_SGX_REGISTER_HW_2D_CONTEXT        PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+24)
+#define PVRSRV_BRIDGE_SGX_UNREGISTER_HW_2D_CONTEXT      PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+25)
+#endif
+#define PVRSRV_BRIDGE_SGX_REGISTER_HW_TRANSFER_CONTEXT  PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+26)
+#define PVRSRV_BRIDGE_SGX_UNREGISTER_HW_TRANSFER_CONTEXT        PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+27)
+
+#define PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES               PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+28)
+
+#define PVRSRV_BRIDGE_SGX_READ_HWPERF_CB                        PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+30)
+
+#if defined(PDUMP)
+#define PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY            PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+31)
+#define PVRSRV_BRIDGE_SGX_PDUMP_3D_SIGNATURE_REGISTERS  PVRSRV_IOWR(PVRSRV_BRIDGE_SGX_CMD_BASE+32)
+#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+36)
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GETPHYSPAGEADDR
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevMemHeap;
+        IMG_DEV_VIRTADDR sDevVAddr;
+}PVRSRV_BRIDGE_IN_GETPHYSPAGEADDR;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GETPHYSPAGEADDR
+{
+        PVRSRV_ERROR            eError;
+        IMG_DEV_PHYADDR         DevPAddr;
+        IMG_CPU_PHYADDR         CpuPAddr;
+}PVRSRV_BRIDGE_OUT_GETPHYSPAGEADDR;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SGX_GETMMU_PDADDR_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        IMG_HANDLE                              hDevMemContext;
+}PVRSRV_BRIDGE_IN_SGX_GETMMU_PDADDR;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_SGX_GETMMU_PDADDR_TAG
+{
+        IMG_DEV_PHYADDR                 sPDDevPAddr;
+        PVRSRV_ERROR                    eError;
+}PVRSRV_BRIDGE_OUT_SGX_GETMMU_PDADDR;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GETCLIENTINFO_TAG
+{
+        IMG_UINT32                                      ui32BridgeFlags; 
+        IMG_HANDLE                                      hDevCookie;
+}PVRSRV_BRIDGE_IN_GETCLIENTINFO;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GETINTERNALDEVINFO_TAG
+{
+        SGX_INTERNAL_DEVINFO    sSGXInternalDevInfo;
+        PVRSRV_ERROR                            eError;
+}PVRSRV_BRIDGE_OUT_GETINTERNALDEVINFO;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_GETINTERNALDEVINFO_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+}PVRSRV_BRIDGE_IN_GETINTERNALDEVINFO;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_GETCLIENTINFO_TAG
+{
+        SGX_CLIENT_INFO         sClientInfo;
+        PVRSRV_ERROR                    eError;
+}PVRSRV_BRIDGE_OUT_GETCLIENTINFO;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_RELEASECLIENTINFO_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        SGX_CLIENT_INFO         sClientInfo;
+}PVRSRV_BRIDGE_IN_RELEASECLIENTINFO;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_ISPBREAKPOLL_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+}PVRSRV_BRIDGE_IN_ISPBREAKPOLL;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_DOKICK_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        SGX_CCB_KICK                    sCCBKick;
+}PVRSRV_BRIDGE_IN_DOKICK;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_SGX_SCHEDULE_PROCESS_QUEUES_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+}PVRSRV_BRIDGE_IN_SGX_SCHEDULE_PROCESS_QUEUES;
+
+
+#if defined(TRANSFER_QUEUE)
+ 
+typedef struct PVRSRV_BRIDGE_IN_SUBMITTRANSFER_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        PVRSRV_TRANSFER_SGX_KICK                        sKick;
+}PVRSRV_BRIDGE_IN_SUBMITTRANSFER;
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+ 
+typedef struct PVRSRV_BRIDGE_IN_SUBMIT2D_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        PVRSRV_2D_SGX_KICK                              sKick;
+} PVRSRV_BRIDGE_IN_SUBMIT2D;
+#endif
+#endif
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_READREGDWORD_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+    IMG_PCHAR                           pszKey;
+    IMG_PCHAR                           pszValue;
+}PVRSRV_BRIDGE_IN_READREGDWORD;
+
+ 
+typedef struct PVRSRV_BRIDGE_OUT_READREGDWORD_TAG
+{
+        PVRSRV_ERROR    eError;
+        IMG_UINT32              ui32Data;
+}PVRSRV_BRIDGE_OUT_READREGDWORD;
+
+
+typedef struct PVRSRV_BRIDGE_IN_SGXGETMISCINFO_TAG
+{
+        IMG_UINT32              ui32BridgeFlags; 
+        IMG_HANDLE              hDevCookie;
+        SGX_MISC_INFO   *psMiscInfo;
+}PVRSRV_BRIDGE_IN_SGXGETMISCINFO;
+
+typedef struct PVRSRV_BRIDGE_IN_SGXINFO_FOR_SRVINIT_TAG
+{
+        IMG_UINT32              ui32BridgeFlags; 
+        IMG_HANDLE              hDevCookie;
+}PVRSRV_BRIDGE_IN_SGXINFO_FOR_SRVINIT;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGXINFO_FOR_SRVINIT_TAG
+{
+        PVRSRV_ERROR                    eError;
+        SGX_BRIDGE_INFO_FOR_SRVINIT     sInitInfo;
+}PVRSRV_BRIDGE_OUT_SGXINFO_FOR_SRVINIT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGXDEVINITPART2_TAG
+{
+        IMG_UINT32              ui32BridgeFlags; 
+        IMG_HANDLE              hDevCookie;
+        SGX_BRIDGE_INIT_INFO    sInitInfo;
+}PVRSRV_BRIDGE_IN_SGXDEVINITPART2;
+
+ 
+typedef struct PVRSRV_BRIDGE_IN_2DQUERYBLTSCOMPLETE_TAG
+{
+        IMG_UINT32                              ui32BridgeFlags; 
+        IMG_HANDLE                              hDevCookie;
+        IMG_HANDLE                              hKernSyncInfo;
+        IMG_BOOL                                bWaitForComplete;
+}PVRSRV_BRIDGE_IN_2DQUERYBLTSCOMPLETE;
+
+
+#define PVRSRV_BRIDGE_SGX_SHAREDPBDESC_MAX_SUBMEMINFOS 10
+
+typedef struct PVRSRV_BRIDGE_IN_SGXFINDSHAREDPBDESC_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_BOOL bLockOnFailure;
+        IMG_UINT32 ui32TotalPBSize;
+}PVRSRV_BRIDGE_IN_SGXFINDSHAREDPBDESC;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGXFINDSHAREDPBDESC_TAG
+{
+        IMG_HANDLE hKernelMemInfo;
+        IMG_HANDLE hSharedPBDesc;
+        IMG_HANDLE hSharedPBDescKernelMemInfoHandle;
+        IMG_HANDLE hHWPBDescKernelMemInfoHandle;
+        IMG_HANDLE hBlockKernelMemInfoHandle;
+        IMG_HANDLE hHWBlockKernelMemInfoHandle;
+        IMG_HANDLE ahSharedPBDescSubKernelMemInfoHandles[PVRSRV_BRIDGE_SGX_SHAREDPBDESC_MAX_SUBMEMINFOS];
+        IMG_UINT32 ui32SharedPBDescSubKernelMemInfoHandlesCount;
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_SGXFINDSHAREDPBDESC;
+
+typedef struct PVRSRV_BRIDGE_IN_SGXUNREFSHAREDPBDESC_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hSharedPBDesc;
+}PVRSRV_BRIDGE_IN_SGXUNREFSHAREDPBDESC;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGXUNREFSHAREDPBDESC_TAG
+{
+        PVRSRV_ERROR eError;
+}PVRSRV_BRIDGE_OUT_SGXUNREFSHAREDPBDESC;
+
+
+typedef struct PVRSRV_BRIDGE_IN_SGXADDSHAREDPBDESC_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_HANDLE hSharedPBDescKernelMemInfo;
+        IMG_HANDLE hHWPBDescKernelMemInfo;
+        IMG_HANDLE hBlockKernelMemInfo;
+        IMG_HANDLE hHWBlockKernelMemInfo;
+        IMG_UINT32 ui32TotalPBSize;
+        IMG_HANDLE *phKernelMemInfoHandles;
+        IMG_UINT32 ui32KernelMemInfoHandlesCount;
+}PVRSRV_BRIDGE_IN_SGXADDSHAREDPBDESC;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGXADDSHAREDPBDESC_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hSharedPBDesc;
+}PVRSRV_BRIDGE_OUT_SGXADDSHAREDPBDESC;
+
+
+#ifdef  PDUMP
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_BUFFER_ARRAY_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        SGX_KICKTA_DUMP_BUFFER *psBufferArray;
+        IMG_UINT32 ui32BufferArrayLength;
+        IMG_BOOL bDumpPolls;
+} PVRSRV_BRIDGE_IN_PDUMP_BUFFER_ARRAY;
+
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_3D_SIGNATURE_REGISTERS_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_UINT32 ui32DumpFrameNum;
+        IMG_BOOL bLastFrame;
+        IMG_UINT32 *pui32Registers;
+        IMG_UINT32 ui32NumRegisters;
+}PVRSRV_BRIDGE_IN_PDUMP_3D_SIGNATURE_REGISTERS;
+
+typedef struct PVRSRV_BRIDGE_IN_PDUMPCOUNTER_REGISTERS_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_UINT32 ui32DumpFrameNum;
+        IMG_BOOL bLastFrame;
+        IMG_UINT32 *pui32Registers;
+        IMG_UINT32 ui32NumRegisters;
+}PVRSRV_BRIDGE_IN_PDUMP_COUNTER_REGISTERS;
+
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_TA_SIGNATURE_REGISTERS_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_UINT32 ui32DumpFrameNum;
+        IMG_UINT32 ui32TAKickCount;
+        IMG_BOOL bLastFrame;
+        IMG_UINT32 *pui32Registers;
+        IMG_UINT32 ui32NumRegisters;
+}PVRSRV_BRIDGE_IN_PDUMP_TA_SIGNATURE_REGISTERS;
+
+typedef struct PVRSRV_BRIDGE_IN_PDUMP_HWPERFCB_TAG
+{
+        IMG_UINT32                      ui32BridgeFlags; 
+        IMG_HANDLE                      hDevCookie;
+        IMG_CHAR                        szFileName[PVRSRV_PDUMP_MAX_FILENAME_SIZE];
+        IMG_UINT32                      ui32FileOffset;
+        IMG_UINT32                      ui32PDumpFlags;
+
+}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
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_DEV_VIRTADDR sHWRenderContextDevVAddr;
+}PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_RENDER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_RENDER_CONTEXT_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hHWRenderContext;
+}PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_RENDER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_RENDER_CONTEXT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_HANDLE hHWRenderContext;
+}PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_RENDER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_TRANSFER_CONTEXT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_DEV_VIRTADDR sHWTransferContextDevVAddr;
+}PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_TRANSFER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_TRANSFER_CONTEXT_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hHWTransferContext;
+}PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_TRANSFER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_TRANSFER_CONTEXT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_HANDLE hHWTransferContext;
+}PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_TRANSFER_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_FLUSH_HW_RENDER_TARGET_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_DEV_VIRTADDR sHWRTDataSetDevVAddr;
+}PVRSRV_BRIDGE_IN_SGX_FLUSH_HW_RENDER_TARGET;
+
+ 
+#if defined(SGX_FEATURE_2D_HARDWARE)
+typedef struct PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_2D_CONTEXT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_DEV_VIRTADDR sHW2DContextDevVAddr;
+}PVRSRV_BRIDGE_IN_SGX_REGISTER_HW_2D_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_2D_CONTEXT_TAG
+{
+        PVRSRV_ERROR eError;
+        IMG_HANDLE hHW2DContext;
+}PVRSRV_BRIDGE_OUT_SGX_REGISTER_HW_2D_CONTEXT;
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_2D_CONTEXT_TAG
+{
+        IMG_UINT32 ui32BridgeFlags; 
+        IMG_HANDLE hDevCookie;
+        IMG_HANDLE hHW2DContext;
+}PVRSRV_BRIDGE_IN_SGX_UNREGISTER_HW_2D_CONTEXT;
+
+#define SGX2D_MAX_BLT_CMD_SIZ           256     
+#endif 
+
+
+typedef struct PVRSRV_BRIDGE_IN_SGX_READ_HWPERF_CB_TAG
+{
+        IMG_UINT32                                      ui32BridgeFlags; 
+        IMG_HANDLE                                      hDevCookie;
+        IMG_UINT32                                      ui32ArraySize;
+        PVRSRV_SGX_HWPERF_CB_ENTRY      *psHWPerfCBData;
+} PVRSRV_BRIDGE_IN_SGX_READ_HWPERF_CB;
+
+typedef struct PVRSRV_BRIDGE_OUT_SGX_READ_HWPERF_CB_TAG
+{
+        PVRSRV_ERROR            eError;
+        IMG_UINT32                      ui32DataCount;
+        IMG_UINT32                      ui32ClockSpeed;
+        IMG_UINT32                      ui32HostTimeStamp;
+} PVRSRV_BRIDGE_OUT_SGX_READ_HWPERF_CB;
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx_mkif_km.h b/drivers/gpu/pvr/sgx_mkif_km.h
new file mode 100644
index 00000000000..32b3a25d93f
--- /dev/null
+++ b/drivers/gpu/pvr/sgx_mkif_km.h
@@ -0,0 +1,338 @@
+/**********************************************************************
+ *
+ * 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 (__SGX_MKIF_KM_H__)
+#define __SGX_MKIF_KM_H__
+
+#include "img_types.h"
+#include "servicesint.h"
+#include "sgxapi_km.h"
+
+
+#if defined(SGX_FEATURE_MP)
+        #define SGX_REG_BANK_SHIFT                      (12)
+        #define SGX_REG_BANK_SIZE                       (0x4000)
+        #if defined(SGX541)
+                #define SGX_REG_BANK_BASE_INDEX         (1)
+                #define SGX_REG_BANK_MASTER_INDEX       (SGX_REG_BANK_BASE_INDEX + SGX_FEATURE_MP_CORE_COUNT)
+        #else
+                #define SGX_REG_BANK_BASE_INDEX         (2)
+                #define SGX_REG_BANK_MASTER_INDEX       (1)
+        #endif 
+        #define SGX_MP_CORE_SELECT(x,i)         (x + ((i + SGX_REG_BANK_BASE_INDEX) * SGX_REG_BANK_SIZE))
+        #define SGX_MP_MASTER_SELECT(x)         (x + (SGX_REG_BANK_MASTER_INDEX * SGX_REG_BANK_SIZE))
+#else
+        #define SGX_MP_CORE_SELECT(x,i)         (x)
+#endif 
+
+
+typedef struct _SGXMKIF_COMMAND_
+{
+        IMG_UINT32                              ui32ServiceAddress;             
+        IMG_UINT32                              ui32CacheControl;               
+        IMG_UINT32                              ui32Data[4];                    
+        IMG_UINT32                              ui32Padding[2];                 
+} SGXMKIF_COMMAND;
+
+
+typedef struct _PVRSRV_SGX_KERNEL_CCB_
+{
+        SGXMKIF_COMMAND         asCommands[256];                
+} PVRSRV_SGX_KERNEL_CCB;
+
+
+typedef struct _PVRSRV_SGX_CCB_CTL_
+{
+        IMG_UINT32                              ui32WriteOffset;                
+        IMG_UINT32                              ui32ReadOffset;                 
+} PVRSRV_SGX_CCB_CTL;
+
+
+typedef struct _SGXMKIF_HOST_CTL_
+{
+#if defined(PVRSRV_USSE_EDM_BREAKPOINTS)
+        IMG_UINT32                              ui32BreakpointDisable;
+        IMG_UINT32                              ui32Continue;
+#endif
+
+        volatile IMG_UINT32             ui32InitStatus;                         
+        volatile IMG_UINT32             ui32PowerStatus;                        
+        volatile IMG_UINT32             ui32CleanupStatus;                      
+#if defined(SUPPORT_HW_RECOVERY)
+        IMG_UINT32                              ui32uKernelDetectedLockups;     
+        IMG_UINT32                              ui32HostDetectedLockups;        
+        IMG_UINT32                              ui32HWRecoverySampleRate;       
+#endif 
+        IMG_UINT32                              ui32uKernelTimerClock;          
+        IMG_UINT32                              ui32ActivePowManSampleRate;     
+        IMG_UINT32                              ui32InterruptFlags;             
+        IMG_UINT32                              ui32InterruptClearFlags;        
+        IMG_UINT32                              ui32BPSetClearSignal;           
+
+        IMG_UINT32                              ui32NumActivePowerEvents;       
+
+        IMG_UINT32                              ui32TimeWraps;                          
+        IMG_UINT32                              ui32HostClock;                          
+
+#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_CMDTA_SHARED_
+{
+        IMG_UINT32                      ui32CtrlFlags;
+        
+        IMG_UINT32                      ui32NumTAStatusVals;
+        IMG_UINT32                      ui32Num3DStatusVals;
+
+        
+        IMG_UINT32                      ui32TATQSyncWriteOpsPendingVal;
+        IMG_DEV_VIRTADDR        sTATQSyncWriteOpsCompleteDevVAddr;
+        IMG_UINT32                      ui32TATQSyncReadOpsPendingVal;
+        IMG_DEV_VIRTADDR        sTATQSyncReadOpsCompleteDevVAddr;
+
+        
+        IMG_UINT32                      ui323DTQSyncWriteOpsPendingVal;
+        IMG_DEV_VIRTADDR        s3DTQSyncWriteOpsCompleteDevVAddr;
+        IMG_UINT32                      ui323DTQSyncReadOpsPendingVal;
+        IMG_DEV_VIRTADDR        s3DTQSyncReadOpsCompleteDevVAddr;
+
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+        
+        IMG_UINT32                                      ui32NumTASrcSyncs;
+        PVRSRV_DEVICE_SYNC_OBJECT       asTASrcSyncs[SGX_MAX_TA_SRC_SYNCS];
+        IMG_UINT32                                      ui32NumTADstSyncs;
+        PVRSRV_DEVICE_SYNC_OBJECT       asTADstSyncs[SGX_MAX_TA_DST_SYNCS];
+        IMG_UINT32                                      ui32Num3DSrcSyncs;
+        PVRSRV_DEVICE_SYNC_OBJECT       as3DSrcSyncs[SGX_MAX_3D_SRC_SYNCS];
+#else
+        
+        IMG_UINT32                      ui32NumSrcSyncs;
+        PVRSRV_DEVICE_SYNC_OBJECT       asSrcSyncs[SGX_MAX_SRC_SYNCS];
+#endif
+
+        
+        PVRSRV_DEVICE_SYNC_OBJECT       sTA3DDependency;
+
+        CTL_STATUS                      sCtlTAStatusInfo[SGX_MAX_TA_STATUS_VALS];
+        CTL_STATUS                      sCtl3DStatusInfo[SGX_MAX_3D_STATUS_VALS];
+
+} SGXMKIF_CMDTA_SHARED;
+
+#define SGXTQ_MAX_STATUS                                                SGX_MAX_TRANSFER_STATUS_VALS + 2
+
+#define SGXMKIF_TQFLAGS_NOSYNCUPDATE                    0x00000001
+#define SGXMKIF_TQFLAGS_KEEPPENDING                             0x00000002
+#define SGXMKIF_TQFLAGS_TATQ_SYNC                               0x00000004
+#define SGXMKIF_TQFLAGS_3DTQ_SYNC                               0x00000008
+#if defined(SGX_FEATURE_FAST_RENDER_CONTEXT_SWITCH)
+#define SGXMKIF_TQFLAGS_CTXSWITCH                               0x00000010
+#endif
+#define SGXMKIF_TQFLAGS_DUMMYTRANSFER                   0x00000020
+
+typedef struct _SGXMKIF_TRANSFERCMD_SHARED_
+{
+        
+        
+        IMG_UINT32              ui32SrcReadOpPendingVal;
+        IMG_DEV_VIRTADDR        sSrcReadOpsCompleteDevAddr;
+        
+        IMG_UINT32              ui32SrcWriteOpPendingVal;
+        IMG_DEV_VIRTADDR        sSrcWriteOpsCompleteDevAddr;
+
+        
+        
+        IMG_UINT32              ui32DstReadOpPendingVal;
+        IMG_DEV_VIRTADDR        sDstReadOpsCompleteDevAddr;
+        
+        IMG_UINT32              ui32DstWriteOpPendingVal;
+        IMG_DEV_VIRTADDR        sDstWriteOpsCompleteDevAddr;
+
+        
+        IMG_UINT32              ui32TASyncWriteOpsPendingVal;
+        IMG_DEV_VIRTADDR        sTASyncWriteOpsCompleteDevVAddr;
+        IMG_UINT32              ui32TASyncReadOpsPendingVal;
+        IMG_DEV_VIRTADDR        sTASyncReadOpsCompleteDevVAddr;
+
+        
+        IMG_UINT32              ui323DSyncWriteOpsPendingVal;
+        IMG_DEV_VIRTADDR        s3DSyncWriteOpsCompleteDevVAddr;
+        IMG_UINT32              ui323DSyncReadOpsPendingVal;
+        IMG_DEV_VIRTADDR        s3DSyncReadOpsCompleteDevVAddr;
+
+        IMG_UINT32              ui32NumStatusVals;
+        CTL_STATUS      sCtlStatusInfo[SGXTQ_MAX_STATUS];
+} SGXMKIF_TRANSFERCMD_SHARED, *PSGXMKIF_TRANSFERCMD_SHARED;
+
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+typedef struct _SGXMKIF_2DCMD_SHARED_ {
+        
+        IMG_UINT32                      ui32NumSrcSync;
+        PVRSRV_DEVICE_SYNC_OBJECT       sSrcSyncData[SGX_MAX_2D_SRC_SYNC_OPS];
+
+        
+        PVRSRV_DEVICE_SYNC_OBJECT       sDstSyncData;
+
+        
+        PVRSRV_DEVICE_SYNC_OBJECT       sTASyncData;
+
+        
+        PVRSRV_DEVICE_SYNC_OBJECT       s3DSyncData;
+} SGXMKIF_2DCMD_SHARED, *PSGXMKIF_2DCMD_SHARED;
+#endif 
+
+
+typedef struct _SGXMKIF_HWDEVICE_SYNC_LIST_
+{
+        IMG_DEV_VIRTADDR        sAccessDevAddr;
+        IMG_UINT32                      ui32NumSyncObjects;
+        
+        PVRSRV_DEVICE_SYNC_OBJECT       asSyncData[1];
+} SGXMKIF_HWDEVICE_SYNC_LIST, *PSGXMKIF_HWDEVICE_SYNC_LIST;
+
+
+#define PVRSRV_USSE_EDM_INIT_COMPLETE                   (1UL << 0)      
+
+#define PVRSRV_USSE_EDM_POWMAN_IDLE_COMPLETE                            (1UL << 2)      
+#define PVRSRV_USSE_EDM_POWMAN_POWEROFF_COMPLETE                        (1UL << 3)      
+#define PVRSRV_USSE_EDM_POWMAN_POWEROFF_RESTART_IMMEDIATE       (1UL << 4)      
+#define PVRSRV_USSE_EDM_POWMAN_NO_WORK                                          (1UL << 5)      
+
+#define PVRSRV_USSE_EDM_INTERRUPT_HWR                   (1UL << 0)      
+#define PVRSRV_USSE_EDM_INTERRUPT_ACTIVE_POWER  (1UL << 1)      
+
+#define PVRSRV_USSE_EDM_CLEANUPCMD_COMPLETE     (1UL << 0)      
+
+#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     
+#endif
+#endif
+
+
+#define PVRSRV_CLEANUPCMD_RT            0x1
+#define PVRSRV_CLEANUPCMD_RC            0x2
+#define PVRSRV_CLEANUPCMD_TC            0x3
+#define PVRSRV_CLEANUPCMD_2DC           0x4
+#define PVRSRV_CLEANUPCMD_PB            0x5
+
+#define PVRSRV_POWERCMD_POWEROFF        0x1
+#define PVRSRV_POWERCMD_IDLE            0x2
+#define PVRSRV_POWERCMD_RESUME          0x3
+
+
+#if defined(SGX_FEATURE_BIF_NUM_DIRLISTS)
+#define SGX_BIF_DIR_LIST_INDEX_EDM      (SGX_FEATURE_BIF_NUM_DIRLISTS - 1)
+#else
+#define SGX_BIF_DIR_LIST_INDEX_EDM      (0)
+#endif
+
+#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 (SGX_FEATURE_2D_HARDWARE)
+        IMG_UINT32      ui32Sizeof_2DCMD;
+        IMG_UINT32      ui32Sizeof_2DCMD_SHARED;
+#endif
+        IMG_UINT32      ui32Sizeof_CMDTA;
+        IMG_UINT32      ui32Sizeof_CMDTA_SHARED;
+        IMG_UINT32      ui32Sizeof_TRANSFERCMD;
+        IMG_UINT32      ui32Sizeof_TRANSFERCMD_SHARED;
+        IMG_UINT32      ui32Sizeof_3DREGISTERS;
+        IMG_UINT32      ui32Sizeof_HWPBDESC;
+        IMG_UINT32      ui32Sizeof_HWRENDERCONTEXT;
+        IMG_UINT32      ui32Sizeof_HWRENDERDETAILS;
+        IMG_UINT32      ui32Sizeof_HWRTDATA;
+        IMG_UINT32      ui32Sizeof_HWRTDATASET;
+        IMG_UINT32      ui32Sizeof_HWTRANSFERCONTEXT;
+        IMG_UINT32      ui32Sizeof_HOST_CTL;
+        IMG_UINT32      ui32Sizeof_COMMAND;
+} SGX_MISCINFO_STRUCT_SIZES;
+
+
+#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
+typedef struct _PVRSRV_SGX_MISCINFO_MEMACCESS
+{
+        IMG_DEV_VIRTADDR        sDevVAddr;              
+        IMG_DEV_PHYADDR         sPDDevPAddr;    
+} PVRSRV_SGX_MISCINFO_MEMACCESS;
+#endif
+
+typedef struct _PVRSRV_SGX_MISCINFO_INFO
+{
+        IMG_UINT32                                              ui32MiscInfoFlags;
+        PVRSRV_SGX_MISCINFO_FEATURES    sSGXFeatures;           
+        SGX_MISCINFO_STRUCT_SIZES               sSGXStructSizes;        
+#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
+        PVRSRV_SGX_MISCINFO_MEMACCESS   sSGXMemAccessSrc;       
+        PVRSRV_SGX_MISCINFO_MEMACCESS   sSGXMemAccessDest;      
+#endif
+} PVRSRV_SGX_MISCINFO_INFO;
+
+#ifdef PVRSRV_USSE_EDM_STATUS_DEBUG
+#define SGXMK_TRACE_BUFFER_SIZE 512
+#endif 
+
+#define SGXMKIF_HWPERF_CB_SIZE                                  0x100   
+
+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[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                              ui32Ordinal;
+        SGXMKIF_HWPERF_CB_ENTRY psHWPerfCBData[SGXMKIF_HWPERF_CB_SIZE];
+} SGXMKIF_HWPERF_CB;
+
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgx_options.h b/drivers/gpu/pvr/sgx_options.h
new file mode 100644
index 00000000000..319db1c5854
--- /dev/null
+++ b/drivers/gpu/pvr/sgx_options.h
@@ -0,0 +1,224 @@
+/**********************************************************************
+ *
+ * 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(DEBUG) || defined (INTERNAL_TEST)
+#define DEBUG_SET_OFFSET        OPTIONS_BIT0
+#define OPTIONS_BIT0            0x1
+#else
+#define OPTIONS_BIT0            0x0
+#endif 
+
+#if defined(PDUMP) || defined (INTERNAL_TEST)
+#define PDUMP_SET_OFFSET        OPTIONS_BIT1
+#define OPTIONS_BIT1            (0x1 << 1)
+#else
+#define OPTIONS_BIT1            0x0
+#endif 
+
+#if defined(PVRSRV_USSE_EDM_STATUS_DEBUG) || defined (INTERNAL_TEST)
+#define PVRSRV_USSE_EDM_STATUS_DEBUG_SET_OFFSET         OPTIONS_BIT2
+#define OPTIONS_BIT2            (0x1 << 2)
+#else
+#define OPTIONS_BIT2            0x0
+#endif 
+
+#if defined(SUPPORT_HW_RECOVERY) || defined (INTERNAL_TEST)
+#define SUPPORT_HW_RECOVERY_SET_OFFSET  OPTIONS_BIT3
+#define OPTIONS_BIT3            (0x1 << 3)
+#else
+#define OPTIONS_BIT3            0x0
+#endif 
+
+
+
+#if defined(PVR_SECURE_HANDLES) || defined (INTERNAL_TEST)
+#define PVR_SECURE_HANDLES_SET_OFFSET   OPTIONS_BIT4
+#define OPTIONS_BIT4            (0x1 << 4)
+#else
+#define OPTIONS_BIT4            0x0
+#endif 
+
+#if defined(SGX_BYPASS_SYSTEM_CACHE) || defined (INTERNAL_TEST)
+#define SGX_BYPASS_SYSTEM_CACHE_SET_OFFSET      OPTIONS_BIT5
+#define OPTIONS_BIT5            (0x1 << 5)
+#else
+#define OPTIONS_BIT5            0x0
+#endif 
+
+#if defined(SGX_DMS_AGE_ENABLE) || defined (INTERNAL_TEST)
+#define SGX_DMS_AGE_ENABLE_SET_OFFSET   OPTIONS_BIT6
+#define OPTIONS_BIT6            (0x1 << 6)
+#else
+#define OPTIONS_BIT6            0x0
+#endif 
+
+#if defined(SGX_FAST_DPM_INIT) || defined (INTERNAL_TEST)
+#define SGX_FAST_DPM_INIT_SET_OFFSET    OPTIONS_BIT8
+#define OPTIONS_BIT8            (0x1 << 8)
+#else
+#define OPTIONS_BIT8            0x0
+#endif 
+
+#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_BIT9            0x0
+#endif 
+
+#if defined(SGX_FEATURE_MP) || defined (INTERNAL_TEST)
+#define SGX_FEATURE_MP_SET_OFFSET       OPTIONS_BIT10
+#define OPTIONS_BIT10           (0x1 << 10)
+#else
+#define OPTIONS_BIT10           0x0
+#endif 
+
+#if defined(SGX_FEATURE_MULTITHREADED_UKERNEL) || defined (INTERNAL_TEST)
+#define SGX_FEATURE_MULTITHREADED_UKERNEL_SET_OFFSET    OPTIONS_BIT11
+#define OPTIONS_BIT11           (0x1 << 11)
+#else
+#define OPTIONS_BIT11           0x0
+#endif 
+
+
+
+#if defined(SGX_FEATURE_OVERLAPPED_SPM) || defined (INTERNAL_TEST)
+#define SGX_FEATURE_OVERLAPPED_SPM_SET_OFFSET   OPTIONS_BIT12
+#define OPTIONS_BIT12           (0x1 << 12)
+#else
+#define OPTIONS_BIT12           0x0
+#endif 
+
+
+#if defined(SGX_FEATURE_SYSTEM_CACHE) || defined (INTERNAL_TEST)
+#define SGX_FEATURE_SYSTEM_CACHE_SET_OFFSET     OPTIONS_BIT13
+#define OPTIONS_BIT13           (0x1 << 13)
+#else
+#define OPTIONS_BIT13           0x0
+#endif 
+
+#if defined(SGX_SUPPORT_HWPROFILING) || defined (INTERNAL_TEST)
+#define SGX_SUPPORT_HWPROFILING_SET_OFFSET      OPTIONS_BIT14
+#define OPTIONS_BIT14           (0x1 << 14)
+#else
+#define OPTIONS_BIT14           0x0
+#endif 
+
+
+
+#if defined(SUPPORT_ACTIVE_POWER_MANAGEMENT) || defined (INTERNAL_TEST)
+#define SUPPORT_ACTIVE_POWER_MANAGEMENT_SET_OFFSET      OPTIONS_BIT15
+#define OPTIONS_BIT15           (0x1 << 15)
+#else
+#define OPTIONS_BIT15           0x0
+#endif 
+
+#if defined(SUPPORT_DISPLAYCONTROLLER_TILING) || defined (INTERNAL_TEST)
+#define SUPPORT_DISPLAYCONTROLLER_TILING_SET_OFFSET     OPTIONS_BIT16
+#define OPTIONS_BIT16           (0x1 << 16)
+#else
+#define OPTIONS_BIT16           0x0
+#endif 
+
+#if defined(SUPPORT_PERCONTEXT_PB) || defined (INTERNAL_TEST)
+#define SUPPORT_PERCONTEXT_PB_SET_OFFSET        OPTIONS_BIT17
+#define OPTIONS_BIT17           (0x1 << 17)
+#else
+#define OPTIONS_BIT17           0x0
+#endif 
+
+#if defined(SUPPORT_SGX_HWPERF) || defined (INTERNAL_TEST)
+#define SUPPORT_SGX_HWPERF_SET_OFFSET   OPTIONS_BIT18
+#define OPTIONS_BIT18           (0x1 << 18)
+#else
+#define OPTIONS_BIT18           0x0
+#endif 
+
+
+
+#if defined(SUPPORT_SGX_MMU_DUMMY_PAGE) || defined (INTERNAL_TEST)
+#define SUPPORT_SGX_MMU_DUMMY_PAGE_SET_OFFSET   OPTIONS_BIT19
+#define OPTIONS_BIT19           (0x1 << 19)
+#else
+#define OPTIONS_BIT19           0x0
+#endif 
+
+#if defined(SUPPORT_SGX_PRIORITY_SCHEDULING) || defined (INTERNAL_TEST)
+#define SUPPORT_SGX_PRIORITY_SCHEDULING_SET_OFFSET      OPTIONS_BIT20
+#define OPTIONS_BIT20           (0x1 << 20)
+#else
+#define OPTIONS_BIT20           0x0
+#endif 
+
+#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
+#define OPTIONS_BIT21           0x0
+#endif 
+
+#if defined(USE_SUPPORT_NO_TA3D_OVERLAP) || defined (INTERNAL_TEST)
+#define USE_SUPPORT_NO_TA3D_OVERLAP_SET_OFFSET  OPTIONS_BIT22
+#define OPTIONS_BIT22           (0x1 << 22)
+#else
+#define OPTIONS_BIT22           0x0
+#endif 
+
+
+#if defined(SGX_FEATURE_MP) || defined (INTERNAL_TEST)
+#define OPTIONS_HIGHBYTE ((SGX_FEATURE_MP_CORE_COUNT-1) << SGX_FEATURE_MP_CORE_COUNT_SET_OFFSET)
+#define SGX_FEATURE_MP_CORE_COUNT_SET_OFFSET    28UL
+#define SGX_FEATURE_MP_CORE_COUNT_SET_MASK              0xFF
+#else
+#define OPTIONS_HIGHBYTE        0x0
+#endif 
+
+
+
+#define SGX_BUILD_OPTIONS       \
+        OPTIONS_BIT0 |\
+        OPTIONS_BIT1 |\
+        OPTIONS_BIT2 |\
+        OPTIONS_BIT3 |\
+        OPTIONS_BIT4 |\
+        OPTIONS_BIT5 |\
+        OPTIONS_BIT6 |\
+        OPTIONS_BIT8 |\
+        OPTIONS_BIT9 |\
+        OPTIONS_BIT10 |\
+        OPTIONS_BIT11 |\
+        OPTIONS_BIT12 |\
+        OPTIONS_BIT13 |\
+        OPTIONS_BIT14 |\
+        OPTIONS_BIT15 |\
+        OPTIONS_BIT16 |\
+        OPTIONS_BIT17 |\
+        OPTIONS_BIT18 |\
+        OPTIONS_BIT19 |\
+        OPTIONS_BIT20 |\
+        OPTIONS_BIT21 |\
+        OPTIONS_HIGHBYTE
+
diff --git a/drivers/gpu/pvr/sgxapi_km.h b/drivers/gpu/pvr/sgxapi_km.h
new file mode 100644
index 00000000000..d9bad0346a5
--- /dev/null
+++ b/drivers/gpu/pvr/sgxapi_km.h
@@ -0,0 +1,381 @@
+/**********************************************************************
+ *
+ * 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 __SGXAPI_KM_H__
+#define __SGXAPI_KM_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "sgxdefs.h"
+
+#if defined(__linux__) && !defined(USE_CODE)
+        #if defined(__KERNEL__)
+                #include <asm/unistd.h>
+        #else
+                #include <unistd.h>
+        #endif
+#endif
+
+#define SGX_UNDEFINED_HEAP_ID                                   (~0LU)
+#define SGX_GENERAL_HEAP_ID                                             0
+#define SGX_TADATA_HEAP_ID                                              1
+#define SGX_KERNEL_CODE_HEAP_ID                                 2
+#define SGX_KERNEL_DATA_HEAP_ID                                 3
+#define SGX_PIXELSHADER_HEAP_ID                                 4
+#define SGX_VERTEXSHADER_HEAP_ID                                5
+#define SGX_PDSPIXEL_CODEDATA_HEAP_ID                   6
+#define SGX_PDSVERTEX_CODEDATA_HEAP_ID                  7
+#define SGX_SYNCINFO_HEAP_ID                                    8
+#define SGX_3DPARAMETERS_HEAP_ID                                9
+#if defined(SUPPORT_SGX_GENERAL_MAPPING_HEAP)
+#define SGX_GENERAL_MAPPING_HEAP_ID                             10
+#endif
+#if defined(SGX_FEATURE_2D_HARDWARE)
+#define SGX_2D_HEAP_ID                                                  11
+#else
+#if defined(FIX_HW_BRN_26915)
+#define SGX_CGBUFFER_HEAP_ID                                    12
+#endif
+#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  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
+#endif
+
+
+#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_TRANSFER                                      0x2
+#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_MK_3D                                         0x103
+#define PVRSRV_SGX_HWPERF_MK_2D                                         0x104
+
+#define PVRSRV_SGX_HWPERF_TYPE_STARTEND_BIT                     28
+#define PVRSRV_SGX_HWPERF_TYPE_OP_MASK                          ((1UL << PVRSRV_SGX_HWPERF_TYPE_STARTEND_BIT) - 1)
+#define PVRSRV_SGX_HWPERF_TYPE_OP_START                         (0UL << PVRSRV_SGX_HWPERF_TYPE_STARTEND_BIT)
+#define PVRSRV_SGX_HWPERF_TYPE_OP_END                           (1Ul << PVRSRV_SGX_HWPERF_TYPE_STARTEND_BIT)
+
+#define PVRSRV_SGX_HWPERF_TYPE_TRANSFER_START           (PVRSRV_SGX_HWPERF_TRANSFER | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#define PVRSRV_SGX_HWPERF_TYPE_TRANSFER_END                     (PVRSRV_SGX_HWPERF_TRANSFER | PVRSRV_SGX_HWPERF_TYPE_OP_END)
+#define PVRSRV_SGX_HWPERF_TYPE_TA_START                         (PVRSRV_SGX_HWPERF_TA | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#define PVRSRV_SGX_HWPERF_TYPE_TA_END                           (PVRSRV_SGX_HWPERF_TA | PVRSRV_SGX_HWPERF_TYPE_OP_END)
+#define PVRSRV_SGX_HWPERF_TYPE_3D_START                         (PVRSRV_SGX_HWPERF_3D | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#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_TA_START                      (PVRSRV_SGX_HWPERF_MK_TA | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#define PVRSRV_SGX_HWPERF_TYPE_MK_TA_END                        (PVRSRV_SGX_HWPERF_MK_TA | PVRSRV_SGX_HWPERF_TYPE_OP_END)
+#define PVRSRV_SGX_HWPERF_TYPE_MK_3D_START                      (PVRSRV_SGX_HWPERF_MK_3D | PVRSRV_SGX_HWPERF_TYPE_OP_START)
+#define PVRSRV_SGX_HWPERF_TYPE_MK_3D_END                        (PVRSRV_SGX_HWPERF_MK_3D | 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_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[SGX_FEATURE_MP_CORE_COUNT][PVRSRV_SGX_HWPERF_NUM_COUNTERS];
+} PVRSRV_SGX_HWPERF_CB_ENTRY;
+
+
+typedef struct _CTL_STATUS_
+{
+        IMG_DEV_VIRTADDR        sStatusDevAddr;
+        IMG_UINT32                      ui32StatusValue;
+} CTL_STATUS;
+
+
+typedef enum _SGX_MISC_INFO_REQUEST_
+{
+        SGX_MISC_INFO_REQUEST_CLOCKSPEED = 0,
+        SGX_MISC_INFO_REQUEST_SGXREV,
+        SGX_MISC_INFO_REQUEST_DRIVER_SGXREV,
+#if defined(SUPPORT_SGX_EDM_MEMORY_DEBUG)
+        SGX_MISC_INFO_REQUEST_MEMREAD,
+        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;
+
+
+typedef struct _PVRSRV_SGX_MISCINFO_FEATURES
+{
+        IMG_UINT32                      ui32CoreRev;    
+        IMG_UINT32                      ui32CoreID;             
+        IMG_UINT32                      ui32DDKVersion; 
+        IMG_UINT32                      ui32DDKBuild;   
+        IMG_UINT32                      ui32CoreIdSW;   
+        IMG_UINT32                      ui32CoreRevSW;  
+        IMG_UINT32                      ui32BuildOptions;       
+#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_DEV_VIRTADDR                        sBPDevVAddr, sBPDevVAddrEnd;
+        
+        IMG_BOOL                    bTrapped;
+        
+        IMG_BOOL                    bRead;
+        
+        IMG_BOOL                    bWrite;
+        
+        IMG_BOOL                    bTrappedBP;
+        
+        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                        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
+                PVRSRV_SGX_MISCINFO_SET_HWPERF_STATUS                           sSetHWPerfStatus;
+        } uData;
+} SGX_MISC_INFO;
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+#define PVRSRV_MAX_BLT_SRC_SYNCS                3
+#endif
+
+
+#define SGX_KICKTA_DUMPBITMAP_MAX_NAME_LENGTH           256
+
+typedef struct _SGX_KICKTA_DUMPBITMAP_
+{
+        IMG_DEV_VIRTADDR        sDevBaseAddr;
+        IMG_UINT32                      ui32Flags;
+        IMG_UINT32                      ui32Width;
+        IMG_UINT32                      ui32Height;
+        IMG_UINT32                      ui32Stride;
+        IMG_UINT32                      ui32PDUMPFormat;
+        IMG_UINT32                      ui32BytesPP;
+        IMG_CHAR                        pszName[SGX_KICKTA_DUMPBITMAP_MAX_NAME_LENGTH];
+} SGX_KICKTA_DUMPBITMAP, *PSGX_KICKTA_DUMPBITMAP;
+
+#define PVRSRV_SGX_PDUMP_CONTEXT_MAX_BITMAP_ARRAY_SIZE  (16)
+
+typedef struct _PVRSRV_SGX_PDUMP_CONTEXT_
+{
+        
+        IMG_UINT32                                              ui32CacheControl;
+
+} PVRSRV_SGX_PDUMP_CONTEXT;
+
+
+typedef struct _SGX_KICKTA_DUMP_ROFF_
+{
+        IMG_HANDLE                      hKernelMemInfo;                                         
+        IMG_UINT32                      uiAllocIndex;                                           
+        IMG_UINT32                      ui32Offset;                                                     
+        IMG_UINT32                      ui32Value;                                                      
+        IMG_PCHAR                       pszName;                                                        
+} SGX_KICKTA_DUMP_ROFF, *PSGX_KICKTA_DUMP_ROFF;
+
+typedef struct _SGX_KICKTA_DUMP_BUFFER_
+{
+        IMG_UINT32                      ui32SpaceUsed;
+        IMG_UINT32                      ui32Start;                                                      
+        IMG_UINT32                      ui32End;                                                        
+        IMG_UINT32                      ui32BufferSize;                                         
+        IMG_UINT32                      ui32BackEndLength;                                      
+        IMG_UINT32                      uiAllocIndex;
+        IMG_HANDLE                      hKernelMemInfo;                                         
+        IMG_PVOID                       pvLinAddr;
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+        IMG_HANDLE                      hCtrlKernelMemInfo;                                     
+        IMG_DEV_VIRTADDR        sCtrlDevVAddr;                                          
+#endif
+        IMG_PCHAR                       pszName;                                                        
+} SGX_KICKTA_DUMP_BUFFER, *PSGX_KICKTA_DUMP_BUFFER;
+
+#ifdef PDUMP
+typedef struct _SGX_KICKTA_PDUMP_
+{
+        
+        PSGX_KICKTA_DUMPBITMAP          psPDumpBitmapArray;
+        IMG_UINT32                                              ui32PDumpBitmapSize;
+
+        
+        PSGX_KICKTA_DUMP_BUFFER psBufferArray;
+        IMG_UINT32                                              ui32BufferArraySize;
+
+        
+        PSGX_KICKTA_DUMP_ROFF           psROffArray;
+        IMG_UINT32                                              ui32ROffArraySize;
+} SGX_KICKTA_PDUMP, *PSGX_KICKTA_PDUMP;
+#endif  
+
+#if defined(TRANSFER_QUEUE)
+#if defined(SGX_FEATURE_2D_HARDWARE)
+#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_SYNC_OPS       5
+#endif
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgxdefs.h b/drivers/gpu/pvr/sgxdefs.h
new file mode 100644
index 00000000000..9e5effbc853
--- /dev/null
+++ b/drivers/gpu/pvr/sgxdefs.h
@@ -0,0 +1,94 @@
+/**********************************************************************
+ *
+ * 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 _SGXDEFS_H_
+#define _SGXDEFS_H_
+
+#include "sgxerrata.h"
+#include "sgxfeaturedefs.h"
+
+#if defined(SGX520)
+#include "sgx520defs.h"
+#else
+#if defined(SGX530)
+#include "sgx530defs.h"
+#else
+#if defined(SGX535)
+#include "sgx535defs.h"
+#else
+#if defined(SGX535_V1_1)
+#include "sgx535defs.h"
+#else
+#if defined(SGX540)
+#include "sgx540defs.h"
+#else
+#if defined(SGX541)
+#include "sgx541defs.h"
+#else
+#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
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#if defined(SGX_FEATURE_MP)
+#if defined(SGX541)
+#if SGX_CORE_REV == 100
+#include "sgx541_100mpdefs.h"
+#else
+#include "sgx541mpdefs.h"
+#endif 
+#else
+#include "sgxmpdefs.h"
+#endif 
+#else 
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+#include "mnemedefs.h"
+#endif
+#endif 
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgxerrata.h b/drivers/gpu/pvr/sgxerrata.h
new file mode 100644
index 00000000000..552cb2c3523
--- /dev/null
+++ b/drivers/gpu/pvr/sgxerrata.h
@@ -0,0 +1,330 @@
+/**********************************************************************
+ *
+ * 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 _SGXERRATA_KM_H_
+#define _SGXERRATA_KM_H_
+
+#if defined(SGX520) && !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: SGX520 Core Revision unspecified"
+        #endif
+        #endif
+        
+        #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX530) && !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 == 110
+                #define FIX_HW_BRN_22934        
+        #else
+        #if SGX_CORE_REV == 111
+                #define FIX_HW_BRN_22934        
+        #else
+        #if SGX_CORE_REV == 120
+                #define FIX_HW_BRN_22934        
+        #else
+        #if SGX_CORE_REV == 121
+                #define FIX_HW_BRN_22934        
+        #else
+        #if SGX_CORE_REV == 125
+                #define FIX_HW_BRN_22934        
+        #else
+        #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+                
+        #else
+                #error "sgxerrata.h: SGX530 Core Revision unspecified"
+        #endif
+        #endif
+        #endif
+        #endif
+#endif
+        #endif
+        
+        #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX531) && !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 == 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
+                
+        #else
+                #error "sgxerrata.h: SGX531 Core Revision unspecified"
+        #endif
+        #endif
+        #endif
+        
+        #define SGX_CORE_DEFINED
+#endif
+
+#if (defined(SGX535) || defined(SGX535_V1_1)) && !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 == 112
+                #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 == 113
+                #define FIX_HW_BRN_22934        
+                #define FIX_HW_BRN_23281
+                #define FIX_HW_BRN_23944
+                #define FIX_HW_BRN_23410
+        #else
+        #if SGX_CORE_REV == 121
+                #define FIX_HW_BRN_22934        
+                #define FIX_HW_BRN_23944
+                #define FIX_HW_BRN_23410
+        #else
+        #if SGX_CORE_REV == 126
+                #define FIX_HW_BRN_22934        
+        #else   
+        #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+                
+        #else
+                #error "sgxerrata.h: SGX535 Core Revision unspecified"
+
+        #endif
+        #endif
+        #endif
+        #endif
+        #endif
+        
+        #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX540) && !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 == 101
+                #define FIX_HW_BRN_25499
+                #define FIX_HW_BRN_25503
+                #define FIX_HW_BRN_26620
+                #define FIX_HW_BRN_28011
+        #else
+        #if SGX_CORE_REV == 110
+                #define FIX_HW_BRN_25503
+                #define FIX_HW_BRN_26620
+                #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
+        #else
+        #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+                
+        #else
+                #error "sgxerrata.h: SGX540 Core Revision unspecified"
+        #endif
+        #endif
+        #endif
+        #endif
+        #endif
+        
+        #define SGX_CORE_DEFINED
+#endif
+
+#if defined(SGX541) && !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    SGX_CORE_REV_HEAD
+                #endif
+
+                #if SGX_CORE_REV == 100
+                        #define FIX_HW_BRN_27270
+                        #define FIX_HW_BRN_28011
+                        #define FIX_HW_BRN_27510
+                        
+                #else
+                #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+                        
+                #else
+                        #error "sgxerrata.h: SGX541 Core Revision unspecified"
+                #endif
+                #endif
+                
+                #define SGX_CORE_DEFINED
+        #else 
+                #error "sgxerrata.h: SGX541 only supports MP configs (SGX_FEATURE_MP)"
+        #endif 
+#endif
+
+#if defined(SGX543) && !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 == 113
+                        
+        #else
+        #if SGX_CORE_REV == 122
+                        
+        #else
+        #if SGX_CORE_REV == SGX_CORE_REV_HEAD
+                
+        #else
+                #error "sgxerrata.h: SGX543 Core Revision unspecified"
+        #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 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
+                #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 == SGX_CORE_REV_HEAD
+                
+        #else
+                #error "sgxerrata.h: SGX545 Core Revision unspecified"
+        #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
+
+#if !defined(SGX_CORE_DEFINED)
+#if defined (__GNUC__)
+        #warning "sgxerrata.h: SGX Core Version unspecified"
+#else
+        #pragma message("sgxerrata.h: SGX Core Version unspecified")
+#endif
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/sgxfeaturedefs.h b/drivers/gpu/pvr/sgxfeaturedefs.h
new file mode 100644
index 00000000000..d815395523a
--- /dev/null
+++ b/drivers/gpu/pvr/sgxfeaturedefs.h
@@ -0,0 +1,199 @@
+/**********************************************************************
+ *
+ * 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(SGX520)
+        #define SGX_CORE_FRIENDLY_NAME                                                  "SGX520"
+        #define SGX_CORE_ID                                                                             SGX_CORE_ID_520
+        #define SGX_FEATURE_ADDRESS_SPACE_SIZE                                  (28)
+        #define SGX_FEATURE_AUTOCLOCKGATING
+#else
+#if defined(SGX530)
+        #define SGX_CORE_FRIENDLY_NAME                                                  "SGX530"
+        #define SGX_CORE_ID                                                                             SGX_CORE_ID_530
+        #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_ADDRESS_SPACE_SIZE                                  (32)
+        #define SGX_FEATURE_MULTIPLE_MEM_CONTEXTS
+        #define SGX_FEATURE_BIF_NUM_DIRLISTS                                    (16)
+        #define SGX_FEATURE_2D_HARDWARE
+        #define SGX_FEATURE_AUTOCLOCKGATING
+        #define SUPPORT_SGX_GENERAL_MAPPING_HEAP
+#else
+#if defined(SGX540)
+        #define SGX_CORE_FRIENDLY_NAME                                                  "SGX540"
+        #define SGX_CORE_ID                                                                             SGX_CORE_ID_540
+        #define SGX_FEATURE_ADDRESS_SPACE_SIZE                                  (28)
+        #define SGX_FEATURE_AUTOCLOCKGATING
+        #define SGX_FEATURE_MULTI_EVENT_KICK
+#else
+#if defined(SGX541)
+        #define SGX_CORE_FRIENDLY_NAME                                                  "SGX541"
+        #define SGX_CORE_ID                                                                             SGX_CORE_ID_541
+        #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_SPM_MODE_0
+        #define SGX_FEATURE_MULTI_EVENT_KICK
+#else
+#if defined(SGX543)
+        #define SGX_CORE_FRIENDLY_NAME                                                  "SGX543"
+        #define SGX_CORE_ID                                                                             SGX_CORE_ID_543
+        #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_2D_HARDWARE
+        #define SGX_FEATURE_PTLA
+        #define SGX_FEATURE_EXTENDED_PERF_COUNTERS
+#else
+#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_CORE_ID                                                                             SGX_CORE_ID_545
+        #define SGX_FEATURE_ADDRESS_SPACE_SIZE                                  (32)
+        #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_BIF_NUM_DIRLISTS                            (16)
+        #define SGX_FEATURE_NUM_USE_PIPES                                       (4)
+        #define SGX_FEATURE_TEXTURESTRIDE_EXTENSION
+        #define SGX_FEATURE_PDS_DATA_INTERLEAVE_2DWORDS
+        #define SGX_FEATURE_MONOLITHIC_UKERNEL
+        #define SGX_FEATURE_ZLS_EXTERNALZ
+        #define SGX_FEATURE_VDM_CONTEXT_SWITCH_REV_2
+        #define SGX_FEATURE_ISP_CONTEXT_SWITCH_REV_2
+        #define SGX_FEATURE_NUM_PDS_PIPES                                       (2)
+        #define SGX_FEATURE_NATIVE_BACKWARD_BLIT
+        #define SGX_FEATURE_MAX_TA_RENDER_TARGETS                               (512)
+        #define SGX_FEATURE_SPM_MODE_0
+        #define SGX_FEATURE_SECONDARY_REQUIRES_USE_KICK
+        #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
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#if defined(FIX_HW_BRN_22693)
+#undef SGX_FEATURE_AUTOCLOCKGATING
+#endif
+
+#if defined(FIX_HW_BRN_27266)
+#undef SGX_FEATURE_36BIT_MMU
+#endif
+
+#if defined(FIX_HW_BRN_27456)
+#undef SGX_FEATURE_BIF_WIDE_TILING_AND_4K_ADDRESS
+#endif
+
+#if defined(FIX_HW_BRN_22934)   \
+        || defined(FIX_HW_BRN_25499)
+#undef SGX_FEATURE_MULTI_EVENT_KICK
+#endif
+
+#if defined(SGX_FEATURE_SYSTEM_CACHE)
+        #if defined(SGX_FEATURE_36BIT_MMU)
+                #error SGX_FEATURE_SYSTEM_CACHE is incompatible with SGX_FEATURE_36BIT_MMU
+        #endif
+        #if defined(FIX_HW_BRN_26620) && !defined(SGX_FEATURE_MULTI_EVENT_KICK)
+                #define SGX_BYPASS_SYSTEM_CACHE
+        #endif
+#endif
+
+#if defined(SGX_FEATURE_MP)
+#if !defined(SGX_FEATURE_MP_CORE_COUNT)
+#error SGX_FEATURE_MP_CORE_COUNT must be defined when SGX_FEATURE_MP is defined
+#endif
+#else
+#define SGX_FEATURE_MP_CORE_COUNT       (1)
+#endif
+
+#if defined(SUPPORT_SGX_LOW_LATENCY_SCHEDULING) && !defined(SUPPORT_SGX_PRIORITY_SCHEDULING)
+#define SUPPORT_SGX_PRIORITY_SCHEDULING
+#endif
+
+#include "img_types.h"
+
diff --git a/drivers/gpu/pvr/sgxinfo.h b/drivers/gpu/pvr/sgxinfo.h
new file mode 100644
index 00000000000..eaef12f4357
--- /dev/null
+++ b/drivers/gpu/pvr/sgxinfo.h
@@ -0,0 +1,286 @@
+/**********************************************************************
+ *
+ * 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 (__SGXINFO_H__)
+#define __SGXINFO_H__
+
+#include "sgxscript.h"
+#include "servicesint.h"
+#include "services.h"
+#include "sgxapi_km.h"
+#include "sgx_mkif_km.h"
+
+
+#define SGX_MAX_DEV_DATA                        24
+#define SGX_MAX_INIT_MEM_HANDLES        16
+
+
+typedef struct _SGX_BRIDGE_INFO_FOR_SRVINIT
+{
+        IMG_DEV_PHYADDR sPDDevPAddr;
+        PVRSRV_HEAP_INFO asHeapInfo[PVRSRV_MAX_CLIENT_HEAPS];
+} SGX_BRIDGE_INFO_FOR_SRVINIT;
+
+
+typedef enum _SGXMKIF_CMD_TYPE_
+{
+        SGXMKIF_CMD_TA                          = 0,
+        SGXMKIF_CMD_TRANSFER            = 1,
+        SGXMKIF_CMD_2D                          = 2,
+        SGXMKIF_CMD_POWER                       = 3,
+        SGXMKIF_CMD_CLEANUP                     = 4,
+        SGXMKIF_CMD_GETMISCINFO         = 5,
+        SGXMKIF_CMD_PROCESS_QUEUES      = 6,
+        SGXMKIF_CMD_DATABREAKPOINT      = 7,
+        SGXMKIF_CMD_SETHWPERFSTATUS     = 8,
+        SGXMKIF_CMD_MAX                         = 9,
+
+        SGXMKIF_CMD_FORCE_I32           = -1,
+
+} SGXMKIF_CMD_TYPE;
+
+
+typedef struct _SGX_BRIDGE_INIT_INFO_
+{
+        IMG_HANDLE      hKernelCCBMemInfo;
+        IMG_HANDLE      hKernelCCBCtlMemInfo;
+        IMG_HANDLE      hKernelCCBEventKickerMemInfo;
+        IMG_HANDLE      hKernelSGXHostCtlMemInfo;
+        IMG_HANDLE      hKernelSGXTA3DCtlMemInfo;
+        IMG_HANDLE      hKernelSGXMiscMemInfo;
+
+        IMG_UINT32      aui32HostKickAddr[SGXMKIF_CMD_MAX];
+
+        SGX_INIT_SCRIPTS sScripts;
+
+        IMG_UINT32      ui32ClientBuildOptions;
+        SGX_MISCINFO_STRUCT_SIZES       sSGXStructSizes;
+
+#if defined(SGX_SUPPORT_HWPROFILING)
+        IMG_HANDLE      hKernelHWProfilingMemInfo;
+#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;
+#endif
+#if defined(SGX_FEATURE_OVERLAPPED_SPM)
+        IMG_HANDLE hKernelTmpRgnHeaderMemInfo;
+#endif
+#if defined(SGX_FEATURE_SPM_MODE_0)
+        IMG_HANDLE hKernelTmpDPMStateMemInfo;
+#endif
+
+        IMG_UINT32 ui32EDMTaskReg0;
+        IMG_UINT32 ui32EDMTaskReg1;
+
+        IMG_UINT32 ui32ClkGateStatusReg;
+        IMG_UINT32 ui32ClkGateStatusMask;
+#if defined(SGX_FEATURE_MP)
+        IMG_UINT32 ui32MasterClkGateStatusReg;
+        IMG_UINT32 ui32MasterClkGateStatusMask;
+        IMG_UINT32 ui32MasterClkGateStatus2Reg;
+        IMG_UINT32 ui32MasterClkGateStatus2Mask;
+#endif 
+
+        IMG_UINT32 ui32CacheControl;
+
+        IMG_UINT32      asInitDevData[SGX_MAX_DEV_DATA];
+        IMG_HANDLE      asInitMemHandles[SGX_MAX_INIT_MEM_HANDLES];
+
+} SGX_BRIDGE_INIT_INFO;
+
+
+typedef struct _SGX_DEVICE_SYNC_LIST_
+{
+        PSGXMKIF_HWDEVICE_SYNC_LIST     psHWDeviceSyncList;
+
+        IMG_HANDLE                              hKernelHWSyncListMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  *psHWDeviceSyncListClientMemInfo;
+        PVRSRV_CLIENT_MEM_INFO  *psAccessResourceClientMemInfo;
+
+        volatile IMG_UINT32             *pui32Lock;
+
+        struct _SGX_DEVICE_SYNC_LIST_   *psNext;
+
+        
+        IMG_UINT32                      ui32NumSyncObjects;
+        IMG_HANDLE                      ahSyncHandles[1];
+} SGX_DEVICE_SYNC_LIST, *PSGX_DEVICE_SYNC_LIST;
+
+
+typedef struct _SGX_INTERNEL_STATUS_UPDATE_
+{
+        CTL_STATUS                              sCtlStatus;
+        IMG_HANDLE                              hKernelMemInfo;
+} SGX_INTERNEL_STATUS_UPDATE;
+
+
+typedef struct _SGX_CCB_KICK_
+{
+        SGXMKIF_COMMAND         sCommand;
+        IMG_HANDLE                      hCCBKernelMemInfo;
+
+        IMG_UINT32      ui32NumDstSyncObjects;
+        IMG_HANDLE      hKernelHWSyncListMemInfo;
+
+        
+        IMG_HANDLE      *pahDstSyncHandles;
+
+        IMG_UINT32      ui32NumTAStatusVals;
+        IMG_UINT32      ui32Num3DStatusVals;
+
+#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
+        SGX_INTERNEL_STATUS_UPDATE      asTAStatusUpdate[SGX_MAX_TA_STATUS_VALS];
+        SGX_INTERNEL_STATUS_UPDATE      as3DStatusUpdate[SGX_MAX_3D_STATUS_VALS];
+#else
+        IMG_HANDLE      ahTAStatusSyncInfo[SGX_MAX_TA_STATUS_VALS];
+        IMG_HANDLE      ah3DStatusSyncInfo[SGX_MAX_3D_STATUS_VALS];
+#endif
+
+        IMG_BOOL        bFirstKickOrResume;
+#if (defined(NO_HARDWARE) || defined(PDUMP))
+        IMG_BOOL        bTerminateOrAbort;
+#endif
+
+        
+        IMG_UINT32      ui32CCBOffset;
+
+#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
+        
+        IMG_UINT32      ui32NumTASrcSyncs;
+        IMG_HANDLE      ahTASrcKernelSyncInfo[SGX_MAX_TA_SRC_SYNCS];
+        IMG_UINT32      ui32NumTADstSyncs;
+        IMG_HANDLE      ahTADstKernelSyncInfo[SGX_MAX_TA_DST_SYNCS];
+        IMG_UINT32      ui32Num3DSrcSyncs;
+        IMG_HANDLE      ah3DSrcKernelSyncInfo[SGX_MAX_3D_SRC_SYNCS];
+#else
+        
+        IMG_UINT32      ui32NumSrcSyncs;
+        IMG_HANDLE      ahSrcKernelSyncInfo[SGX_MAX_SRC_SYNCS];
+#endif
+
+        
+        IMG_BOOL        bTADependency;
+        IMG_HANDLE      hTA3DSyncInfo;
+
+        IMG_HANDLE      hTASyncInfo;
+        IMG_HANDLE      h3DSyncInfo;
+#if defined(PDUMP)
+        IMG_UINT32      ui32CCBDumpWOff;
+#endif
+#if defined(NO_HARDWARE)
+        IMG_UINT32      ui32WriteOpsPendingVal;
+#endif
+} SGX_CCB_KICK;
+
+
+#define SGX_KERNEL_USE_CODE_BASE_INDEX          15
+
+
+typedef struct _SGX_CLIENT_INFO_
+{
+        IMG_UINT32                                      ui32ProcessID;                  
+        IMG_VOID                                        *pvProcess;                             
+        PVRSRV_MISC_INFO                        sMiscInfo;                              
+
+        IMG_UINT32                                      asDevData[SGX_MAX_DEV_DATA];
+
+} SGX_CLIENT_INFO;
+
+typedef struct _SGX_INTERNAL_DEVINFO_
+{
+        IMG_UINT32                      ui32Flags;
+        IMG_HANDLE                      hHostCtlKernelMemInfoHandle;
+        IMG_BOOL                        bForcePTOff;
+} SGX_INTERNAL_DEVINFO;
+
+
+#if defined(TRANSFER_QUEUE)
+typedef struct _PVRSRV_TRANSFER_SGX_KICK_
+{
+        IMG_HANDLE              hCCBMemInfo;
+        IMG_UINT32              ui32SharedCmdCCBOffset;
+
+        IMG_DEV_VIRTADDR        sHWTransferContextDevVAddr;
+
+        IMG_HANDLE              hTASyncInfo;
+        IMG_HANDLE              h3DSyncInfo;
+
+        IMG_UINT32              ui32NumSrcSync;
+        IMG_HANDLE              ahSrcSyncInfo[SGX_MAX_TRANSFER_SYNC_OPS];
+
+        IMG_UINT32              ui32NumDstSync;
+        IMG_HANDLE              ahDstSyncInfo[SGX_MAX_TRANSFER_SYNC_OPS];
+
+        IMG_UINT32              ui32Flags;
+
+        IMG_UINT32              ui32PDumpFlags;
+#if defined(PDUMP)
+        IMG_UINT32              ui32CCBDumpWOff;
+#endif
+} PVRSRV_TRANSFER_SGX_KICK, *PPVRSRV_TRANSFER_SGX_KICK;
+
+#if defined(SGX_FEATURE_2D_HARDWARE)
+typedef struct _PVRSRV_2D_SGX_KICK_
+{
+        IMG_HANDLE              hCCBMemInfo;
+        IMG_UINT32              ui32SharedCmdCCBOffset;
+
+        IMG_DEV_VIRTADDR        sHW2DContextDevVAddr;
+
+        IMG_UINT32              ui32NumSrcSync;
+        IMG_HANDLE              ahSrcSyncInfo[SGX_MAX_2D_SRC_SYNC_OPS];
+
+        
+        IMG_HANDLE              hDstSyncInfo;
+
+        
+        IMG_HANDLE              hTASyncInfo;
+
+        
+        IMG_HANDLE              h3DSyncInfo;
+
+        IMG_UINT32              ui32PDumpFlags;
+#if defined(PDUMP)
+        IMG_UINT32              ui32CCBDumpWOff;
+#endif
+} PVRSRV_2D_SGX_KICK, *PPVRSRV_2D_SGX_KICK;
+#endif  
+#endif  
+
+
+#endif 
diff --git a/drivers/gpu/pvr/sgxmmu.h b/drivers/gpu/pvr/sgxmmu.h
new file mode 100644
index 00000000000..4df8003361c
--- /dev/null
+++ b/drivers/gpu/pvr/sgxmmu.h
@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * 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(__SGXMMU_KM_H__)
+#define __SGXMMU_KM_H__
+
+#define SGX_MMU_PAGE_SHIFT                              (12)
+#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                                 (1U<<SGX_MMU_PD_SHIFT)
+#define SGX_MMU_PD_MASK                                 (0xFFC00000U)
+
+#if defined(SGX_FEATURE_36BIT_MMU)
+        #define SGX_MMU_PDE_ADDR_MASK                   (0xFFFFFF00U)
+        #define SGX_MMU_PDE_ADDR_ALIGNSHIFT             (4)
+#else
+        #define SGX_MMU_PDE_ADDR_MASK                   (0xFFFFF000U)
+        #define SGX_MMU_PDE_ADDR_ALIGNSHIFT             (0)
+#endif
+#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               (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                   (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                                 (1U<<SGX_MMU_PT_SHIFT)
+#define SGX_MMU_PT_MASK                                 (0x003FF000U)
+
+#if defined(SGX_FEATURE_36BIT_MMU)
+        #define SGX_MMU_PTE_ADDR_MASK                   (0xFFFFFF00U)
+        #define SGX_MMU_PTE_ADDR_ALIGNSHIFT             (4)
+#else
+        #define SGX_MMU_PTE_ADDR_MASK                   (0xFFFFF000U)
+        #define SGX_MMU_PTE_ADDR_ALIGNSHIFT             (0)
+#endif
+#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  
+
diff --git a/drivers/gpu/pvr/sgxscript.h b/drivers/gpu/pvr/sgxscript.h
new file mode 100644
index 00000000000..47c9e4830fd
--- /dev/null
+++ b/drivers/gpu/pvr/sgxscript.h
@@ -0,0 +1,81 @@
+/**********************************************************************
+ *
+ * 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 __SGXSCRIPT_H__
+#define __SGXSCRIPT_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define SGX_MAX_INIT_COMMANDS   64
+#define SGX_MAX_DEINIT_COMMANDS 16
+
+typedef enum _SGX_INIT_OPERATION
+{
+        SGX_INIT_OP_ILLEGAL = 0,
+        SGX_INIT_OP_WRITE_HW_REG,
+#if defined(PDUMP)
+        SGX_INIT_OP_PDUMP_HW_REG,
+#endif
+        SGX_INIT_OP_HALT
+} SGX_INIT_OPERATION;
+
+typedef union _SGX_INIT_COMMAND
+{
+        SGX_INIT_OPERATION eOp;
+        struct {
+                SGX_INIT_OPERATION eOp;
+                IMG_UINT32 ui32Offset;
+                IMG_UINT32 ui32Value;
+        } sWriteHWReg;
+#if defined(PDUMP)
+        struct {
+                SGX_INIT_OPERATION eOp;
+                IMG_UINT32 ui32Offset;
+                IMG_UINT32 ui32Value;
+        } sPDumpHWReg;
+#endif
+#if defined(FIX_HW_BRN_22997) && defined(FIX_HW_BRN_23030) && defined(SGX_FEATURE_HOST_PORT)                    
+        struct {
+                SGX_INIT_OPERATION eOp;
+        } sWorkaroundBRN22997;
+#endif  
+} SGX_INIT_COMMAND;
+
+typedef struct _SGX_INIT_SCRIPTS_
+{
+        SGX_INIT_COMMAND asInitCommandsPart1[SGX_MAX_INIT_COMMANDS];
+        SGX_INIT_COMMAND asInitCommandsPart2[SGX_MAX_INIT_COMMANDS];
+        SGX_INIT_COMMAND asDeinitCommands[SGX_MAX_DEINIT_COMMANDS];
+} SGX_INIT_SCRIPTS;
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif 
+
diff --git a/drivers/gpu/pvr/srvkm.h b/drivers/gpu/pvr/srvkm.h
new file mode 100644
index 00000000000..44a1daa9700
--- /dev/null
+++ b/drivers/gpu/pvr/srvkm.h
@@ -0,0 +1,78 @@
+/**********************************************************************
+ *
+ * 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 SRVKM_H
+#define SRVKM_H
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+        
+        #ifdef PVR_DISABLE_LOGGING
+        #define PVR_LOG(X)
+        #else
+         
+        #define PVR_LOG(X)                      PVRSRVReleasePrintf X;
+        #endif
+
+        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 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; \
+        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 
diff --git a/drivers/gpu/pvr/syscommon.h b/drivers/gpu/pvr/syscommon.h
new file mode 100644
index 00000000000..5ae080ad4b2
--- /dev/null
+++ b/drivers/gpu/pvr/syscommon.h
@@ -0,0 +1,223 @@
+/**********************************************************************
+ *
+ * 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 _SYSCOMMON_H
+#define _SYSCOMMON_H
+
+#include "sysconfig.h"      
+#include "sysinfo.h"            
+#include "servicesint.h"
+#include "queue.h"
+#include "power.h"
+#include "resman.h"
+#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
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef struct _SYS_DEVICE_ID_TAG
+{
+        IMG_UINT32      uiID;
+        IMG_BOOL        bInUse;
+
+} SYS_DEVICE_ID;
+
+
+#define SYS_MAX_LOCAL_DEVMEM_ARENAS     4
+
+typedef struct _SYS_DATA_TAG_
+{
+    IMG_UINT32                  ui32NumDevices;                 
+        SYS_DEVICE_ID                           sDeviceID[SYS_DEVICE_COUNT];
+    PVRSRV_DEVICE_NODE                  *psDeviceNodeList;                      
+    PVRSRV_POWER_DEV                    *psPowerDeviceList;                     
+        PVRSRV_RESOURCE                         sPowerStateChangeResource;      
+        PVRSRV_SYS_POWER_STATE          eCurrentPowerState;                     
+        PVRSRV_SYS_POWER_STATE          eFailedPowerState;                      
+        IMG_UINT32                                      ui32CurrentOSPowerState;        
+    PVRSRV_QUEUE_INFO           *psQueueList;                   
+        PVRSRV_KERNEL_SYNC_INFO         *psSharedSyncInfoList;          
+    IMG_PVOID                   pvEnvSpecificData;              
+    IMG_PVOID                   pvSysSpecificData;              
+        PVRSRV_RESOURCE                         sQProcessResource;                      
+        IMG_VOID                                        *pvSOCRegsBase;                         
+    IMG_HANDLE                  hSOCTimerRegisterOSMemHandle; 
+        IMG_UINT32                                      *pvSOCTimerRegisterKM;          
+        IMG_VOID                                        *pvSOCClockGateRegsBase;        
+        IMG_UINT32                                      ui32SOCClockGateRegsSize;
+        PFN_CMD_PROC                            *ppfnCmdProcList[SYS_DEVICE_COUNT];
+                                                                                                                        
+
+
+        PCOMMAND_COMPLETE_DATA          *ppsCmdCompleteData[SYS_DEVICE_COUNT];
+                                                                                                                        
+
+        IMG_BOOL                    bReProcessQueues;                   
+
+        RA_ARENA                                        *apsLocalDevMemArena[SYS_MAX_LOCAL_DEVMEM_ARENAS]; 
+
+    IMG_CHAR                    *pszVersionString;          
+        PVRSRV_EVENTOBJECT                      *psGlobalEventObject;                   
+
+        PVRSRV_MISC_INFO_CPUCACHEOP_TYPE ePendingCacheOpType;   
+} SYS_DATA;
+
+
+
+PVRSRV_ERROR SysInitialise(IMG_VOID);
+PVRSRV_ERROR SysFinalise(IMG_VOID);
+
+PVRSRV_ERROR SysDeinitialise(SYS_DATA *psSysData);
+PVRSRV_ERROR SysGetDeviceMemoryMap(PVRSRV_DEVICE_TYPE eDeviceType,
+                                                                        IMG_VOID **ppvDeviceMap);
+
+IMG_VOID SysRegisterExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode);
+IMG_VOID SysRemoveExternalDevice(PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_UINT32 SysGetInterruptSource(SYS_DATA                       *psSysData,
+                                                                 PVRSRV_DEVICE_NODE *psDeviceNode);
+
+IMG_VOID SysClearInterrupts(SYS_DATA* psSysData, IMG_UINT32 ui32ClearBits);
+
+PVRSRV_ERROR SysResetDevice(IMG_UINT32 ui32DeviceIndex);
+
+PVRSRV_ERROR SysSystemPrePowerState(PVRSRV_SYS_POWER_STATE eNewPowerState);
+PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState);
+PVRSRV_ERROR SysDevicePrePowerState(IMG_UINT32 ui32DeviceIndex,
+                                                                        PVRSRV_DEV_POWER_STATE eNewPowerState,
+                                                                        PVRSRV_DEV_POWER_STATE eCurrentPowerState);
+PVRSRV_ERROR SysDevicePostPowerState(IMG_UINT32 ui32DeviceIndex,
+                                                                         PVRSRV_DEV_POWER_STATE eNewPowerState,
+                                                                         PVRSRV_DEV_POWER_STATE eCurrentPowerState);
+
+#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
+PVRSRV_ERROR SysPowerLockWrap(SYS_DATA *psSysData);
+IMG_VOID SysPowerLockUnwrap(SYS_DATA *psSysData);
+#endif
+
+PVRSRV_ERROR SysOEMFunction (   IMG_UINT32      ui32ID,
+                                                                IMG_VOID        *pvIn,
+                                                                IMG_UINT32  ulInSize,
+                                                                IMG_VOID        *pvOut,
+                                                                IMG_UINT32      ulOutSize);
+
+
+IMG_DEV_PHYADDR SysCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_CPU_PHYADDR cpu_paddr);
+IMG_DEV_PHYADDR SysSysPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr);
+IMG_SYS_PHYADDR SysDevPAddrToSysPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_DEV_PHYADDR SysPAddr);
+IMG_CPU_PHYADDR SysSysPAddrToCpuPAddr (IMG_SYS_PHYADDR SysPAddr);
+IMG_SYS_PHYADDR SysCpuPAddrToSysPAddr (IMG_CPU_PHYADDR cpu_paddr);
+#if defined(PVR_LMA)
+IMG_BOOL SysVerifyCpuPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_CPU_PHYADDR CpuPAddr);
+IMG_BOOL SysVerifySysPAddrToDevPAddr (PVRSRV_DEVICE_TYPE eDeviceType, IMG_SYS_PHYADDR SysPAddr);
+#endif
+
+extern SYS_DATA* gpsSysData;
+
+#if !defined(USE_CODE)
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SysAcquireData)
+#endif
+static INLINE IMG_VOID SysAcquireData(SYS_DATA **ppsSysData)
+{
+        
+        *ppsSysData = gpsSysData;
+
+        
+
+
+
+        PVR_ASSERT (gpsSysData != IMG_NULL);
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SysAcquireDataNoCheck)
+#endif
+static INLINE SYS_DATA * SysAcquireDataNoCheck(IMG_VOID)
+{
+        
+        return gpsSysData;
+}
+
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SysInitialiseCommon)
+#endif
+static INLINE PVRSRV_ERROR SysInitialiseCommon(SYS_DATA *psSysData)
+{
+        PVRSRV_ERROR    eError;
+
+        
+        eError = PVRSRVInit(psSysData);
+
+        return eError;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(SysDeinitialiseCommon)
+#endif
+static INLINE IMG_VOID SysDeinitialiseCommon(SYS_DATA *psSysData)
+{
+        
+        PVRSRVDeInit(psSysData);
+
+        OSDestroyResource(&psSysData->sPowerStateChangeResource);
+}
+#endif 
+
+
+#if !(defined(NO_HARDWARE) && defined(__linux__) && defined(__KERNEL__))
+#define SysReadHWReg(p, o) OSReadHWReg(p, o)
+#define SysWriteHWReg(p, o, v) OSWriteHWReg(p, o, v)
+#else   
+static inline IMG_UINT32 SysReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset)
+{
+        return (IMG_UINT32) readl(pvLinRegBaseAddr + ui32Offset);
+}
+
+static inline IMG_VOID SysWriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value)
+{
+        writel(ui32Value, pvLinRegBaseAddr + ui32Offset);
+}
+#endif  
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 175f8f6ff88..1e02feb8463 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -23,6 +23,8 @@ source "drivers/gpu/drm/Kconfig"
 
 source "drivers/gpu/stub/Kconfig"
 
+source "drivers/gpu/pvr/Kconfig"
+
 config VGASTATE
        tristate
        default n