OSDN Git Service

initial import froyo-x86 gingerbread-x86 android-x86-2.2 android-x86-2.2-r2
authorOwen Kwon <pinebud77@hotmail.com>
Fri, 25 Jun 2010 09:19:45 +0000 (18:19 +0900)
committerOwen Kwon <pinebud77@hotmail.com>
Fri, 25 Jun 2010 09:19:45 +0000 (18:19 +0900)
145 files changed:
.gitignore [new file with mode: 0644]
AndroidBoard.mk [new file with mode: 0755]
AndroidProducts.mk [new file with mode: 0644]
BoardConfig.mk [new file with mode: 0644]
firmware/msvdx_fw.bin [new file with mode: 0644]
firmware/sd8686.bin [new file with mode: 0755]
firmware/sd8686_helper.bin [new file with mode: 0755]
init.s5.rc [new file with mode: 0644]
init.s5.sh [new file with mode: 0755]
pointercal [new file with mode: 0644]
psb-kernel-source-4.41.1/.gitignore [new file with mode: 0644]
psb-kernel-source-4.41.1/Android.mk [new file with mode: 0644]
psb-kernel-source-4.41.1/Config.in [new file with mode: 0644]
psb-kernel-source-4.41.1/Doxyfile [new file with mode: 0644]
psb-kernel-source-4.41.1/GPLv2_License.txt [new file with mode: 0644]
psb-kernel-source-4.41.1/Kconfig [new file with mode: 0644]
psb-kernel-source-4.41.1/Makefile [new file with mode: 0644]
psb-kernel-source-4.41.1/Makefile.kernel [new file with mode: 0644]
psb-kernel-source-4.41.1/Module.markers [new file with mode: 0644]
psb-kernel-source-4.41.1/README.drm [new file with mode: 0644]
psb-kernel-source-4.41.1/ati_pcigart.c [new file with mode: 0644]
psb-kernel-source-4.41.1/build.sh [new file with mode: 0755]
psb-kernel-source-4.41.1/create_linux_pci_lists.sh [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/changelog [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/compat [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/control [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/copyright [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/dirs [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/dkms.conf.in [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/patches/00list [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/patches/use_udev.dpatch [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/postinst [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/postrm [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/prerm [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/psb-kernel-headers.dirs [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/psb-kernel-headers.install [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/psb-kernel-headers.postrm [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/psb-kernel-headers.preinst [new file with mode: 0644]
psb-kernel-source-4.41.1/debian/rules [new file with mode: 0644]
psb-kernel-source-4.41.1/drm.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drmP.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_agpsupport.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_auth.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_bo.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_bo_lock.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_bo_move.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_bufs.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_compat.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_compat.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_context.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_core.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_crtc.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_crtc.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_dma.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_drawable.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_drv.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_edid.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_edid.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_fb.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_fence.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_fops.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_hashtab.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_hashtab.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_internal.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_ioc32.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_ioctl.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_irq.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_lock.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_memory.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_memory.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_memory_debug.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_memory_debug.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_mm.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_modes.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_object.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_objects.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_os_linux.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_pci.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_pciids.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_pciids.txt [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_proc.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_regman.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_sarea.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_scatter.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_sman.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_sman.h [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_stub.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_sysfs.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_ttm.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_vm.c [new file with mode: 0644]
psb-kernel-source-4.41.1/drm_vm_nopage_compat.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_buffer.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_compat.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_dma.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_drm.h [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_drv.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_drv.h [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_fence.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_init.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_ioc32.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_irq.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_mem.c [new file with mode: 0644]
psb-kernel-source-4.41.1/i915_reg.h [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_crt.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_display.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_drv.h [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_fb.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_i2c.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_lvds.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_lvds.h [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_modes.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_sdvo.c [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_sdvo_regs.h [new file with mode: 0644]
psb-kernel-source-4.41.1/intel_setup.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_buffer.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_detear.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_detear.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_drm.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_drv.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_drv.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_fb.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_fence.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_gtt.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_i2c.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_irq.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_mmu.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_msvdx.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_msvdx.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_msvdxinit.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_reg.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_regman.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_reset.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_scene.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_scene.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_schedule.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_schedule.h [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_setup.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_sgx.c [new file with mode: 0644]
psb-kernel-source-4.41.1/psb_xhw.c [new file with mode: 0644]
s5.mk [new file with mode: 0644]
s5_defconfig [new file with mode: 0644]
s5_info [new file with mode: 0644]
system.prop [new file with mode: 0644]
ts.conf [new file with mode: 0644]
ts.env [new file with mode: 0644]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..9e3f011
--- /dev/null
@@ -0,0 +1,9 @@
+*.o.cmd
+.tmp_versions
+*.o
+*.ko
+*.mod.c
+*.ko.cmd
+Modules.symvers
+Module.symvers
+modules.order
diff --git a/AndroidBoard.mk b/AndroidBoard.mk
new file mode 100755 (executable)
index 0000000..8a519c2
--- /dev/null
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+LOCAL_FIRMWARES := 
+TARGET_INITRD_SCRIPTS := $(LOCAL_PATH)/s5_info
+TARGET_PREBUILT_APPS := $(subst $(LOCAL_PATH)/,,$(wildcard $(LOCAL_PATH)/app/*))
+TARGET_KERNEL_CONFIG := $(LOCAL_PATH)/s5_defconfig
+
+#copy firmware files
+$(call add-prebuilt-targets,$(TARGET_OUT)/lib/firmware, firmware/msvdx_fw.bin)
+$(call add-prebuilt-targets,$(TARGET_OUT)/lib/firmware, firmware/sd8686.bin)
+$(call add-prebuilt-targets,$(TARGET_OUT)/lib/firmware, firmware/sd8686_helper.bin)
+
+#compile and add psb modules
+#this is not an Android Makefile format :(
+#ToDo : need to find a way to configure the path -_-;;
+KBUILD_OUTPUT := $(CURDIR)/$(TARGET_OUT_INTERMEDIATES)/kernel
+PSB_SRC_DIR := psb-kernel-source-4.41.1
+$(LOCAL_PATH)/drm.ko : kernel $(LOCAL_PATH)/psb.ko
+       cp $(TARGET_DEVICE_DIR)/$(PSB_SRC_DIR)/drm.ko $(TARGET_DEVICE_DIR)
+
+
+$(LOCAL_PATH)/psb.ko : kernel
+       $(hide) $(MAKE) -C$(TARGET_DEVICE_DIR)/$(PSB_SRC_DIR) \
+               LINUXDIR=$(KBUILD_OUTPUT) DRM_MODULES=psb
+       cp $(TARGET_DEVICE_DIR)/$(PSB_SRC_DIR)/psb.ko $(TARGET_DEVICE_DIR)
+
+$(call add-prebuilt-targets,$(TARGET_OUT)/lib/modules, drm.ko)
+$(call add-prebuilt-targets,$(TARGET_OUT)/lib/modules, psb.ko)
+
+include $(GENERIC_X86_ANDROID_MK)
+
diff --git a/AndroidProducts.mk b/AndroidProducts.mk
new file mode 100644 (file)
index 0000000..d12c16f
--- /dev/null
@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# This file should set PRODUCT_MAKEFILES to a list of product makefiles
+# to expose to the build system.  LOCAL_DIR will already be set to
+# the directory containing this file.
+#
+# This file may not rely on the value of any variable other than
+# LOCAL_DIR; do not use any conditionals, and do not look up the
+# value of any variable that isn't set in this file or in a file that
+# it includes.
+#
+
+PRODUCT_MAKEFILES := \
+    $(LOCAL_DIR)/s5.mk
diff --git a/BoardConfig.mk b/BoardConfig.mk
new file mode 100644 (file)
index 0000000..c050f8b
--- /dev/null
@@ -0,0 +1,6 @@
+RGET_HAS_THIRD_PARTY_APPS := true
+BOARD_WPA_SUPPLICANT_DRIVER := true
+BOARD_USES_TSLIB := true
+
+include $(GENERIC_X86_CONFIG_MK)
+
diff --git a/firmware/msvdx_fw.bin b/firmware/msvdx_fw.bin
new file mode 100644 (file)
index 0000000..7ee9ce0
Binary files /dev/null and b/firmware/msvdx_fw.bin differ
diff --git a/firmware/sd8686.bin b/firmware/sd8686.bin
new file mode 100755 (executable)
index 0000000..4f5675c
Binary files /dev/null and b/firmware/sd8686.bin differ
diff --git a/firmware/sd8686_helper.bin b/firmware/sd8686_helper.bin
new file mode 100755 (executable)
index 0000000..f450ee6
Binary files /dev/null and b/firmware/sd8686_helper.bin differ
diff --git a/init.s5.rc b/init.s5.rc
new file mode 100644 (file)
index 0000000..d3bd900
--- /dev/null
@@ -0,0 +1,2 @@
+service s5hw /system/bin/sh /system/etc/init.s5.sh
+       oneshot
diff --git a/init.s5.sh b/init.s5.sh
new file mode 100755 (executable)
index 0000000..2f7acf0
--- /dev/null
@@ -0,0 +1,22 @@
+#!/system/bin/sh
+
+# no sleep!
+echo s5NoSleep > /sys/power/wake_lock
+
+#turn on wifi
+/system/xbin/s5_onoff 0x7 0x1
+
+#turn on BT
+/system/xbin/s5_onoff 0x2 0x1
+#modprobe libertas_sdio                # moved to initrd"
+
+#netcfg eth0 dhcp
+#setprop net.dns1 4.2.2.2
+
+## For wifi, we'll need this:
+
+# insmod ath_hal.ko
+# insmod wlan.ko
+# insmod wlan_scan_sta.ko
+# insmod ath_rate_sample.ko
+# insmod ath_pci.ko
diff --git a/pointercal b/pointercal
new file mode 100644 (file)
index 0000000..204844f
--- /dev/null
@@ -0,0 +1 @@
+77039 -493 -4216930 195 51908 -5652733 65536 1024 600#
diff --git a/psb-kernel-source-4.41.1/.gitignore b/psb-kernel-source-4.41.1/.gitignore
new file mode 100644 (file)
index 0000000..9e3f011
--- /dev/null
@@ -0,0 +1,9 @@
+*.o.cmd
+.tmp_versions
+*.o
+*.ko
+*.mod.c
+*.ko.cmd
+Modules.symvers
+Module.symvers
+modules.order
diff --git a/psb-kernel-source-4.41.1/Android.mk b/psb-kernel-source-4.41.1/Android.mk
new file mode 100644 (file)
index 0000000..5632356
--- /dev/null
@@ -0,0 +1,4 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR-VARS)
+
+
diff --git a/psb-kernel-source-4.41.1/Config.in b/psb-kernel-source-4.41.1/Config.in
new file mode 100644 (file)
index 0000000..46ba48d
--- /dev/null
@@ -0,0 +1,17 @@
+#
+# Drm device configuration
+#
+# This driver provides support for the
+# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
+#
+
+tristate '  3dfx Banshee/Voodoo3+' CONFIG_DRM_TDFX
+#tristate '  3dlabs GMX 2000' CONFIG_DRM_GAMMA
+tristate '  ATI Rage 128' CONFIG_DRM_R128
+tristate '  ATI Radeon' CONFIG_DRM_RADEON
+dep_tristate '  Intel I810' CONFIG_DRM_I810 $CONFIG_AGP
+dep_tristate '  Intel 830M/845G/852GM/855GM/865G' CONFIG_DRM_I830 $CONFIG_AGP
+dep_tristate '  Matrox g200/g400' CONFIG_DRM_MGA $CONFIG_AGP
+tristate '  SiS' CONFIG_DRM_SIS
+tristate '  Via Unichrome' CONFIG_DRM_VIA
+
diff --git a/psb-kernel-source-4.41.1/Doxyfile b/psb-kernel-source-4.41.1/Doxyfile
new file mode 100644 (file)
index 0000000..97efeaa
--- /dev/null
@@ -0,0 +1,1161 @@
+# Doxyfile 1.3.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "Direct Rendering Module"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = 
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of source 
+# files, where putting all generated files in the same directory would otherwise 
+# cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, 
+# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, 
+# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, 
+# Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE        = English
+
+# This tag can be used to specify the encoding used in the generated output. 
+# The encoding is not always determined by the language that is chosen, 
+# but also whether or not the output is meant for Windows or non-Windows users. 
+# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES 
+# forces the Windows encoding (this is the default for the Windows binary), 
+# whereas setting the tag to NO uses a Unix-style encoding (the default for 
+# all platforms other than Windows).
+
+USE_WINDOWS_ENCODING   = NO
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is used 
+# as the annotated text. Otherwise, the brief description is used as-is. If left 
+# blank, the following values are used ("$name" is automatically replaced with the 
+# name of the entity): "The $name class" "The $name widget" "The $name file" 
+# "is" "provides" "specifies" "contains" "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = 
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited 
+# members of a class in the documentation of that class as if those members were 
+# ordinary class members. Constructors, destructors and assignment operators of 
+# the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like the Qt-style comments (thus requiring an 
+# explicit @brief command for a brief description.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member 
+# documentation.
+
+DETAILS_AT_TOP         = YES
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources 
+# only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources 
+# only. Doxygen will then generate output that is more tailored for Java. 
+# For instance, namespaces will be presented as packages, qualified scopes 
+# will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = NO
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = NO
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = . \
+                         ../shared-core
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp 
+# *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm
+
+FILE_PATTERNS          = *.c \
+                         *.h
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = 
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories 
+# that are symbolic links (a Unix filesystem feature) are excluded from the input.
+
+EXCLUDE_SYMLINKS       = YES
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories.
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = 
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES (the default) 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES (the default) 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = YES
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, 
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are 
+# probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_PREDEFINED tags.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed.
+
+PREDEFINED             = __KERNEL__ \
+                         DRM(x)=x \
+                         __OS_HAS_AGP=1 \
+                         __OS_HAS_MTRR=1
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = DRMFILE \
+                         DRM_IOCTL_ARGS \
+                         DRM_IRQ_ARGS \
+                         DRM_TASKQUEUE_ARGS
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse the 
+# parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base or 
+# super classes. Setting the tag to NO turns the diagrams off. Note that this 
+# option is superseded by the HAVE_DOT option below. This is only a fallback. It is 
+# recommended to install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will 
+# generate a call dependency graph for every global function or class method. 
+# Note that enabling this option will significantly increase the time of a run. 
+# So in most cases it will be better to enable call graphs for selected 
+# functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found on the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_WIDTH    = 1024
+
+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images.
+
+MAX_DOT_GRAPH_HEIGHT   = 1024
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes that 
+# lay further from the root node will be omitted. Note that setting this option to 
+# 1 or 2 may greatly reduce the computation time needed for large code bases. Also 
+# note that a graph may be further truncated if the graph's image dimensions are 
+# not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH and MAX_DOT_GRAPH_HEIGHT). 
+# If 0 is used for the depth value (the default), the graph is not depth-constrained.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE           = NO
diff --git a/psb-kernel-source-4.41.1/GPLv2_License.txt b/psb-kernel-source-4.41.1/GPLv2_License.txt
new file mode 100644 (file)
index 0000000..ce7ac8e
--- /dev/null
@@ -0,0 +1,341 @@
+\r
+                   GNU GENERAL PUBLIC LICENSE\r
+                      Version 2, June 1991\r
+\r
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.\r
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
+ Everyone is permitted to copy and distribute verbatim copies\r
+ of this license document, but changing it is not allowed.\r
+\r
+                           Preamble\r
+\r
+  The licenses for most software are designed to take away your\r
+freedom to share and change it.  By contrast, the GNU General Public\r
+License is intended to guarantee your freedom to share and change free\r
+software--to make sure the software is free for all its users.  This\r
+General Public License applies to most of the Free Software\r
+Foundation's software and to any other program whose authors commit to\r
+using it.  (Some other Free Software Foundation software is covered by\r
+the GNU Library General Public License instead.)  You can apply it to\r
+your programs, too.\r
+\r
+  When we speak of free software, we are referring to freedom, not\r
+price.  Our General Public Licenses are designed to make sure that you\r
+have the freedom to distribute copies of free software (and charge for\r
+this service if you wish), that you receive source code or can get it\r
+if you want it, that you can change the software or use pieces of it\r
+in new free programs; and that you know you can do these things.\r
+\r
+  To protect your rights, we need to make restrictions that forbid\r
+anyone to deny you these rights or to ask you to surrender the rights.\r
+These restrictions translate to certain responsibilities for you if you\r
+distribute copies of the software, or if you modify it.\r
+\r
+  For example, if you distribute copies of such a program, whether\r
+gratis or for a fee, you must give the recipients all the rights that\r
+you have.  You must make sure that they, too, receive or can get the\r
+source code.  And you must show them these terms so they know their\r
+rights.\r
+\r
+  We protect your rights with two steps: (1) copyright the software, and\r
+(2) offer you this license which gives you legal permission to copy,\r
+distribute and/or modify the software.\r
+\r
+  Also, for each author's protection and ours, we want to make certain\r
+that everyone understands that there is no warranty for this free\r
+software.  If the software is modified by someone else and passed on, we\r
+want its recipients to know that what they have is not the original, so\r
+that any problems introduced by others will not reflect on the original\r
+authors' reputations.\r
+\r
+  Finally, any free program is threatened constantly by software\r
+patents.  We wish to avoid the danger that redistributors of a free\r
+program will individually obtain patent licenses, in effect making the\r
+program proprietary.  To prevent this, we have made it clear that any\r
+patent must be licensed for everyone's free use or not licensed at all.\r
+\r
+  The precise terms and conditions for copying, distribution and\r
+modification follow.\r
+\f\r
+                   GNU GENERAL PUBLIC LICENSE\r
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\r
+\r
+  0. This License applies to any program or other work which contains\r
+a notice placed by the copyright holder saying it may be distributed\r
+under the terms of this General Public License.  The "Program", below,\r
+refers to any such program or work, and a "work based on the Program"\r
+means either the Program or any derivative work under copyright law:\r
+that is to say, a work containing the Program or a portion of it,\r
+either verbatim or with modifications and/or translated into another\r
+language.  (Hereinafter, translation is included without limitation in\r
+the term "modification".)  Each licensee is addressed as "you".\r
+\r
+Activities other than copying, distribution and modification are not\r
+covered by this License; they are outside its scope.  The act of\r
+running the Program is not restricted, and the output from the Program\r
+is covered only if its contents constitute a work based on the\r
+Program (independent of having been made by running the Program).\r
+Whether that is true depends on what the Program does.\r
+\r
+  1. You may copy and distribute verbatim copies of the Program's\r
+source code as you receive it, in any medium, provided that you\r
+conspicuously and appropriately publish on each copy an appropriate\r
+copyright notice and disclaimer of warranty; keep intact all the\r
+notices that refer to this License and to the absence of any warranty;\r
+and give any other recipients of the Program a copy of this License\r
+along with the Program.\r
+\r
+You may charge a fee for the physical act of transferring a copy, and\r
+you may at your option offer warranty protection in exchange for a fee.\r
+\r
+  2. You may modify your copy or copies of the Program or any portion\r
+of it, thus forming a work based on the Program, and copy and\r
+distribute such modifications or work under the terms of Section 1\r
+above, provided that you also meet all of these conditions:\r
+\r
+    a) You must cause the modified files to carry prominent notices\r
+    stating that you changed the files and the date of any change.\r
+\r
+    b) You must cause any work that you distribute or publish, that in\r
+    whole or in part contains or is derived from the Program or any\r
+    part thereof, to be licensed as a whole at no charge to all third\r
+    parties under the terms of this License.\r
+\r
+    c) If the modified program normally reads commands interactively\r
+    when run, you must cause it, when started running for such\r
+    interactive use in the most ordinary way, to print or display an\r
+    announcement including an appropriate copyright notice and a\r
+    notice that there is no warranty (or else, saying that you provide\r
+    a warranty) and that users may redistribute the program under\r
+    these conditions, and telling the user how to view a copy of this\r
+    License.  (Exception: if the Program itself is interactive but\r
+    does not normally print such an announcement, your work based on\r
+    the Program is not required to print an announcement.)\r
+\f\r
+These requirements apply to the modified work as a whole.  If\r
+identifiable sections of that work are not derived from the Program,\r
+and can be reasonably considered independent and separate works in\r
+themselves, then this License, and its terms, do not apply to those\r
+sections when you distribute them as separate works.  But when you\r
+distribute the same sections as part of a whole which is a work based\r
+on the Program, the distribution of the whole must be on the terms of\r
+this License, whose permissions for other licensees extend to the\r
+entire whole, and thus to each and every part regardless of who wrote it.\r
+\r
+Thus, it is not the intent of this section to claim rights or contest\r
+your rights to work written entirely by you; rather, the intent is to\r
+exercise the right to control the distribution of derivative or\r
+collective works based on the Program.\r
+\r
+In addition, mere aggregation of another work not based on the Program\r
+with the Program (or with a work based on the Program) on a volume of\r
+a storage or distribution medium does not bring the other work under\r
+the scope of this License.\r
+\r
+  3. You may copy and distribute the Program (or a work based on it,\r
+under Section 2) in object code or executable form under the terms of\r
+Sections 1 and 2 above provided that you also do one of the following:\r
+\r
+    a) Accompany it with the complete corresponding machine-readable\r
+    source code, which must be distributed under the terms of Sections\r
+    1 and 2 above on a medium customarily used for software interchange; or,\r
+\r
+    b) Accompany it with a written offer, valid for at least three\r
+    years, to give any third party, for a charge no more than your\r
+    cost of physically performing source distribution, a complete\r
+    machine-readable copy of the corresponding source code, to be\r
+    distributed under the terms of Sections 1 and 2 above on a medium\r
+    customarily used for software interchange; or,\r
+\r
+    c) Accompany it with the information you received as to the offer\r
+    to distribute corresponding source code.  (This alternative is\r
+    allowed only for noncommercial distribution and only if you\r
+    received the program in object code or executable form with such\r
+    an offer, in accord with Subsection b above.)\r
+\r
+The source code for a work means the preferred form of the work for\r
+making modifications to it.  For an executable work, complete source\r
+code means all the source code for all modules it contains, plus any\r
+associated interface definition files, plus the scripts used to\r
+control compilation and installation of the executable.  However, as a\r
+special exception, the source code distributed need not include\r
+anything that is normally distributed (in either source or binary\r
+form) with the major components (compiler, kernel, and so on) of the\r
+operating system on which the executable runs, unless that component\r
+itself accompanies the executable.\r
+\r
+If distribution of executable or object code is made by offering\r
+access to copy from a designated place, then offering equivalent\r
+access to copy the source code from the same place counts as\r
+distribution of the source code, even though third parties are not\r
+compelled to copy the source along with the object code.\r
+\f\r
+  4. You may not copy, modify, sublicense, or distribute the Program\r
+except as expressly provided under this License.  Any attempt\r
+otherwise to copy, modify, sublicense or distribute the Program is\r
+void, and will automatically terminate your rights under this License.\r
+However, parties who have received copies, or rights, from you under\r
+this License will not have their licenses terminated so long as such\r
+parties remain in full compliance.\r
+\r
+  5. You are not required to accept this License, since you have not\r
+signed it.  However, nothing else grants you permission to modify or\r
+distribute the Program or its derivative works.  These actions are\r
+prohibited by law if you do not accept this License.  Therefore, by\r
+modifying or distributing the Program (or any work based on the\r
+Program), you indicate your acceptance of this License to do so, and\r
+all its terms and conditions for copying, distributing or modifying\r
+the Program or works based on it.\r
+\r
+  6. Each time you redistribute the Program (or any work based on the\r
+Program), the recipient automatically receives a license from the\r
+original licensor to copy, distribute or modify the Program subject to\r
+these terms and conditions.  You may not impose any further\r
+restrictions on the recipients' exercise of the rights granted herein.\r
+You are not responsible for enforcing compliance by third parties to\r
+this License.\r
+\r
+  7. If, as a consequence of a court judgment or allegation of patent\r
+infringement or for any other reason (not limited to patent issues),\r
+conditions are imposed on you (whether by court order, agreement or\r
+otherwise) that contradict the conditions of this License, they do not\r
+excuse you from the conditions of this License.  If you cannot\r
+distribute so as to satisfy simultaneously your obligations under this\r
+License and any other pertinent obligations, then as a consequence you\r
+may not distribute the Program at all.  For example, if a patent\r
+license would not permit royalty-free redistribution of the Program by\r
+all those who receive copies directly or indirectly through you, then\r
+the only way you could satisfy both it and this License would be to\r
+refrain entirely from distribution of the Program.\r
+\r
+If any portion of this section is held invalid or unenforceable under\r
+any particular circumstance, the balance of the section is intended to\r
+apply and the section as a whole is intended to apply in other\r
+circumstances.\r
+\r
+It is not the purpose of this section to induce you to infringe any\r
+patents or other property right claims or to contest validity of any\r
+such claims; this section has the sole purpose of protecting the\r
+integrity of the free software distribution system, which is\r
+implemented by public license practices.  Many people have made\r
+generous contributions to the wide range of software distributed\r
+through that system in reliance on consistent application of that\r
+system; it is up to the author/donor to decide if he or she is willing\r
+to distribute software through any other system and a licensee cannot\r
+impose that choice.\r
+\r
+This section is intended to make thoroughly clear what is believed to\r
+be a consequence of the rest of this License.\r
+\f\r
+  8. If the distribution and/or use of the Program is restricted in\r
+certain countries either by patents or by copyrighted interfaces, the\r
+original copyright holder who places the Program under this License\r
+may add an explicit geographical distribution limitation excluding\r
+those countries, so that distribution is permitted only in or among\r
+countries not thus excluded.  In such case, this License incorporates\r
+the limitation as if written in the body of this License.\r
+\r
+  9. The Free Software Foundation may publish revised and/or new versions\r
+of the General Public License from time to time.  Such new versions will\r
+be similar in spirit to the present version, but may differ in detail to\r
+address new problems or concerns.\r
+\r
+Each version is given a distinguishing version number.  If the Program\r
+specifies a version number of this License which applies to it and "any\r
+later version", you have the option of following the terms and conditions\r
+either of that version or of any later version published by the Free\r
+Software Foundation.  If the Program does not specify a version number of\r
+this License, you may choose any version ever published by the Free Software\r
+Foundation.\r
+\r
+  10. If you wish to incorporate parts of the Program into other free\r
+programs whose distribution conditions are different, write to the author\r
+to ask for permission.  For software which is copyrighted by the Free\r
+Software Foundation, write to the Free Software Foundation; we sometimes\r
+make exceptions for this.  Our decision will be guided by the two goals\r
+of preserving the free status of all derivatives of our free software and\r
+of promoting the sharing and reuse of software generally.\r
+\r
+                           NO WARRANTY\r
+\r
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\r
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\r
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\r
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\r
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\r
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\r
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\r
+REPAIR OR CORRECTION.\r
+\r
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\r
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\r
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\r
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\r
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\r
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\r
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\r
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\r
+POSSIBILITY OF SUCH DAMAGES.\r
+\r
+                    END OF TERMS AND CONDITIONS\r
+\f\r
+           How to Apply These Terms to Your New Programs\r
+\r
+  If you develop a new program, and you want it to be of the greatest\r
+possible use to the public, the best way to achieve this is to make it\r
+free software which everyone can redistribute and change under these terms.\r
+\r
+  To do so, attach the following notices to the program.  It is safest\r
+to attach them to the start of each source file to most effectively\r
+convey the exclusion of warranty; and each file should have at least\r
+the "copyright" line and a pointer to where the full notice is found.\r
+\r
+    <one line to give the program's name and a brief idea of what it does.>\r
+    Copyright (C) <year>  <name of author>\r
+\r
+    This program is free software; you can redistribute it and/or modify\r
+    it under the terms of the GNU General Public License as published by\r
+    the Free Software Foundation; either version 2 of the License, or\r
+    (at your option) any later version.\r
+\r
+    This program is distributed in the hope that it will be useful,\r
+    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+    GNU General Public License for more details.\r
+\r
+    You should have received a copy of the GNU General Public License\r
+    along with this program; if not, write to the Free Software\r
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
+\r
+\r
+Also add information on how to contact you by electronic and paper mail.\r
+\r
+If the program is interactive, make it output a short notice like this\r
+when it starts in an interactive mode:\r
+\r
+    Gnomovision version 69, Copyright (C) year name of author\r
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\r
+    This is free software, and you are welcome to redistribute it\r
+    under certain conditions; type `show c' for details.\r
+\r
+The hypothetical commands `show w' and `show c' should show the appropriate\r
+parts of the General Public License.  Of course, the commands you use may\r
+be called something other than `show w' and `show c'; they could even be\r
+mouse-clicks or menu items--whatever suits your program.\r
+\r
+You should also get your employer (if you work as a programmer) or your\r
+school, if any, to sign a "copyright disclaimer" for the program, if\r
+necessary.  Here is a sample; alter the names:\r
+\r
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program\r
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.\r
+\r
+  <signature of Ty Coon>, 1 April 1989\r
+  Ty Coon, President of Vice\r
+\r
+This General Public License does not permit incorporating your program into\r
+proprietary programs.  If your program is a subroutine library, you may\r
+consider it more useful to permit linking proprietary applications with the\r
+library.  If this is what you want to do, use the GNU Library General\r
+Public License instead of this License.\r
diff --git a/psb-kernel-source-4.41.1/Kconfig b/psb-kernel-source-4.41.1/Kconfig
new file mode 100644 (file)
index 0000000..96015b1
--- /dev/null
@@ -0,0 +1,103 @@
+#
+# Drm device configuration
+#
+# This driver provides support for the
+# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
+#
+config DRM
+       bool "Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)"
+       help
+         Kernel-level support for the Direct Rendering Infrastructure (DRI)
+         introduced in XFree86 4.0. If you say Y here, you need to select
+         the module that's right for your graphics card from the list below.
+         These modules provide support for synchronization, security, and
+         DMA transfers. Please see <http://dri.sourceforge.net/> for more
+         details.  You should also select and configure AGP
+         (/dev/agpgart) support.
+
+config DRM_TDFX
+       tristate "3dfx Banshee/Voodoo3+"
+       depends on DRM && PCI
+       help
+         Choose this option if you have a 3dfx Banshee or Voodoo3 (or later),
+         graphics card.  If M is selected, the module will be called tdfx.
+
+config DRM_R128
+       tristate "ATI Rage 128"
+       depends on DRM && PCI
+       help
+         Choose this option if you have an ATI Rage 128 graphics card.  If M
+         is selected, the module will be called r128.  AGP support for
+         this card is strongly suggested (unless you have a PCI version).
+
+config DRM_RADEON
+       tristate "ATI Radeon"
+       depends on DRM && PCI
+       help
+         Choose this option if you have an ATI Radeon graphics card.  There
+         are both PCI and AGP versions.  You don't need to choose this to
+         run the Radeon in plain VGA mode.  There is a product page at
+         <http://www.ati.com/na/pages/products/pc/radeon32/index.html>.
+         If M is selected, the module will be called radeon.
+
+config DRM_I810
+       tristate "Intel I810"
+       depends on DRM && AGP && AGP_INTEL
+       help
+         Choose this option if you have an Intel I810 graphics card.  If M is
+         selected, the module will be called i810.  AGP support is required
+         for this driver to work.
+
+choice
+       prompt "Intel 830M, 845G, 852GM, 855GM, 865G"
+       depends on DRM && AGP && AGP_INTEL
+       optional
+
+config DRM_I915
+       tristate "i915 driver"
+       depends on DRM && AGP && AGP_INTEL
+       help
+         Choose this option if you have a system that has Intel 830M, 845G,
+         852GM, 855GM, 865G, 915G, 915GM, 945G, 945GM and 965G integrated 
+         graphics.  If M is selected, the module will be called i915.  
+         AGP support is required for this driver to work.
+       
+endchoice
+
+config DRM_MGA
+       tristate "Matrox g200/g400"
+       depends on DRM && (!X86_64 || BROKEN) && (!PPC || BROKEN)
+       help
+         Choose this option if you have a Matrox G200, G400, G450 or G550
+         graphics card.  If M is selected, the module will be called mga.
+
+config DRM_SIS
+       tristate "SiS video cards"
+       depends on DRM
+       help
+         Choose this option if you have a SiS 630 or compatible video 
+         chipset. If M is selected the module will be called sis.
+
+config DRM_VIA
+       tristate "Via unichrome video cards"
+       depends on DRM 
+       help
+         Choose this option if you have a Via unichrome or compatible video 
+         chipset. If M is selected the module will be called via.
+
+config DRM_MACH64
+       tristate "ATI Rage Pro (Mach64)"
+       depends on DRM && PCI
+       help
+         Choose this option if you have an ATI Rage Pro (mach64 chipset)
+         graphics card.  Example cards include:  3D Rage Pro, Xpert 98,
+         3D Rage LT Pro, 3D Rage XL/XC, and 3D Rage Mobility (P/M, M1).
+         Cards earlier than ATI Rage Pro (e.g. Rage II) are not supported.
+         If M is selected, the module will be called mach64.  AGP support for
+         this card is strongly suggested (unless you have a PCI version).
+
+config DRM_PSB
+       tristate "Intel Poulsbo"
+       depends on DRM && PCI && I2C_ALGOBIT
+       help
+         Choose
diff --git a/psb-kernel-source-4.41.1/Makefile b/psb-kernel-source-4.41.1/Makefile
new file mode 100644 (file)
index 0000000..1684557
--- /dev/null
@@ -0,0 +1,369 @@
+# Makefile -- For the Direct Rendering Manager module (drm)
+#
+# Based on David Woodhouse's mtd build.
+#
+# Modified to handle the DRM requirements and builds on a wider range of
+# platforms in a flexible way by David Dawes.  It's not clear, however,
+# that this approach is simpler than the old one.
+#
+# The purpose of this Makefile is to handle setting up everything
+# needed for an out-of-kernel source build.  Makefile.kernel contains
+# everything required for in-kernel source builds.  It is included into
+# this file, so none of that should be duplicated here.
+#
+# $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/kernel/Makefile.linux,v 1.40 2003/08/17 17:12:25 dawes Exp $
+#
+
+#
+# By default, the build is done against the running linux kernel source.
+# To build against a different kernel source tree, set LINUXDIR:
+#
+#    make LINUXDIR=/path/to/kernel/source
+
+#
+# To build only some modules, either set DRM_MODULES to the list of modules,
+# or specify the modules as targets:
+#
+#    make r128.o radeon.o
+#
+# or:
+#
+#    make DRM_MODULES="r128 radeon"
+#
+
+SHELL=/bin/sh
+
+.SUFFIXES:
+
+ifndef LINUXDIR
+RUNNING_REL := $(shell uname -r)
+
+LINUXDIR := $(shell if [ -e /lib/modules/$(RUNNING_REL)/source ]; then \
+                echo /lib/modules/$(RUNNING_REL)/source; \
+                else echo /lib/modules/$(RUNNING_REL)/build; fi)
+endif
+
+ifndef O
+O := $(shell if [ -e /lib/modules/$(RUNNING_REL)/build ]; then \
+                echo /lib/modules/$(RUNNING_REL)/build; \
+                else echo ""; fi)
+#O := $(LINUXDIR)
+endif
+
+ifdef ARCH
+MACHINE := $(ARCH)
+else
+MACHINE := $(shell uname -m)
+endif
+
+# Modules for all architectures
+MODULE_LIST := drm.o tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o \
+               mach64.o nv.o nouveau.o psb.o xgi.o
+
+# Modules only for ix86 architectures
+ifneq (,$(findstring 86,$(MACHINE)))
+ARCHX86 := 1
+MODULE_LIST += i810.o i915.o
+endif
+
+ifneq (,$(findstring sparc64,$(MACHINE)))
+ARCHSPARC64 := 1
+#MODULE_LIST += ffb.o
+endif
+
+DRM_MODULES ?= $(MODULE_LIST)
+
+# These definitions are for handling dependencies in the out of kernel build.
+
+DRMHEADERS =    drmP.h drm_compat.h drm_os_linux.h drm.h drm_sarea.h
+COREHEADERS =   drm_core.h drm_sman.h drm_hashtab.h 
+
+TDFXHEADERS =   tdfx_drv.h $(DRMHEADERS)
+R128HEADERS =   r128_drv.h r128_drm.h $(DRMHEADERS)
+RADEONHEADERS = radeon_drv.h radeon_drm.h r300_reg.h $(DRMHEADERS)
+MGAHEADERS =    mga_drv.h mga_drm.h mga_ucode.h $(DRMHEADERS)
+I810HEADERS =   i810_drv.h i810_drm.h $(DRMHEADERS)
+I915HEADERS =   i915_drv.h i915_drm.h $(DRMHEADERS)
+SISHEADERS=     sis_drv.h sis_drm.h drm_hashtab.h drm_sman.h $(DRMHEADERS)
+SAVAGEHEADERS=  savage_drv.h savage_drm.h $(DRMHEADERS)
+VIAHEADERS =   via_drm.h via_drv.h via_3d_reg.h via_verifier.h $(DRMHEADERS)
+MACH64HEADERS = mach64_drv.h mach64_drm.h $(DRMHEADERS)
+NVHEADERS =     nv_drv.h $(DRMHEADERS)
+FFBHEADERS =   ffb_drv.h $(DRMHEADERS)
+NOUVEAUHEADERS = nouveau_drv.h nouveau_drm.h nouveau_reg.h $(DRMHEADERS)
+PSBHEADERS=    psb_drv.h psb_drm.h psb_reg.h psb_kreg.h psb_scene.h \
+       psb_schedule.h psb_detear.h $(DRMHEADERS)
+XGIHEADERS = xgi_cmdlist.h xgi_drv.h xgi_misc.h xgi_regs.h $(DRMHEADERS)
+
+PROGS = dristat drmstat
+
+CLEANFILES = *.o *.ko $(PROGS) .depend .*.flags .*.d .*.cmd *.mod.c .tmp_versions
+
+# VERSION is not defined from the initial invocation.  It is defined when
+# this Makefile is invoked from the kernel's root Makefile.
+
+ifndef VERSION
+
+ifdef RUNNING_REL
+
+# SuSE has the version.h and autoconf.h headers for the current kernel
+# in /boot as /boot/vmlinuz.version.h and /boot/vmlinuz.autoconf.h.
+# Check these first to see if they match the running kernel.
+
+BOOTVERSION_PREFIX = /boot/vmlinuz.
+
+V := $(shell if [ -f $(BOOTVERSION_PREFIX)version.h ]; then \
+       grep UTS_RELEASE $(BOOTVERSION_PREFIX)version.h | \
+       cut -d' ' -f3; fi)
+
+ifeq ($(V),"$(RUNNING_REL)")
+HEADERFROMBOOT := 1
+GETCONFIG := MAKEFILES=$(shell pwd)/.config
+HAVECONFIG := y
+endif
+
+# On Red Hat we need to check if there is a .config file in the kernel
+# source directory.  If there isn't, we need to check if there's a
+# matching file in the configs subdirectory.
+
+ifneq ($(HAVECONFIG),y)
+HAVECONFIG := $(shell if [ -e $(LINUXDIR)/.config ]; then echo y; fi)
+endif
+
+ifneq ($(HAVECONFIG),y)
+REL_BASE := $(shell echo $(RUNNING_REL) | sed 's/-.*//')
+REL_TYPE := $(shell echo $(RUNNING_REL) | sed 's/[0-9.-]//g')
+ifeq ($(REL_TYPE),)
+RHCONFIG := configs/kernel-$(REL_BASE)-$(MACHINE).config
+else
+RHCONFIG := configs/kernel-$(REL_BASE)-$(MACHINE)-$(REL_TYPE).config
+endif
+HAVECONFIG := $(shell if [ -e $(LINUXDIR)/$(RHCONFIG) ]; then echo y; fi)
+ifneq ($(HAVECONFIG),y)
+RHCONFIG :=
+endif
+endif
+
+ifneq ($(HAVECONFIG),y)
+ifneq ($(0),$(LINUXDIR))
+GETCONFIG += O=$(O)
+endif
+HAVECONFIG := $(shell if [ -e $(O)/.config ]; then echo y; fi)
+endif
+
+GETCONFIG += O=$(O)
+
+ifneq ($(HAVECONFIG),y)
+$(error Cannot find a kernel config file)
+endif
+
+endif
+
+CLEANCONFIG := $(shell if cmp -s $(LINUXDIR)/.config .config; then echo y; fi)
+ifeq ($(CLEANCONFIG),y)
+CLEANFILES += $(LINUXDIR)/.config .config $(LINUXDIR)/tmp_include_depends
+endif
+
+all: modules
+
+modules: includes
+       +make -C $(LINUXDIR) $(GETCONFIG) SUBDIRS=`pwd` DRMSRCDIR=`pwd` modules
+
+ifeq ($(HEADERFROMBOOT),1)
+
+BOOTHEADERS = version.h autoconf.h
+BOOTCONFIG = .config
+
+CLEANFILES += $(BOOTHEADERS) $(BOOTCONFIG)
+
+includes:: $(BOOTHEADERS) $(BOOTCONFIG)
+
+version.h: $(BOOTVERSION_PREFIX)version.h
+       rm -f $@
+       ln -s $< $@
+
+autoconf.h: $(BOOTVERSION_PREFIX)autoconf.h
+       rm -f $@
+       ln -s $< $@
+
+.config: $(BOOTVERSION_PREFIX)config
+       rm -f $@
+       ln -s $< $@
+endif
+
+# This prepares an unused Red Hat kernel tree for the build.
+ifneq ($(RHCONFIG),)
+includes:: $(LINUXDIR)/.config $(LINUXDIR)/tmp_include_depends .config
+
+$(LINUXDIR)/.config: $(LINUXDIR)/$(RHCONFIG)
+       rm -f $@
+       ln -s $< $@
+
+.config: $(LINUXDIR)/$(RHCONFIG)
+       rm -f $@
+       ln -s $< $@
+
+$(LINUXDIR)/tmp_include_depends:
+       echo all: > $@
+endif
+
+# Make sure that the shared source files are linked into this directory.
+
+
+SHAREDDIR := .
+
+ifeq ($(shell if [ -d $(SHAREDDIR) ]; then echo y; fi),y)
+includes::  drm_pciids.h
+
+drm_pciids.h: $(SHAREDDIR)/drm_pciids.txt
+       sh ./create_linux_pci_lists.sh < $(SHAREDDIR)/drm_pciids.txt
+else
+includes::
+
+endif
+
+clean cleandir:
+       rm -rf $(CLEANFILES)
+
+$(MODULE_LIST)::
+       make DRM_MODULES=$@ modules
+
+# Build test utilities
+
+PRGCFLAGS = $(CFLAGS) -g -ansi -pedantic -DPOSIX_C_SOURCE=199309L \
+           -D_POSIX_SOURCE -D_XOPEN_SOURCE -D_BSD_SOURCE -D_SVID_SOURCE \
+           -I. -I../../..
+
+DRMSTATLIBS = -L../../.. -L.. -ldrm -lxf86_os \
+             -L../../../../dummylib -ldummy -lm
+
+programs: $(PROGS)
+
+dristat: dristat.c
+       $(CC) $(PRGCFLAGS) $< -o $@
+
+drmstat: drmstat.c
+       $(CC) $(PRGCFLAGS) $< -o $@ $(DRMSTATLIBS)
+
+install:
+       make -C $(LINUXDIR) $(GETCONFIG) SUBDIRS=`pwd` DRMSRCDIR=`pwd` modules_install
+
+else
+
+# Check for kernel versions that we don't support.
+
+BELOW26 := $(shell if [ $(VERSION) -lt 2 -o $(PATCHLEVEL) -lt 6 ]; then \
+               echo y; fi)
+
+ifeq ($(BELOW26),y)
+$(error Only 2.6.x and later kernels are supported \
+       ($(VERSION).$(PATCHLEVEL).$(SUBLEVEL)))
+endif
+
+ifdef ARCHX86
+ifndef CONFIG_X86_CMPXCHG
+$(error CONFIG_X86_CMPXCHG needs to be enabled in the kernel)
+endif
+endif
+
+# This needs to go before all other include paths.
+CC += -I$(DRMSRCDIR)
+
+# Check for PAGE_AGP definition
+PAGE_AGP := $(shell cat $(LINUXDIR)/include/asm/agp.h 2>/dev/null | \
+               grep -c PAGE_AGP)
+
+ifneq ($(PAGE_AGP),0)
+EXTRA_CFLAGS += -DHAVE_PAGE_AGP
+endif
+
+# Start with all modules turned off.
+CONFIG_DRM_GAMMA := n
+CONFIG_DRM_TDFX := n
+CONFIG_DRM_MGA := n
+CONFIG_DRM_I810 := n
+CONFIG_DRM_R128 := n
+CONFIG_DRM_RADEON := n
+CONFIG_DRM_I915 := n
+CONFIG_DRM_SIS := n
+CONFIG_DRM_FFB := n
+CONFIG_DRM_SAVAGE := n
+CONFIG_DRM_VIA := n
+CONFIG_DRM_MACH64 := n
+CONFIG_DRM_NV := n
+CONFIG_DRM_NOUVEAU := n
+CONFIG_DRM_PSB := n
+CONFIG_DRM_XGI := n
+
+# Enable module builds for the modules requested/supported.
+
+ifneq (,$(findstring tdfx,$(DRM_MODULES)))
+CONFIG_DRM_TDFX := m
+endif
+ifneq (,$(findstring r128,$(DRM_MODULES)))
+CONFIG_DRM_R128 := m
+endif
+ifneq (,$(findstring radeon,$(DRM_MODULES)))
+CONFIG_DRM_RADEON := m
+endif
+ifneq (,$(findstring sis,$(DRM_MODULES)))
+CONFIG_DRM_SIS := m
+endif
+ifneq (,$(findstring via,$(DRM_MODULES)))
+CONFIG_DRM_VIA := m
+endif
+ifneq (,$(findstring mach64,$(DRM_MODULES)))
+CONFIG_DRM_MACH64 := m
+endif
+ifneq (,$(findstring ffb,$(DRM_MODULES)))
+CONFIG_DRM_FFB := m
+endif
+ifneq (,$(findstring savage,$(DRM_MODULES)))
+CONFIG_DRM_SAVAGE := m
+endif
+ifneq (,$(findstring mga,$(DRM_MODULES)))
+CONFIG_DRM_MGA := m
+endif
+ifneq (,$(findstring nv,$(DRM_MODULES)))
+CONFIG_DRM_NV := m
+endif
+ifneq (,$(findstring nouveau,$(DRM_MODULES)))
+CONFIG_DRM_NOUVEAU := m
+endif
+ifneq (,$(findstring xgi,$(DRM_MODULES)))
+CONFIG_DRM_XGI := m
+endif
+
+# These require AGP support
+
+ifneq (,$(findstring i810,$(DRM_MODULES)))
+CONFIG_DRM_I810 := m
+endif
+ifneq (,$(findstring i915,$(DRM_MODULES)))
+CONFIG_DRM_I915 := m
+endif
+ifneq (,$(findstring psb,$(DRM_MODULES)))
+CONFIG_DRM_PSB := m
+endif
+include $(DRMSRCDIR)/Makefile.kernel
+
+# Depencencies
+$(drm-objs):   $(DRMHEADERS) $(COREHEADERS)
+$(tdfx-objs):  $(TDFXHEADERS)
+$(r128-objs):  $(R128HEADERS)
+$(mga-objs):   $(MGAHEADERS)
+$(i810-objs):  $(I810HEADERS)
+$(i915-objs):  $(I915HEADERS)
+$(radeon-objs):        $(RADEONHEADERS)
+$(sis-objs):   $(SISHEADERS)
+$(ffb-objs):   $(FFBHEADERS)
+$(savage-objs): $(SAVAGEHEADERS)
+$(via-objs):   $(VIAHEADERS)
+$(mach64-objs): $(MACH64HEADERS)
+$(nv-objs):     $(NVHEADERS)
+$(nouveau-objs): $(NOUVEAUHEADERS)
+$(psb-objs):   $(PSBHEADERS)
+$(xgi-objs):    $(XGIHEADERS)
+
+endif
+
diff --git a/psb-kernel-source-4.41.1/Makefile.kernel b/psb-kernel-source-4.41.1/Makefile.kernel
new file mode 100644 (file)
index 0000000..702bf28
--- /dev/null
@@ -0,0 +1,76 @@
+#
+# Makefile for the drm device driver.  This driver provides support for the
+# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
+#
+# Based on David Woodhouse's mtd build.
+#
+# $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/kernel/Makefile.kernel,v 1.18 2003/08/16 17:59:17 dawes Exp $
+#
+
+drm-objs    := drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \
+               drm_drv.o drm_fops.o drm_ioctl.o drm_irq.o \
+               drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
+               drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \
+               drm_memory_debug.o ati_pcigart.o drm_sman.o \
+               drm_hashtab.o drm_mm.o drm_object.o drm_compat.o \
+               drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_crtc.o \
+               drm_edid.o drm_modes.o drm_bo_lock.o drm_regman.o drm_vm_nopage_compat.o
+tdfx-objs   := tdfx_drv.o
+r128-objs   := r128_drv.o r128_cce.o r128_state.o r128_irq.o
+mga-objs    := mga_drv.o mga_dma.o mga_state.o mga_warp.o mga_irq.o
+i810-objs   := i810_drv.o i810_dma.o
+i915-objs   := i915_drv.o i915_dma.o i915_irq.o i915_mem.o i915_fence.o \
+               i915_buffer.o intel_setup.o intel_i2c.o i915_init.o intel_fb.o \
+               i915_compat.o
+nouveau-objs := nouveau_drv.o nouveau_state.o nouveau_fifo.o nouveau_mem.o \
+               nouveau_object.o nouveau_irq.o nouveau_notifier.o nouveau_swmthd.o \
+               nouveau_sgdma.o nouveau_dma.o nouveau_buffer.o nouveau_fence.o \
+               nv04_timer.o \
+               nv04_mc.o nv40_mc.o nv50_mc.o \
+               nv04_fb.o nv10_fb.o nv40_fb.o \
+               nv04_fifo.o nv10_fifo.o nv40_fifo.o nv50_fifo.o \
+               nv04_graph.o nv10_graph.o nv20_graph.o \
+               nv40_graph.o nv50_graph.o \
+               nv04_instmem.o nv50_instmem.o
+radeon-objs := radeon_drv.o radeon_cp.o radeon_state.o radeon_mem.o radeon_irq.o r300_cmdbuf.o radeon_fence.o radeon_buffer.o
+sis-objs    := sis_drv.o sis_mm.o
+ffb-objs    := ffb_drv.o ffb_context.o
+savage-objs := savage_drv.o savage_bci.o savage_state.o
+via-objs    := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o \
+               via_video.o via_dmablit.o via_fence.o via_buffer.o
+mach64-objs := mach64_drv.o mach64_dma.o mach64_irq.o mach64_state.o
+nv-objs := nv_drv.o
+psb-objs    := psb_drv.o psb_mmu.o psb_sgx.o psb_irq.o psb_fence.o \
+               psb_buffer.o psb_gtt.o psb_setup.o psb_i2c.o psb_fb.o \
+               psb_schedule.o psb_scene.o psb_reset.o \
+               psb_regman.o psb_xhw.o psb_msvdx.o psb_msvdxinit.o \
+               psb_detear.o
+xgi-objs    := xgi_cmdlist.o xgi_drv.o xgi_fb.o xgi_misc.o xgi_pcie.o \
+               xgi_fence.o
+
+ifeq ($(CONFIG_COMPAT),y)
+drm-objs    += drm_ioc32.o
+radeon-objs += radeon_ioc32.o
+mga-objs    += mga_ioc32.o
+r128-objs   += r128_ioc32.o
+i915-objs   += i915_ioc32.o
+nouveau-objs += nouveau_ioc32.o
+xgi-objs    += xgi_ioc32.o
+endif
+
+obj-m                  += drm.o
+obj-$(CONFIG_DRM_TDFX) += tdfx.o
+obj-$(CONFIG_DRM_R128) += r128.o
+obj-$(CONFIG_DRM_RADEON)+= radeon.o
+obj-$(CONFIG_DRM_MGA)  += mga.o
+obj-$(CONFIG_DRM_I810) += i810.o
+obj-$(CONFIG_DRM_I915) += i915.o
+obj-$(CONFIG_DRM_SIS)   += sis.o
+obj-$(CONFIG_DRM_FFB)   += ffb.o
+obj-$(CONFIG_DRM_SAVAGE)+= savage.o
+obj-$(CONFIG_DRM_VIA)   += via.o
+obj-$(CONFIG_DRM_MACH64)+= mach64.o
+obj-$(CONFIG_DRM_NV)    += nv.o
+obj-$(CONFIG_DRM_NOUVEAU) += nouveau.o
+obj-$(CONFIG_DRM_PSB)   += psb.o
+obj-$(CONFIG_DRM_XGI)   += xgi.o
diff --git a/psb-kernel-source-4.41.1/Module.markers b/psb-kernel-source-4.41.1/Module.markers
new file mode 100644 (file)
index 0000000..e69de29
diff --git a/psb-kernel-source-4.41.1/README.drm b/psb-kernel-source-4.41.1/README.drm
new file mode 100644 (file)
index 0000000..7bcd619
--- /dev/null
@@ -0,0 +1,25 @@
+************************************************************
+* For the very latest on DRI development, please see:      *
+*     http://dri.freedesktop.org/                          *
+************************************************************
+
+The Direct Rendering Manager (drm) is a device-independent kernel-level
+device driver that provides support for the XFree86 Direct Rendering
+Infrastructure (DRI).
+
+The DRM supports the Direct Rendering Infrastructure (DRI) in four major
+ways:
+
+    1. The DRM provides synchronized access to the graphics hardware via
+       the use of an optimized two-tiered lock.
+
+    2. The DRM enforces the DRI security policy for access to the graphics
+       hardware by only allowing authenticated X11 clients access to
+       restricted regions of memory.
+
+    3. The DRM provides a generic DMA engine, complete with multiple
+       queues and the ability to detect the need for an OpenGL context
+       switch.
+
+    4. The DRM is extensible via the use of small device-specific modules
+       that rely extensively on the API exported by the DRM module.
diff --git a/psb-kernel-source-4.41.1/ati_pcigart.c b/psb-kernel-source-4.41.1/ati_pcigart.c
new file mode 100644 (file)
index 0000000..5fafbb9
--- /dev/null
@@ -0,0 +1,411 @@
+/**
+ * \file ati_pcigart.c
+ * ATI PCI GART support
+ *
+ * \author Gareth Hughes <gareth@valinux.com>
+ */
+
+/*
+ * Created: Wed Dec 13 21:52:19 2000 by gareth@valinux.com
+ *
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "drmP.h"
+
+# define ATI_PCIGART_PAGE_SIZE         4096    /**< PCI GART page size */
+
+static __inline__ void insert_page_into_table(struct drm_ati_pcigart_info *info, u32 page_base, u32 *pci_gart)
+{
+       switch(info->gart_reg_if) {
+       case DRM_ATI_GART_IGP:
+               *pci_gart = cpu_to_le32((page_base) | 0xc);
+               break;
+       case DRM_ATI_GART_PCIE:
+               *pci_gart = cpu_to_le32((page_base >> 8) | 0xc);
+               break;
+       default:
+       case DRM_ATI_GART_PCI:
+               *pci_gart = cpu_to_le32(page_base);
+               break;
+       }
+}
+
+static __inline__ u32 get_page_base_from_table(struct drm_ati_pcigart_info *info, u32 *pci_gart)
+{
+       u32 retval;
+       switch(info->gart_reg_if) {
+       case DRM_ATI_GART_IGP:
+               retval = *pci_gart;
+               retval &= ~0xc;
+               break;
+       case DRM_ATI_GART_PCIE:
+               retval = *pci_gart;
+               retval &= ~0xc;
+               retval <<= 8;
+               break;
+       default:
+       case DRM_ATI_GART_PCI:
+               retval = *pci_gart;
+               break;
+       }
+       return retval;
+}
+
+
+
+static void *drm_ati_alloc_pcigart_table(int order)
+{
+       unsigned long address;
+       struct page *page;
+       int i;
+
+       DRM_DEBUG("%s: alloc %d order\n", __FUNCTION__, order);
+
+       address = __get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                  order);
+       if (address == 0UL) {
+               return NULL;
+       }
+
+       page = virt_to_page(address);
+
+       for (i = 0; i < order; i++, page++) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
+               get_page(page);
+#endif
+               SetPageReserved(page);
+       }
+
+       DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address);
+       return (void *)address;
+}
+
+static void drm_ati_free_pcigart_table(void *address, int order)
+{
+       struct page *page;
+       int i;
+       int num_pages = 1 << order;
+       DRM_DEBUG("%s\n", __FUNCTION__);
+
+       page = virt_to_page((unsigned long)address);
+
+       for (i = 0; i < num_pages; i++, page++) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
+               __put_page(page);
+#endif
+               ClearPageReserved(page);
+       }
+
+       free_pages((unsigned long)address, order);
+}
+
+int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
+{
+       struct drm_sg_mem *entry = dev->sg;
+       unsigned long pages;
+       int i;
+       int order;
+       int num_pages, max_pages;
+
+       /* we need to support large memory configurations */
+       if (!entry) {
+               DRM_ERROR("no scatter/gather memory!\n");
+               return 0;
+       }
+
+       order = drm_order((gart_info->table_size + (PAGE_SIZE-1)) / PAGE_SIZE);
+       num_pages = 1 << order;
+
+       if (gart_info->bus_addr) {
+               if (gart_info->gart_table_location == DRM_ATI_GART_MAIN) {
+                       pci_unmap_single(dev->pdev, gart_info->bus_addr,
+                                        num_pages * PAGE_SIZE,
+                                        PCI_DMA_TODEVICE);
+               }
+
+               max_pages = (gart_info->table_size / sizeof(u32));
+               pages = (entry->pages <= max_pages)
+                 ? entry->pages : max_pages;
+
+               for (i = 0; i < pages; i++) {
+                       if (!entry->busaddr[i])
+                               break;
+                       pci_unmap_single(dev->pdev, entry->busaddr[i],
+                                        PAGE_SIZE, PCI_DMA_TODEVICE);
+               }
+
+               if (gart_info->gart_table_location == DRM_ATI_GART_MAIN)
+                       gart_info->bus_addr = 0;
+       }
+
+
+       if (gart_info->gart_table_location == DRM_ATI_GART_MAIN
+           && gart_info->addr) {
+
+               drm_ati_free_pcigart_table(gart_info->addr, order);
+               gart_info->addr = NULL;
+       }
+
+       return 1;
+}
+EXPORT_SYMBOL(drm_ati_pcigart_cleanup);
+
+int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
+{
+       struct drm_sg_mem *entry = dev->sg;
+       void *address = NULL;
+       unsigned long pages;
+       u32 *pci_gart, page_base, bus_address = 0;
+       int i, j, ret = 0;
+       int order;
+       int max_pages;
+       int num_pages;
+
+       if (!entry) {
+               DRM_ERROR("no scatter/gather memory!\n");
+               goto done;
+       }
+
+       if (gart_info->gart_table_location == DRM_ATI_GART_MAIN) {
+               DRM_DEBUG("PCI: no table in VRAM: using normal RAM\n");
+
+               order = drm_order((gart_info->table_size +
+                                  (PAGE_SIZE-1)) / PAGE_SIZE);
+               num_pages = 1 << order;
+               address = drm_ati_alloc_pcigart_table(order);
+               if (!address) {
+                       DRM_ERROR("cannot allocate PCI GART page!\n");
+                       goto done;
+               }
+
+               if (!dev->pdev) {
+                       DRM_ERROR("PCI device unknown!\n");
+                       goto done;
+               }
+
+               bus_address = pci_map_single(dev->pdev, address,
+                                            num_pages * PAGE_SIZE,
+                                            PCI_DMA_TODEVICE);
+               if (bus_address == 0) {
+                       DRM_ERROR("unable to map PCIGART pages!\n");
+                       order = drm_order((gart_info->table_size +
+                                          (PAGE_SIZE-1)) / PAGE_SIZE);
+                       drm_ati_free_pcigart_table(address, order);
+                       address = NULL;
+                       goto done;
+               }
+       } else {
+               address = gart_info->addr;
+               bus_address = gart_info->bus_addr;
+               DRM_DEBUG("PCI: Gart Table: VRAM %08X mapped at %08lX\n",
+                         bus_address, (unsigned long)address);
+       }
+
+       pci_gart = (u32 *) address;
+
+       max_pages = (gart_info->table_size / sizeof(u32));
+       pages = (entry->pages <= max_pages)
+           ? entry->pages : max_pages;
+
+       memset(pci_gart, 0, max_pages * sizeof(u32));
+
+       for (i = 0; i < pages; i++) {
+               /* we need to support large memory configurations */
+               entry->busaddr[i] = pci_map_single(dev->pdev,
+                                                  page_address(entry->
+                                                               pagelist[i]),
+                                                  PAGE_SIZE, PCI_DMA_TODEVICE);
+               if (entry->busaddr[i] == 0) {
+                       DRM_ERROR("unable to map PCIGART pages!\n");
+                       drm_ati_pcigart_cleanup(dev, gart_info);
+                       address = NULL;
+                       bus_address = 0;
+                       goto done;
+               }
+               page_base = (u32) entry->busaddr[i];
+
+               for (j = 0; j < (PAGE_SIZE / ATI_PCIGART_PAGE_SIZE); j++) {
+                       insert_page_into_table(gart_info, page_base, pci_gart);
+                       pci_gart++;
+                       page_base += ATI_PCIGART_PAGE_SIZE;
+               }
+       }
+
+       ret = 1;
+
+#if defined(__i386__) || defined(__x86_64__)
+       wbinvd();
+#else
+       mb();
+#endif
+
+      done:
+       gart_info->addr = address;
+       gart_info->bus_addr = bus_address;
+       return ret;
+}
+EXPORT_SYMBOL(drm_ati_pcigart_init);
+
+static int ati_pcigart_needs_unbind_cache_adjust(struct drm_ttm_backend *backend)
+{
+       return ((backend->flags & DRM_BE_FLAG_BOUND_CACHED) ? 0 : 1);
+}
+
+static int ati_pcigart_populate(struct drm_ttm_backend *backend,
+                               unsigned long num_pages,
+                               struct page **pages)
+{
+       ati_pcigart_ttm_backend_t *atipci_be =
+               container_of(backend, ati_pcigart_ttm_backend_t, backend);
+
+       DRM_ERROR("%ld\n", num_pages);
+       atipci_be->pages = pages;
+       atipci_be->num_pages = num_pages;
+       atipci_be->populated = 1;
+       return 0;
+}
+
+static int ati_pcigart_bind_ttm(struct drm_ttm_backend *backend,
+                               struct drm_bo_mem_reg *bo_mem)
+{
+       ati_pcigart_ttm_backend_t *atipci_be =
+               container_of(backend, ati_pcigart_ttm_backend_t, backend);
+        off_t j;
+       int i;
+       struct drm_ati_pcigart_info *info = atipci_be->gart_info;
+       u32 *pci_gart;
+       u32 page_base;
+       unsigned long offset = bo_mem->mm_node->start;
+       pci_gart = info->addr;
+
+       DRM_ERROR("Offset is %08lX\n", bo_mem->mm_node->start);
+        j = offset;
+        while (j < (offset + atipci_be->num_pages)) {
+               if (get_page_base_from_table(info, pci_gart+j))
+                       return -EBUSY;
+                j++;
+        }
+
+        for (i = 0, j = offset; i < atipci_be->num_pages; i++, j++) {
+               struct page *cur_page = atipci_be->pages[i];
+                /* write value */
+               page_base = page_to_phys(cur_page);
+               insert_page_into_table(info, page_base, pci_gart + j);
+        }
+
+#if defined(__i386__) || defined(__x86_64__)
+       wbinvd();
+#else
+       mb();
+#endif
+
+       atipci_be->gart_flush_fn(atipci_be->dev);
+
+       atipci_be->bound = 1;
+       atipci_be->offset = offset;
+        /* need to traverse table and add entries */
+       DRM_DEBUG("\n");
+       return 0;
+}
+
+static int ati_pcigart_unbind_ttm(struct drm_ttm_backend *backend)
+{
+       ati_pcigart_ttm_backend_t *atipci_be =
+               container_of(backend, ati_pcigart_ttm_backend_t, backend);
+       struct drm_ati_pcigart_info *info = atipci_be->gart_info;       
+       unsigned long offset = atipci_be->offset;
+       int i;
+       off_t j;
+       u32 *pci_gart = info->addr;
+
+       DRM_DEBUG("\n");
+
+       if (atipci_be->bound != 1)
+               return -EINVAL;
+
+       for (i = 0, j = offset; i < atipci_be->num_pages; i++, j++) {
+               *(pci_gart + j) = 0;
+       }
+       atipci_be->gart_flush_fn(atipci_be->dev);
+       atipci_be->bound = 0;
+       atipci_be->offset = 0;
+       return 0;
+}
+
+static void ati_pcigart_clear_ttm(struct drm_ttm_backend *backend)
+{
+       ati_pcigart_ttm_backend_t *atipci_be =
+               container_of(backend, ati_pcigart_ttm_backend_t, backend);
+
+       DRM_DEBUG("\n");        
+       if (atipci_be->pages) {
+               backend->func->unbind(backend);
+               atipci_be->pages = NULL;
+
+       }
+       atipci_be->num_pages = 0;
+}
+
+static void ati_pcigart_destroy_ttm(struct drm_ttm_backend *backend)
+{
+       ati_pcigart_ttm_backend_t *atipci_be;
+       if (backend) {
+               DRM_DEBUG("\n");
+               atipci_be = container_of(backend, ati_pcigart_ttm_backend_t, backend);
+               if (atipci_be) {
+                       if (atipci_be->pages) {
+                               backend->func->clear(backend);
+                       }
+                       drm_ctl_free(atipci_be, sizeof(*atipci_be), DRM_MEM_TTM);
+               }
+       }
+}
+
+static struct drm_ttm_backend_func ati_pcigart_ttm_backend = 
+{
+       .needs_ub_cache_adjust = ati_pcigart_needs_unbind_cache_adjust,
+       .populate = ati_pcigart_populate,
+       .clear = ati_pcigart_clear_ttm,
+       .bind = ati_pcigart_bind_ttm,
+       .unbind = ati_pcigart_unbind_ttm,
+       .destroy =  ati_pcigart_destroy_ttm,
+};
+
+struct drm_ttm_backend *ati_pcigart_init_ttm(struct drm_device *dev, struct drm_ati_pcigart_info *info, void (*gart_flush_fn)(struct drm_device *dev))
+{
+       ati_pcigart_ttm_backend_t *atipci_be;
+
+       atipci_be = drm_ctl_calloc(1, sizeof (*atipci_be), DRM_MEM_TTM);
+       if (!atipci_be)
+               return NULL;
+       
+       atipci_be->populated = 0;
+       atipci_be->backend.func = &ati_pcigart_ttm_backend;
+       atipci_be->gart_info = info;
+       atipci_be->gart_flush_fn = gart_flush_fn;
+       atipci_be->dev = dev;
+
+       return &atipci_be->backend;
+}
+EXPORT_SYMBOL(ati_pcigart_init_ttm);
diff --git a/psb-kernel-source-4.41.1/build.sh b/psb-kernel-source-4.41.1/build.sh
new file mode 100755 (executable)
index 0000000..af62546
--- /dev/null
@@ -0,0 +1 @@
+LINUXDIR=/home/pinebud/android/android-x86/out/target/product/s5/obj/kernel DRM_MODULES=psb make
diff --git a/psb-kernel-source-4.41.1/create_linux_pci_lists.sh b/psb-kernel-source-4.41.1/create_linux_pci_lists.sh
new file mode 100644 (file)
index 0000000..bb0e687
--- /dev/null
@@ -0,0 +1,40 @@
+#! /bin/bash 
+#
+# Script to output Linux compatible pci ids file
+#  - Copyright Dave Airlie 2004 (airlied@linux.ie)
+#
+OUTFILE=drm_pciids.h
+
+finished=0
+
+cat > $OUTFILE <<EOF
+/*
+   This file is auto-generated from the drm_pciids.txt in the DRM CVS
+   Please contact dri-devel@lists.sf.net to add new cards to this list
+*/
+EOF
+
+while read pcivend pcidev attribs pciname
+do
+       if [ "x$pcivend" = "x" ]; then
+               if [ "$finished" = "0" ]; then
+                       finished=1
+                       echo "  {0, 0, 0}" >> $OUTFILE
+                       echo >> $OUTFILE
+               fi
+       else
+       
+               cardtype=`echo "$pcivend" | cut -s -f2 -d'[' | cut -s -f1 -d']'`
+               if [ "x$cardtype" = "x" ];
+               then
+                       echo "  {$pcivend, $pcidev, PCI_ANY_ID, PCI_ANY_ID, 0, 0, $attribs}, \\" >> $OUTFILE
+               else
+                       echo "#define "$cardtype"_PCI_IDS \\" >> $OUTFILE
+                       finished=0
+               fi
+       fi
+done
+
+if [ "$finished" = "0" ]; then
+       echo "  {0, 0, 0}" >> $OUTFILE
+fi
diff --git a/psb-kernel-source-4.41.1/debian/changelog b/psb-kernel-source-4.41.1/debian/changelog
new file mode 100644 (file)
index 0000000..554e8f4
--- /dev/null
@@ -0,0 +1,5 @@
+psb-kernel-source (4.41.1-0ubuntu1~904um1) jaunty; urgency=low
+
+  * Initial package for Jaunty, utilising DKMS.
+
+ -- Steve Kowalik <stevenk@ubuntu.com>  Thu, 25 Jun 2009 11:44:04 +1000
diff --git a/psb-kernel-source-4.41.1/debian/compat b/psb-kernel-source-4.41.1/debian/compat
new file mode 100644 (file)
index 0000000..7f8f011
--- /dev/null
@@ -0,0 +1 @@
+7
diff --git a/psb-kernel-source-4.41.1/debian/control b/psb-kernel-source-4.41.1/debian/control
new file mode 100644 (file)
index 0000000..58d11cf
--- /dev/null
@@ -0,0 +1,26 @@
+Source: psb-kernel-source
+Section: misc
+Priority: optional
+Maintainer: Ubuntu Mobile Developers <ubuntu-mobile@lists.ubuntu.com>
+XSBC-Original-Maintainer: Waldo Bastian <waldo.bastian@intel.com>
+Build-Depends: debhelper (>= 7), dpatch, linux-headers-generic [i386 amd64], linux-headers-lpia [lpia]
+Standards-Version: 3.8.0
+
+Package: psb-kernel-source
+Architecture: all
+Depends: dkms, make
+Description: Kernel module for the Poulsbo (psb) 2D X11 driver
+ This package contains the source for the Poulsbo (psb) 2D X11 driver, and 
+ hooks to use DKMS to build it on install.
+
+Package: psb-kernel-headers
+Architecture: all
+Description: Kernel module headers for the Poulsbo (psb) 2D X11 driver
+ This package contains the kernel headers for the Poulsbo (psb) 2D X11 driver.
+
+Package: psb-modules
+Architecture: any
+Depends: linux-generic [i386 amd64], linux-lpia [lpia]
+Description: Kernel module built for -generic or -lpia kernel
+ This package provides the psb kernel module for the -generic or -lpia kernel.
+
diff --git a/psb-kernel-source-4.41.1/debian/copyright b/psb-kernel-source-4.41.1/debian/copyright
new file mode 100644 (file)
index 0000000..f66d5bf
--- /dev/null
@@ -0,0 +1,53 @@
+Upstream Author(s): 
+
+    Intel Corporation, http://www.intel.com
+
+Copyright: 
+
+    Copyright (c) 1997-2003 by The XFree86 Project, Inc.
+    Copyright (c) 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
+    Copyright (c) 2000-2001 VA Linux Systems, Inc., Sunnyvale, California.
+    Copyright (c) 2002-2003, 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA
+    Copyright (c) 2003 Jos�Fonseca.
+    Copyright (c) 2003 Leif Delgass.
+    Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com>
+    Copyright (c) 2003-2004 IBM Corp.
+    Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com>
+    Copyright (c) 2005 Alan Hourihane
+    Copyright (c) 2005 Paul Mackerras
+    Copyright (c) 2005-2007 Imagination Technologies Limited, UK
+    Copyright (c) 2006 Dennis Munsie <dmunsie@cecropia.com>
+    Copyright (c) 2006 Keith Packard
+    Copyright (c) 2006-2007 Dave Airlie <airlied@linux.ie>
+    Copyright (c) 2006-2008 Intel Corporation
+
+License:
+
+    All Rights Reserved.
+    
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+    
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+
+On Debian systems, the complete text of the GNU General
+Public License can be found in `/usr/share/common-licenses/GPL-2'.
+
+The Debian packaging is (C) Canonical Ltd, is under the terms of the GPL,
+version 2.
+
diff --git a/psb-kernel-source-4.41.1/debian/dirs b/psb-kernel-source-4.41.1/debian/dirs
new file mode 100644 (file)
index 0000000..b601f22
--- /dev/null
@@ -0,0 +1 @@
+usr/src
diff --git a/psb-kernel-source-4.41.1/debian/dkms.conf.in b/psb-kernel-source-4.41.1/debian/dkms.conf.in
new file mode 100644 (file)
index 0000000..ef78d69
--- /dev/null
@@ -0,0 +1,9 @@
+PACKAGE_NAME="psb-kernel-source"
+PACKAGE_VERSION="#VERSION#"
+CLEAN="make clean"
+BUILT_MODULE_NAME[0]="psb"
+BUILT_MODULE_LOCATION[0]="."
+DEST_MODULE_LOCATION[0]="/kernel/../updates/char/drm"
+BUILT_MODULE_NAME[1]="drm"
+DEST_MODULE_LOCATION[1]="/kernel/../updates/char/drm"
+MAKE[0]="make LINUXDIR=/lib/modules/$kernelver/build DRM_MODULES=psb"
diff --git a/psb-kernel-source-4.41.1/debian/patches/00list b/psb-kernel-source-4.41.1/debian/patches/00list
new file mode 100644 (file)
index 0000000..942477e
--- /dev/null
@@ -0,0 +1 @@
+use_udev
diff --git a/psb-kernel-source-4.41.1/debian/patches/use_udev.dpatch b/psb-kernel-source-4.41.1/debian/patches/use_udev.dpatch
new file mode 100644 (file)
index 0000000..f19bead
--- /dev/null
@@ -0,0 +1,36 @@
+#! /bin/sh /usr/share/dpatch/dpatch-run
+## use_udev_for_the_love_of_god.patch.dpatch by Steve Kowalik <stevenk@ubuntu.com>
+##
+## All lines beginning with `## DP:' are a description of the patch.
+## DP: Use udev!!
+
+@DPATCH@
+diff -urNad psb-kernel-source-4.37~/drm_sysfs.c psb-kernel-source-4.37/drm_sysfs.c
+--- psb-kernel-source-4.37~/drm_sysfs.c        2009-04-17 18:35:58.000000000 +1000
++++ psb-kernel-source-4.37/drm_sysfs.c 2009-04-17 18:52:59.000000000 +1000
+@@ -167,7 +167,7 @@
+        * will create the device node.  We don't want to do that just
+        * yet...
+        */
+-      /* dev->dev.devt = head->device; */
++      dev->dev.devt = head->device;
+       snprintf(dev->dev.bus_id, BUS_ID_SIZE, "card%d", head->minor);
+       err = device_register(&dev->dev);
+@@ -176,7 +176,7 @@
+               goto err_out;
+       }
+-      for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
++/*    for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
+               err = device_create_file(&dev->dev, &device_attrs[i]);
+               if (err)
+                       goto err_out_files;
+@@ -189,6 +189,7 @@
+               for (j = 0; j < i; j++)
+                       device_remove_file(&dev->dev, &device_attrs[i]);
+       device_unregister(&dev->dev);
++*/
+ err_out:
+       return err;
diff --git a/psb-kernel-source-4.41.1/debian/postinst b/psb-kernel-source-4.41.1/debian/postinst
new file mode 100644 (file)
index 0000000..200c9c3
--- /dev/null
@@ -0,0 +1,73 @@
+#!/bin/sh
+
+set -e
+
+NAME=psb-kernel-source
+VERSION=$(dpkg-query -W -f='${Version}' $NAME | awk -F "-" '{print $1}' | cut -d\: -f2)
+
+case "$1" in
+    configure)
+      # Determine current arch / kernel
+      c_arch=`uname -m`
+      c_kern=`uname -r`
+
+      if [ -e "/var/lib/dkms/$NAME/$VERSION" ]; then
+         echo "Removing old $NAME-$VERSION DKMS files..."
+         dkms remove -m $NAME -v $VERSION --all
+      fi
+
+      echo "Loading new $NAME-$VERSION DKMS files..."
+      if [ -f "/usr/src/$NAME-$VERSION.dkms.tar.gz" ]; then
+          dkms ldtarball --archive "/usr/src/$NAME-$VERSION.dkms.tar.gz"
+      else
+          dkms add -m $NAME -v $VERSION
+      fi
+
+      echo "Installing prebuilt kernel module binaries (if any)"
+      set +e
+      IFS='
+'
+      for kern in `dkms status -m $NAME -v $VERSION -a $c_arch | grep ": built" | awk {'print $3'} | sed 's/,$//'`; do
+         echo "Trying kernel: $kern"
+         dkms install --force -m $NAME -v $VERSION -k $kern -a $c_arch
+      done
+      unset IFS
+      set -e
+
+      # If none installed, install.
+      ##if [ `dkms status -m $NAME -v $VERSION -k $c_kern -a $c_arch | grep -c ": installed"` -eq 0 ]; then
+      dkms_status=`dkms status -m $NAME -v $VERSION -k $c_kern -a $c_arch`
+      if [ `echo $dkms_status | grep -c ": installed"` -eq 0 ]; then
+         if [ `echo $c_kern | grep -c "BOOT"` -eq 0 ] && [ -e "/lib/modules/$c_kern/build/include" ]; then
+            # Only build if we need to.
+            if [ `echo $dkms_status | grep -c ": built"` -eq 0 ]; then
+               echo "Building module..."
+               dkms build -m $NAME -v $VERSION
+            fi
+            echo "Installing module..."
+            dkms install -m $NAME -v $VERSION
+         elif [ `echo $c_kern | grep -c "BOOT"` -gt 0 ]; then
+            echo ""
+            echo "Module build for the currently running kernel was skipped since you"
+            echo "are running a BOOT variant of the kernel."
+         else
+            echo ""
+            echo "Module build for the currently running kernel was skipped since the"
+            echo "kernel source for this kernel does not seem to be installed."
+         fi
+      fi
+    ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+#DEBHELPER#
+
+exit 0
+
diff --git a/psb-kernel-source-4.41.1/debian/postrm b/psb-kernel-source-4.41.1/debian/postrm
new file mode 100644 (file)
index 0000000..edd4db6
--- /dev/null
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -e
+
+NAME=psb-kernel-source
+VERSION=$(dpkg-query -W -f='${Version}' $NAME | awk -F "-" '{print $1}' | cut -d\: -f2)
+
+case "$1" in
+    purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
+               moddir="/lib/modules/`uname -r`/kernel/"
+      depmod
+      if [ -d "/usr/src/$NAME-$VERSION" ]; then
+         echo "Removing old module source..."
+         rm -rf "/usr/src/$NAME-$VERSION"
+      fi
+    ;;
+
+    *)
+        echo "postrm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+#DEBHELPER#
+
+exit 0
+
diff --git a/psb-kernel-source-4.41.1/debian/prerm b/psb-kernel-source-4.41.1/debian/prerm
new file mode 100644 (file)
index 0000000..b9bf3cf
--- /dev/null
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+set -e
+
+NAME=psb-kernel-source
+VERSION=$(dpkg-query -W -f='${Version}' $NAME | awk -F "-" '{print $1}' | cut -d\: -f2)
+
+case "$1" in
+    remove|upgrade|deconfigure)
+      if [  "`dkms status -m $NAME`" ]; then
+         dkms remove -m $NAME -v $VERSION --all
+      fi
+    ;;
+
+    failed-upgrade)
+    ;;
+
+    *)
+        echo "prerm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+#DEBHELPER#
+
+exit 0
+
+
diff --git a/psb-kernel-source-4.41.1/debian/psb-kernel-headers.dirs b/psb-kernel-source-4.41.1/debian/psb-kernel-headers.dirs
new file mode 100644 (file)
index 0000000..65c6f0d
--- /dev/null
@@ -0,0 +1 @@
+usr/include/drm
diff --git a/psb-kernel-source-4.41.1/debian/psb-kernel-headers.install b/psb-kernel-source-4.41.1/debian/psb-kernel-headers.install
new file mode 100644 (file)
index 0000000..6da797a
--- /dev/null
@@ -0,0 +1 @@
+*.h /usr/include/drm
diff --git a/psb-kernel-source-4.41.1/debian/psb-kernel-headers.postrm b/psb-kernel-source-4.41.1/debian/psb-kernel-headers.postrm
new file mode 100644 (file)
index 0000000..02edd5a
--- /dev/null
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+case "$1" in
+    remove|purge)
+        for file in drm_sarea.h drm.h drm_hashtab.h i915_drm.h; do
+            dpkg-divert --remove --rename /usr/include/drm/$file
+        done
+       rm -f /usr/include/drm-linux-libc
+    ;;
+esac
+
+#DEBHELPER#
+
diff --git a/psb-kernel-source-4.41.1/debian/psb-kernel-headers.preinst b/psb-kernel-source-4.41.1/debian/psb-kernel-headers.preinst
new file mode 100644 (file)
index 0000000..fffbf79
--- /dev/null
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+set -e
+
+case "$1" in
+    install|upgrade)
+       if [ ! -d /usr/include/drm-linux-libc ]; then
+           mkdir /usr/include/drm-linux-libc
+       fi
+       for file in drm_sarea.h drm.h drm_hashtab.h i915_drm.h; do
+           dpkg-divert --add --rename --package psb-kernel-headers --divert \
+               /usr/include/drm-linux-libc/$file /usr/include/drm/$file
+       done
+    ;;
+esac
+
+#DEBHELPER#
+
diff --git a/psb-kernel-source-4.41.1/debian/rules b/psb-kernel-source-4.41.1/debian/rules
new file mode 100644 (file)
index 0000000..7b8621b
--- /dev/null
@@ -0,0 +1,38 @@
+#!/usr/bin/make -f
+
+include /usr/share/dpatch/dpatch.make
+
+DEB_NAME=psb-kernel-source
+VERSION := $(shell dpkg-parsechangelog | grep '^Version:' | cut -d' ' -f2 | cut -d- -f1 | cut -d\: -f2)
+KERNEL_VER := $(shell ls -1 /lib/modules)
+
+build: build-stamp
+build-stamp: patch
+       $(MAKE) LINUXDIR=/lib/modules/$(KERNEL_VER)/build DRM_MODULES="psb"
+       touch $@
+
+clean: clean-patched unpatch
+clean-patched:
+       dh clean
+
+install: build install-stamp
+install-stamp:
+       dh_clean -k
+       dh_installdirs
+       mkdir $(CURDIR)/debian/$(DEB_NAME)/usr/src/$(DEB_NAME)-$(VERSION)
+       cp *.c *.h Config.in Doxyfile *.txt Kconfig Makefile* Module.* \
+               modules.order README.drm create_linux_pci_lists.sh \
+               $(CURDIR)/debian/$(DEB_NAME)/usr/src/$(DEB_NAME)-$(VERSION)
+       cat debian/dkms.conf.in | sed -e "s/#VERSION#/$(VERSION)/" > \
+               $(CURDIR)/debian/$(DEB_NAME)/usr/src/$(DEB_NAME)-$(VERSION)/dkms.conf
+       mkdir -p $(CURDIR)/debian/psb-modules/lib/modules/$(KERNEL_VER)/updates/char/drm
+       cp psb.ko drm.ko $(CURDIR)/debian/psb-modules/lib/modules/$(KERNEL_VER)/updates/char/drm
+       touch $@
+
+binary-arch: install-stamp
+       dh $@
+
+binary-indep: install-stamp
+       dh $@
+
+binary: binary-arch binary-indep
diff --git a/psb-kernel-source-4.41.1/drm.h b/psb-kernel-source-4.41.1/drm.h
new file mode 100644 (file)
index 0000000..bd4df10
--- /dev/null
@@ -0,0 +1,1192 @@
+/**
+ * \file drm.h
+ * Header for the Direct Rendering Manager
+ *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * \par Acknowledgments:
+ * Dec 1999, Richard Henderson <rth@twiddle.net>, move to generic \c cmpxchg.
+ */
+
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \mainpage
+ *
+ * The Direct Rendering Manager (DRM) is a device-independent kernel-level
+ * device driver that provides support for the XFree86 Direct Rendering
+ * Infrastructure (DRI).
+ *
+ * The DRM supports the Direct Rendering Infrastructure (DRI) in four major
+ * ways:
+ *     -# The DRM provides synchronized access to the graphics hardware via
+ *        the use of an optimized two-tiered lock.
+ *     -# The DRM enforces the DRI security policy for access to the graphics
+ *        hardware by only allowing authenticated X11 clients access to
+ *        restricted regions of memory.
+ *     -# The DRM provides a generic DMA engine, complete with multiple
+ *        queues and the ability to detect the need for an OpenGL context
+ *        switch.
+ *     -# The DRM is extensible via the use of small device-specific modules
+ *        that rely extensively on the API exported by the DRM module.
+ *
+ */
+
+#ifndef _DRM_H_
+#define _DRM_H_
+
+#ifndef __user
+#define __user
+#endif
+#ifndef __iomem
+#define __iomem
+#endif
+
+#ifdef __GNUC__
+# define DEPRECATED  __attribute__ ((deprecated))
+#else
+# define DEPRECATED
+#endif
+
+#if defined(__linux__)
+#include <asm/ioctl.h>         /* For _IO* macros */
+#define DRM_IOCTL_NR(n)                _IOC_NR(n)
+#define DRM_IOC_VOID           _IOC_NONE
+#define DRM_IOC_READ           _IOC_READ
+#define DRM_IOC_WRITE          _IOC_WRITE
+#define DRM_IOC_READWRITE      _IOC_READ|_IOC_WRITE
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+#include <sys/ioccom.h>
+#define DRM_IOCTL_NR(n)                ((n) & 0xff)
+#define DRM_IOC_VOID           IOC_VOID
+#define DRM_IOC_READ           IOC_OUT
+#define DRM_IOC_WRITE          IOC_IN
+#define DRM_IOC_READWRITE      IOC_INOUT
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#endif
+
+#ifdef __OpenBSD__
+#define DRM_MAJOR       81
+#endif
+#if defined(__linux__) || defined(__NetBSD__)
+#define DRM_MAJOR       226
+#endif
+#define DRM_MAX_MINOR   15
+
+#define DRM_NAME       "drm"     /**< Name in kernel, /dev, and /proc */
+#define DRM_MIN_ORDER  5         /**< At least 2^5 bytes = 32 bytes */
+#define DRM_MAX_ORDER  22        /**< Up to 2^22 bytes = 4MB */
+#define DRM_RAM_PERCENT 10       /**< How much system ram can we lock? */
+
+#define _DRM_LOCK_HELD 0x80000000U /**< Hardware lock is held */
+#define _DRM_LOCK_CONT 0x40000000U /**< Hardware lock is contended */
+#define _DRM_LOCK_IS_HELD(lock)           ((lock) & _DRM_LOCK_HELD)
+#define _DRM_LOCK_IS_CONT(lock)           ((lock) & _DRM_LOCK_CONT)
+#define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
+
+#if defined(__linux__)
+typedef unsigned int drm_handle_t;
+#else
+#include <sys/types.h>
+typedef unsigned long drm_handle_t;    /**< To mapped regions */
+#endif
+typedef unsigned int drm_context_t;    /**< GLXContext handle */
+typedef unsigned int drm_drawable_t;
+typedef unsigned int drm_magic_t;      /**< Magic for authentication */
+
+/**
+ * Cliprect.
+ *
+ * \warning If you change this structure, make sure you change
+ * XF86DRIClipRectRec in the server as well
+ *
+ * \note KW: Actually it's illegal to change either for
+ * backwards-compatibility reasons.
+ */
+struct drm_clip_rect {
+       unsigned short x1;
+       unsigned short y1;
+       unsigned short x2;
+       unsigned short y2;
+};
+
+/**
+ * Texture region,
+ */
+struct drm_tex_region {
+       unsigned char next;
+       unsigned char prev;
+       unsigned char in_use;
+       unsigned char padding;
+       unsigned int age;
+};
+
+/**
+ * Hardware lock.
+ *
+ * The lock structure is a simple cache-line aligned integer.  To avoid
+ * processor bus contention on a multiprocessor system, there should not be any
+ * other data stored in the same cache line.
+ */
+struct drm_hw_lock {
+       __volatile__ unsigned int lock;         /**< lock variable */
+       char padding[60];                       /**< Pad to cache line */
+};
+
+/* This is beyond ugly, and only works on GCC.  However, it allows me to use
+ * drm.h in places (i.e., in the X-server) where I can't use size_t.  The real
+ * fix is to use uint32_t instead of size_t, but that fix will break existing
+ * LP64 (i.e., PowerPC64, SPARC64, IA-64, Alpha, etc.) systems.  That *will*
+ * eventually happen, though.  I chose 'unsigned long' to be the fallback type
+ * because that works on all the platforms I know about.  Hopefully, the
+ * real fix will happen before that bites us.
+ */
+
+#ifdef __SIZE_TYPE__
+# define DRM_SIZE_T __SIZE_TYPE__
+#else
+# warning "__SIZE_TYPE__ not defined.  Assuming sizeof(size_t) == sizeof(unsigned long)!"
+# define DRM_SIZE_T unsigned long
+#endif
+
+/**
+ * DRM_IOCTL_VERSION ioctl argument type.
+ *
+ * \sa drmGetVersion().
+ */
+struct drm_version {
+       int version_major;        /**< Major version */
+       int version_minor;        /**< Minor version */
+       int version_patchlevel;   /**< Patch level */
+       DRM_SIZE_T name_len;      /**< Length of name buffer */
+       char __user *name;                /**< Name of driver */
+       DRM_SIZE_T date_len;      /**< Length of date buffer */
+       char __user *date;                /**< User-space buffer to hold date */
+       DRM_SIZE_T desc_len;      /**< Length of desc buffer */
+       char __user *desc;                /**< User-space buffer to hold desc */
+};
+
+/**
+ * DRM_IOCTL_GET_UNIQUE ioctl argument type.
+ *
+ * \sa drmGetBusid() and drmSetBusId().
+ */
+struct drm_unique {
+       DRM_SIZE_T unique_len;    /**< Length of unique */
+       char __user *unique;              /**< Unique name for driver instantiation */
+};
+
+#undef DRM_SIZE_T
+
+struct drm_list {
+       int count;                /**< Length of user-space structures */
+       struct drm_version __user *version;
+};
+
+struct drm_block {
+       int unused;
+};
+
+/**
+ * DRM_IOCTL_CONTROL ioctl argument type.
+ *
+ * \sa drmCtlInstHandler() and drmCtlUninstHandler().
+ */
+struct drm_control {
+       enum {
+               DRM_ADD_COMMAND,
+               DRM_RM_COMMAND,
+               DRM_INST_HANDLER,
+               DRM_UNINST_HANDLER
+       } func;
+       int irq;
+};
+
+/**
+ * Type of memory to map.
+ */
+enum drm_map_type {
+       _DRM_FRAME_BUFFER = 0,    /**< WC (no caching), no core dump */
+       _DRM_REGISTERS = 1,       /**< no caching, no core dump */
+       _DRM_SHM = 2,             /**< shared, cached */
+       _DRM_AGP = 3,             /**< AGP/GART */
+       _DRM_SCATTER_GATHER = 4,  /**< Scatter/gather memory for PCI DMA */
+       _DRM_CONSISTENT = 5,      /**< Consistent memory for PCI DMA */
+       _DRM_TTM = 6
+};
+
+/**
+ * Memory mapping flags.
+ */
+enum drm_map_flags {
+       _DRM_RESTRICTED = 0x01,      /**< Cannot be mapped to user-virtual */
+       _DRM_READ_ONLY = 0x02,
+       _DRM_LOCKED = 0x04,          /**< shared, cached, locked */
+       _DRM_KERNEL = 0x08,          /**< kernel requires access */
+       _DRM_WRITE_COMBINING = 0x10, /**< use write-combining if available */
+       _DRM_CONTAINS_LOCK = 0x20,   /**< SHM page that contains lock */
+       _DRM_REMOVABLE = 0x40,       /**< Removable mapping */
+        _DRM_DRIVER = 0x80           /**< Driver will take care of it */
+};
+
+struct drm_ctx_priv_map {
+       unsigned int ctx_id;     /**< Context requesting private mapping */
+       void *handle;            /**< Handle of map */
+};
+
+/**
+ * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
+ * argument type.
+ *
+ * \sa drmAddMap().
+ */
+struct drm_map {
+       unsigned long offset;    /**< Requested physical address (0 for SAREA)*/
+       unsigned long size;      /**< Requested physical size (bytes) */
+       enum drm_map_type type;  /**< Type of memory to map */
+       enum drm_map_flags flags;        /**< Flags */
+       void *handle;            /**< User-space: "Handle" to pass to mmap() */
+                                /**< Kernel-space: kernel-virtual address */
+       int mtrr;                /**< MTRR slot used */
+       /*   Private data */
+};
+
+/**
+ * DRM_IOCTL_GET_CLIENT ioctl argument type.
+ */
+struct drm_client {
+       int idx;                /**< Which client desired? */
+       int auth;               /**< Is client authenticated? */
+       unsigned long pid;      /**< Process ID */
+       unsigned long uid;      /**< User ID */
+       unsigned long magic;    /**< Magic */
+       unsigned long iocs;     /**< Ioctl count */
+};
+
+enum drm_stat_type {
+       _DRM_STAT_LOCK,
+       _DRM_STAT_OPENS,
+       _DRM_STAT_CLOSES,
+       _DRM_STAT_IOCTLS,
+       _DRM_STAT_LOCKS,
+       _DRM_STAT_UNLOCKS,
+       _DRM_STAT_VALUE,        /**< Generic value */
+       _DRM_STAT_BYTE,         /**< Generic byte counter (1024bytes/K) */
+       _DRM_STAT_COUNT,        /**< Generic non-byte counter (1000/k) */
+
+       _DRM_STAT_IRQ,          /**< IRQ */
+       _DRM_STAT_PRIMARY,      /**< Primary DMA bytes */
+       _DRM_STAT_SECONDARY,    /**< Secondary DMA bytes */
+       _DRM_STAT_DMA,          /**< DMA */
+       _DRM_STAT_SPECIAL,      /**< Special DMA (e.g., priority or polled) */
+       _DRM_STAT_MISSED        /**< Missed DMA opportunity */
+           /* Add to the *END* of the list */
+};
+
+/**
+ * DRM_IOCTL_GET_STATS ioctl argument type.
+ */
+struct drm_stats {
+       unsigned long count;
+       struct {
+               unsigned long value;
+               enum drm_stat_type type;
+       } data[15];
+};
+
+/**
+ * Hardware locking flags.
+ */
+enum drm_lock_flags {
+       _DRM_LOCK_READY = 0x01,      /**< Wait until hardware is ready for DMA */
+       _DRM_LOCK_QUIESCENT = 0x02,  /**< Wait until hardware quiescent */
+       _DRM_LOCK_FLUSH = 0x04,      /**< Flush this context's DMA queue first */
+       _DRM_LOCK_FLUSH_ALL = 0x08,  /**< Flush all DMA queues first */
+       /* These *HALT* flags aren't supported yet
+          -- they will be used to support the
+          full-screen DGA-like mode. */
+       _DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */
+       _DRM_HALT_CUR_QUEUES = 0x20  /**< Halt all current queues */
+};
+
+/**
+ * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type.
+ *
+ * \sa drmGetLock() and drmUnlock().
+ */
+struct drm_lock {
+       int context;
+       enum drm_lock_flags flags;
+};
+
+/**
+ * DMA flags
+ *
+ * \warning
+ * These values \e must match xf86drm.h.
+ *
+ * \sa drm_dma.
+ */
+enum drm_dma_flags {
+       /* Flags for DMA buffer dispatch */
+       _DRM_DMA_BLOCK = 0x01,        /**<
+                                      * Block until buffer dispatched.
+                                      *
+                                      * \note The buffer may not yet have
+                                      * been processed by the hardware --
+                                      * getting a hardware lock with the
+                                      * hardware quiescent will ensure
+                                      * that the buffer has been
+                                      * processed.
+                                      */
+       _DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */
+       _DRM_DMA_PRIORITY = 0x04,     /**< High priority dispatch */
+
+       /* Flags for DMA buffer request */
+       _DRM_DMA_WAIT = 0x10,         /**< Wait for free buffers */
+       _DRM_DMA_SMALLER_OK = 0x20,   /**< Smaller-than-requested buffers OK */
+       _DRM_DMA_LARGER_OK = 0x40     /**< Larger-than-requested buffers OK */
+};
+
+/**
+ * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
+ *
+ * \sa drmAddBufs().
+ */
+struct drm_buf_desc {
+       int count;               /**< Number of buffers of this size */
+       int size;                /**< Size in bytes */
+       int low_mark;            /**< Low water mark */
+       int high_mark;           /**< High water mark */
+       enum {
+               _DRM_PAGE_ALIGN = 0x01, /**< Align on page boundaries for DMA */
+               _DRM_AGP_BUFFER = 0x02, /**< Buffer is in AGP space */
+               _DRM_SG_BUFFER  = 0x04, /**< Scatter/gather memory buffer */
+               _DRM_FB_BUFFER  = 0x08, /**< Buffer is in frame buffer */
+               _DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer read-only */
+       } flags;
+       unsigned long agp_start; /**<
+                                 * Start address of where the AGP buffers are
+                                 * in the AGP aperture
+                                 */
+};
+
+/**
+ * DRM_IOCTL_INFO_BUFS ioctl argument type.
+ */
+struct drm_buf_info {
+       int count;                /**< Number of buffers described in list */
+       struct drm_buf_desc __user *list; /**< List of buffer descriptions */
+};
+
+/**
+ * DRM_IOCTL_FREE_BUFS ioctl argument type.
+ */
+struct drm_buf_free {
+       int count;
+       int __user *list;
+};
+
+/**
+ * Buffer information
+ *
+ * \sa drm_buf_map.
+ */
+struct drm_buf_pub {
+       int idx;                       /**< Index into the master buffer list */
+       int total;                     /**< Buffer size */
+       int used;                      /**< Amount of buffer in use (for DMA) */
+       void __user *address;          /**< Address of buffer */
+};
+
+/**
+ * DRM_IOCTL_MAP_BUFS ioctl argument type.
+ */
+struct drm_buf_map {
+       int count;              /**< Length of the buffer list */
+#if defined(__cplusplus)
+       void __user *c_virtual;
+#else
+       void __user *virtual;           /**< Mmap'd area in user-virtual */
+#endif
+       struct drm_buf_pub __user *list;        /**< Buffer information */
+};
+
+/**
+ * DRM_IOCTL_DMA ioctl argument type.
+ *
+ * Indices here refer to the offset into the buffer list in drm_buf_get.
+ *
+ * \sa drmDMA().
+ */
+struct drm_dma {
+       int context;                      /**< Context handle */
+       int send_count;                   /**< Number of buffers to send */
+       int __user *send_indices;         /**< List of handles to buffers */
+       int __user *send_sizes;           /**< Lengths of data to send */
+       enum drm_dma_flags flags;         /**< Flags */
+       int request_count;                /**< Number of buffers requested */
+       int request_size;                 /**< Desired size for buffers */
+       int __user *request_indices;     /**< Buffer information */
+       int __user *request_sizes;
+       int granted_count;                /**< Number of buffers granted */
+};
+
+enum drm_ctx_flags {
+       _DRM_CONTEXT_PRESERVED = 0x01,
+       _DRM_CONTEXT_2DONLY = 0x02
+};
+
+/**
+ * DRM_IOCTL_ADD_CTX ioctl argument type.
+ *
+ * \sa drmCreateContext() and drmDestroyContext().
+ */
+struct drm_ctx {
+       drm_context_t handle;
+       enum drm_ctx_flags flags;
+};
+
+/**
+ * DRM_IOCTL_RES_CTX ioctl argument type.
+ */
+struct drm_ctx_res {
+       int count;
+       struct drm_ctx __user *contexts;
+};
+
+/**
+ * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
+ */
+struct drm_draw {
+       drm_drawable_t handle;
+};
+
+/**
+ * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
+ */
+typedef enum {
+       DRM_DRAWABLE_CLIPRECTS,
+} drm_drawable_info_type_t;
+
+struct drm_update_draw {
+       drm_drawable_t handle;
+       unsigned int type;
+       unsigned int num;
+       unsigned long long data;
+};
+
+/**
+ * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
+ */
+struct drm_auth {
+       drm_magic_t magic;
+};
+
+/**
+ * DRM_IOCTL_IRQ_BUSID ioctl argument type.
+ *
+ * \sa drmGetInterruptFromBusID().
+ */
+struct drm_irq_busid {
+       int irq;        /**< IRQ number */
+       int busnum;     /**< bus number */
+       int devnum;     /**< device number */
+       int funcnum;    /**< function number */
+};
+
+enum drm_vblank_seq_type {
+       _DRM_VBLANK_ABSOLUTE = 0x0,     /**< Wait for specific vblank sequence number */
+       _DRM_VBLANK_RELATIVE = 0x1,     /**< Wait for given number of vblanks */
+       _DRM_VBLANK_FLIP = 0x8000000,   /**< Scheduled buffer swap should flip */
+       _DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
+       _DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
+       _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */
+};
+
+#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
+#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY | \
+                               _DRM_VBLANK_NEXTONMISS)
+
+struct drm_wait_vblank_request {
+       enum drm_vblank_seq_type type;
+       unsigned int sequence;
+       unsigned long signal;
+};
+
+struct drm_wait_vblank_reply {
+       enum drm_vblank_seq_type type;
+       unsigned int sequence;
+       long tval_sec;
+       long tval_usec;
+};
+
+/**
+ * DRM_IOCTL_WAIT_VBLANK ioctl argument type.
+ *
+ * \sa drmWaitVBlank().
+ */
+union drm_wait_vblank {
+       struct drm_wait_vblank_request request;
+       struct drm_wait_vblank_reply reply;
+};
+
+/**
+ * DRM_IOCTL_AGP_ENABLE ioctl argument type.
+ *
+ * \sa drmAgpEnable().
+ */
+struct drm_agp_mode {
+       unsigned long mode;     /**< AGP mode */
+};
+
+/**
+ * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
+ *
+ * \sa drmAgpAlloc() and drmAgpFree().
+ */
+struct drm_agp_buffer {
+       unsigned long size;     /**< In bytes -- will round to page boundary */
+       unsigned long handle;   /**< Used for binding / unbinding */
+       unsigned long type;     /**< Type of memory to allocate */
+       unsigned long physical; /**< Physical used by i810 */
+};
+
+/**
+ * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
+ *
+ * \sa drmAgpBind() and drmAgpUnbind().
+ */
+struct drm_agp_binding {
+       unsigned long handle;   /**< From drm_agp_buffer */
+       unsigned long offset;   /**< In bytes -- will round to page boundary */
+};
+
+/**
+ * DRM_IOCTL_AGP_INFO ioctl argument type.
+ *
+ * \sa drmAgpVersionMajor(), drmAgpVersionMinor(), drmAgpGetMode(),
+ * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
+ * drmAgpVendorId() and drmAgpDeviceId().
+ */
+struct drm_agp_info {
+       int agp_version_major;
+       int agp_version_minor;
+       unsigned long mode;
+       unsigned long aperture_base;   /**< physical address */
+       unsigned long aperture_size;   /**< bytes */
+       unsigned long memory_allowed;  /**< bytes */
+       unsigned long memory_used;
+
+       /** \name PCI information */
+       /*@{ */
+       unsigned short id_vendor;
+       unsigned short id_device;
+       /*@} */
+};
+
+/**
+ * DRM_IOCTL_SG_ALLOC ioctl argument type.
+ */
+struct drm_scatter_gather {
+       unsigned long size;     /**< In bytes -- will round to page boundary */
+       unsigned long handle;   /**< Used for mapping / unmapping */
+};
+
+/**
+ * DRM_IOCTL_SET_VERSION ioctl argument type.
+ */
+struct drm_set_version {
+       int drm_di_major;
+       int drm_di_minor;
+       int drm_dd_major;
+       int drm_dd_minor;
+};
+
+
+#define DRM_FENCE_FLAG_EMIT                0x00000001
+#define DRM_FENCE_FLAG_SHAREABLE           0x00000002
+#define DRM_FENCE_FLAG_WAIT_LAZY           0x00000004
+#define DRM_FENCE_FLAG_WAIT_IGNORE_SIGNALS 0x00000008
+#define DRM_FENCE_FLAG_NO_USER             0x00000010
+
+/* Reserved for driver use */
+#define DRM_FENCE_MASK_DRIVER              0xFF000000
+
+#define DRM_FENCE_TYPE_EXE                 0x00000001
+
+struct drm_fence_arg {
+       unsigned int handle;
+       unsigned int fence_class;
+       unsigned int type;
+       unsigned int flags;
+       unsigned int signaled;
+       unsigned int error;
+       unsigned int sequence;
+       unsigned int pad64;
+       uint64_t expand_pad[2]; /*Future expansion */
+};
+
+/* Buffer permissions, referring to how the GPU uses the buffers.
+ * these translate to fence types used for the buffers.
+ * Typically a texture buffer is read, A destination buffer is write and
+ *  a command (batch-) buffer is exe. Can be or-ed together.
+ */
+
+#define DRM_BO_FLAG_READ        (1ULL << 0)
+#define DRM_BO_FLAG_WRITE       (1ULL << 1)
+#define DRM_BO_FLAG_EXE         (1ULL << 2)
+
+/*
+ * Status flags. Can be read to determine the actual state of a buffer.
+ * Can also be set in the buffer mask before validation.
+ */
+
+/*
+ * Mask: Never evict this buffer. Not even with force. This type of buffer is only
+ * available to root and must be manually removed before buffer manager shutdown
+ * or lock.
+ * Flags: Acknowledge
+ */
+#define DRM_BO_FLAG_NO_EVICT    (1ULL << 4)
+
+/*
+ * Mask: Require that the buffer is placed in mappable memory when validated.
+ *       If not set the buffer may or may not be in mappable memory when validated.
+ * Flags: If set, the buffer is in mappable memory.
+ */
+#define DRM_BO_FLAG_MAPPABLE    (1ULL << 5)
+
+/* Mask: The buffer should be shareable with other processes.
+ * Flags: The buffer is shareable with other processes.
+ */
+#define DRM_BO_FLAG_SHAREABLE   (1ULL << 6)
+
+/* Mask: If set, place the buffer in cache-coherent memory if available.
+ *       If clear, never place the buffer in cache coherent memory if validated.
+ * Flags: The buffer is currently in cache-coherent memory.
+ */
+#define DRM_BO_FLAG_CACHED      (1ULL << 7)
+
+/* Mask: Make sure that every time this buffer is validated,
+ *       it ends up on the same location provided that the memory mask is the same.
+ *       The buffer will also not be evicted when claiming space for
+ *       other buffers. Basically a pinned buffer but it may be thrown out as
+ *       part of buffer manager shutdown or locking.
+ * Flags: Acknowledge.
+ */
+#define DRM_BO_FLAG_NO_MOVE     (1ULL << 8)
+
+/* Mask: Make sure the buffer is in cached memory when mapped
+ * Flags: Acknowledge.
+ * Buffers allocated with this flag should not be used for suballocators
+ * This type may have issues on CPUs with over-aggressive caching
+ * http://marc.info/?l=linux-kernel&m=102376926732464&w=2
+ */
+#define DRM_BO_FLAG_CACHED_MAPPED    (1ULL << 19)
+
+
+/* Mask: Force DRM_BO_FLAG_CACHED flag strictly also if it is set.
+ * Flags: Acknowledge.
+ */
+#define DRM_BO_FLAG_FORCE_CACHING  (1ULL << 13)
+
+/*
+ * Mask: Force DRM_BO_FLAG_MAPPABLE flag strictly also if it is clear.
+ * Flags: Acknowledge.
+ */
+#define DRM_BO_FLAG_FORCE_MAPPABLE (1ULL << 14)
+#define DRM_BO_FLAG_TILE           (1ULL << 15)
+
+/*
+ * Memory type flags that can be or'ed together in the mask, but only
+ * one appears in flags.
+ */
+
+/* System memory */
+#define DRM_BO_FLAG_MEM_LOCAL  (1ULL << 24)
+/* Translation table memory */
+#define DRM_BO_FLAG_MEM_TT     (1ULL << 25)
+/* Vram memory */
+#define DRM_BO_FLAG_MEM_VRAM   (1ULL << 26)
+/* Up to the driver to define. */
+#define DRM_BO_FLAG_MEM_PRIV0  (1ULL << 27)
+#define DRM_BO_FLAG_MEM_PRIV1  (1ULL << 28)
+#define DRM_BO_FLAG_MEM_PRIV2  (1ULL << 29)
+#define DRM_BO_FLAG_MEM_PRIV3  (1ULL << 30)
+#define DRM_BO_FLAG_MEM_PRIV4  (1ULL << 31)
+/* We can add more of these now with a 64-bit flag type */
+
+/* Memory flag mask */
+#define DRM_BO_MASK_MEM         0x00000000FF000000ULL
+#define DRM_BO_MASK_MEMTYPE     0x00000000FF0800A0ULL
+
+/* Driver-private flags */
+#define DRM_BO_MASK_DRIVER      0xFFFF000000000000ULL
+
+/* Don't block on validate and map */
+#define DRM_BO_HINT_DONT_BLOCK  0x00000002
+/* Don't place this buffer on the unfenced list.*/
+#define DRM_BO_HINT_DONT_FENCE  0x00000004
+#define DRM_BO_HINT_WAIT_LAZY   0x00000008
+#define DRM_BO_HINT_PRESUMED_OFFSET 0x00000010
+
+#define DRM_BO_INIT_MAGIC 0xfe769812
+#define DRM_BO_INIT_MAJOR 1
+#define DRM_BO_INIT_MINOR 0
+#define DRM_BO_INIT_PATCH 0
+
+
+struct drm_bo_info_req {
+       uint64_t mask;
+       uint64_t flags;
+       unsigned int handle;
+       unsigned int hint;
+       unsigned int fence_class;
+       unsigned int desired_tile_stride;
+       unsigned int tile_info;
+       unsigned int pad64;
+        uint64_t presumed_offset;
+};
+
+struct drm_bo_create_req {
+       uint64_t mask;
+       uint64_t size;
+       uint64_t buffer_start;
+       unsigned int hint;
+       unsigned int page_alignment;
+};
+
+
+/*
+ * Reply flags
+ */
+
+#define DRM_BO_REP_BUSY 0x00000001
+
+struct drm_bo_info_rep {
+       uint64_t flags;
+       uint64_t mask;
+       uint64_t size;
+       uint64_t offset;
+       uint64_t arg_handle;
+       uint64_t buffer_start;
+       unsigned int handle;
+       unsigned int fence_flags;
+       unsigned int rep_flags;
+       unsigned int page_alignment;
+       unsigned int desired_tile_stride;
+       unsigned int hw_tile_stride;
+       unsigned int tile_info;
+       unsigned int pad64;
+       uint64_t expand_pad[4]; /*Future expansion */
+};
+
+struct drm_bo_arg_rep {
+       struct drm_bo_info_rep bo_info;
+       int ret;
+       unsigned int pad64;
+};
+
+struct drm_bo_create_arg {
+       union {
+               struct drm_bo_create_req req;
+               struct drm_bo_info_rep rep;
+       } d;
+};
+
+struct drm_bo_handle_arg {
+       unsigned int handle;
+};
+
+struct drm_bo_reference_info_arg {
+       union {
+               struct drm_bo_handle_arg req;
+               struct drm_bo_info_rep rep;
+       } d;
+};
+
+struct drm_bo_map_wait_idle_arg {
+       union {
+               struct drm_bo_info_req req;
+               struct drm_bo_info_rep rep;
+       } d;
+};
+
+struct drm_bo_op_req {
+       enum {
+               drm_bo_validate,
+               drm_bo_fence,
+               drm_bo_ref_fence,
+       } op;
+       unsigned int arg_handle;
+       struct drm_bo_info_req bo_req;
+};
+
+
+struct drm_bo_op_arg {
+       uint64_t next;
+       union {
+               struct drm_bo_op_req req;
+               struct drm_bo_arg_rep rep;
+       } d;
+       int handled;
+       unsigned int pad64;
+};
+
+
+#define DRM_BO_MEM_LOCAL 0
+#define DRM_BO_MEM_TT 1
+#define DRM_BO_MEM_VRAM 2
+#define DRM_BO_MEM_PRIV0 3
+#define DRM_BO_MEM_PRIV1 4
+#define DRM_BO_MEM_PRIV2 5
+#define DRM_BO_MEM_PRIV3 6
+#define DRM_BO_MEM_PRIV4 7
+
+#define DRM_BO_MEM_TYPES 8 /* For now. */
+
+#define DRM_BO_LOCK_UNLOCK_BM       (1 << 0)
+#define DRM_BO_LOCK_IGNORE_NO_EVICT (1 << 1)
+
+struct drm_bo_version_arg {
+       uint32_t major;
+       uint32_t minor;
+       uint32_t patchlevel;
+};
+
+struct drm_mm_type_arg {
+       unsigned int mem_type;
+       unsigned int lock_flags;
+};
+
+struct drm_mm_init_arg {
+       unsigned int magic;
+       unsigned int major;
+       unsigned int minor;
+       unsigned int mem_type;
+       uint64_t p_offset;
+       uint64_t p_size;
+};
+
+/*
+ * Drm mode setting
+ */
+#define DRM_DISPLAY_INFO_LEN 32
+#define DRM_OUTPUT_NAME_LEN 32
+#define DRM_DISPLAY_MODE_LEN 32
+#define DRM_PROP_NAME_LEN 32
+
+#define DRM_MODE_TYPE_BUILTIN  (1<<0)
+#define DRM_MODE_TYPE_CLOCK_C  ((1<<1) | DRM_MODE_TYPE_BUILTIN)
+#define DRM_MODE_TYPE_CRTC_C   ((1<<2) | DRM_MODE_TYPE_BUILTIN)
+#define DRM_MODE_TYPE_PREFERRED        (1<<3)
+#define DRM_MODE_TYPE_DEFAULT  (1<<4)
+#define DRM_MODE_TYPE_USERDEF  (1<<5)
+#define DRM_MODE_TYPE_DRIVER   (1<<6)
+#define DRM_MODE_TYPE_USERPREF (1<<7)
+
+struct drm_mode_modeinfo {
+
+       unsigned int id;
+
+       unsigned int clock;
+       unsigned short hdisplay, hsync_start, hsync_end, htotal, hskew;
+       unsigned short vdisplay, vsync_start, vsync_end, vtotal, vscan;
+
+       unsigned int vrefresh; /* vertical refresh * 1000 */
+
+       unsigned int flags;
+       unsigned int type;
+       char name[DRM_DISPLAY_MODE_LEN];
+};
+
+struct drm_mode_card_res {
+
+       int count_fbs;
+       unsigned int __user *fb_id;
+
+       int count_crtcs;
+       unsigned int __user *crtc_id;
+
+       int count_outputs;
+       unsigned int __user *output_id;
+
+       int count_modes;
+        struct drm_mode_modeinfo __user *modes;
+
+};
+
+struct drm_mode_crtc {
+       unsigned int crtc_id; /**< Id */
+       unsigned int fb_id; /**< Id of framebuffer */
+
+       int x, y; /**< Position on the frameuffer */
+
+       unsigned int mode; /**< Current mode used */
+
+       int count_outputs;
+       unsigned int outputs; /**< Outputs that are connected */
+
+       int count_possibles;
+       unsigned int possibles; /**< Outputs that can be connected */
+
+       unsigned int __user *set_outputs; /**< Outputs to be connected */
+
+       int gamma_size;
+
+};
+
+struct drm_mode_get_output {
+
+       unsigned int output; /**< Id */
+       unsigned int crtc; /**< Id of crtc */
+       unsigned char name[DRM_OUTPUT_NAME_LEN];
+
+       unsigned int connection;
+       unsigned int mm_width, mm_height; /**< HxW in millimeters */
+       unsigned int subpixel;
+
+       int count_crtcs;
+       unsigned int crtcs; /**< possible crtc to connect to */
+
+       int count_clones;
+       unsigned int clones; /**< list of clones */
+
+       int count_modes;
+       unsigned int __user *modes; /**< list of modes it supports */
+
+       int count_props;
+       unsigned int __user *props;
+       unsigned int __user *prop_values;
+};
+
+#define DRM_MODE_PROP_PENDING (1<<0)
+#define DRM_MODE_PROP_RANGE (1<<1)
+#define DRM_MODE_PROP_IMMUTABLE (1<<2)
+#define DRM_MODE_PROP_ENUM (1<<3) // enumerated type with text strings
+
+struct drm_mode_property_enum {
+       uint32_t value;
+       unsigned char name[DRM_PROP_NAME_LEN];
+};
+               
+struct drm_mode_get_property {
+
+       unsigned int prop_id;
+       unsigned int flags;
+       unsigned char name[DRM_PROP_NAME_LEN];
+
+       int count_values;
+       uint32_t __user *values;
+
+       int count_enums;
+       struct drm_mode_property_enum *enums;
+};
+
+struct drm_mode_fb_cmd {
+        unsigned int buffer_id;
+        unsigned int width, height;
+        unsigned int pitch;
+        unsigned int bpp;
+        unsigned int handle;
+       unsigned int depth;
+};
+
+struct drm_mode_mode_cmd {
+       unsigned int output_id;
+       unsigned int mode_id;
+};
+
+/**
+ * \name Ioctls Definitions
+ */
+/*@{*/
+
+#define DRM_IOCTL_BASE                 'd'
+#define DRM_IO(nr)                     _IO(DRM_IOCTL_BASE,nr)
+#define DRM_IOR(nr,type)               _IOR(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOW(nr,type)               _IOW(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOWR(nr,type)              _IOWR(DRM_IOCTL_BASE,nr,type)
+
+#define DRM_IOCTL_VERSION              DRM_IOWR(0x00, struct drm_version)
+#define DRM_IOCTL_GET_UNIQUE           DRM_IOWR(0x01, struct drm_unique)
+#define DRM_IOCTL_GET_MAGIC            DRM_IOR( 0x02, struct drm_auth)
+#define DRM_IOCTL_IRQ_BUSID            DRM_IOWR(0x03, struct drm_irq_busid)
+#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, struct drm_map)
+#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, struct drm_client)
+#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, struct drm_stats)
+#define DRM_IOCTL_SET_VERSION          DRM_IOWR(0x07, struct drm_set_version)
+
+#define DRM_IOCTL_SET_UNIQUE           DRM_IOW( 0x10, struct drm_unique)
+#define DRM_IOCTL_AUTH_MAGIC           DRM_IOW( 0x11, struct drm_auth)
+#define DRM_IOCTL_BLOCK                        DRM_IOWR(0x12, struct drm_block)
+#define DRM_IOCTL_UNBLOCK              DRM_IOWR(0x13, struct drm_block)
+#define DRM_IOCTL_CONTROL              DRM_IOW( 0x14, struct drm_control)
+#define DRM_IOCTL_ADD_MAP              DRM_IOWR(0x15, struct drm_map)
+#define DRM_IOCTL_ADD_BUFS             DRM_IOWR(0x16, struct drm_buf_desc)
+#define DRM_IOCTL_MARK_BUFS            DRM_IOW( 0x17, struct drm_buf_desc)
+#define DRM_IOCTL_INFO_BUFS            DRM_IOWR(0x18, struct drm_buf_info)
+#define DRM_IOCTL_MAP_BUFS             DRM_IOWR(0x19, struct drm_buf_map)
+#define DRM_IOCTL_FREE_BUFS            DRM_IOW( 0x1a, struct drm_buf_free)
+
+#define DRM_IOCTL_RM_MAP               DRM_IOW( 0x1b, struct drm_map)
+
+#define DRM_IOCTL_SET_SAREA_CTX                DRM_IOW( 0x1c, struct drm_ctx_priv_map)
+#define DRM_IOCTL_GET_SAREA_CTX                DRM_IOWR(0x1d, struct drm_ctx_priv_map)
+
+#define DRM_IOCTL_ADD_CTX              DRM_IOWR(0x20, struct drm_ctx)
+#define DRM_IOCTL_RM_CTX               DRM_IOWR(0x21, struct drm_ctx)
+#define DRM_IOCTL_MOD_CTX              DRM_IOW( 0x22, struct drm_ctx)
+#define DRM_IOCTL_GET_CTX              DRM_IOWR(0x23, struct drm_ctx)
+#define DRM_IOCTL_SWITCH_CTX           DRM_IOW( 0x24, struct drm_ctx)
+#define DRM_IOCTL_NEW_CTX              DRM_IOW( 0x25, struct drm_ctx)
+#define DRM_IOCTL_RES_CTX              DRM_IOWR(0x26, struct drm_ctx_res)
+#define DRM_IOCTL_ADD_DRAW             DRM_IOWR(0x27, struct drm_draw)
+#define DRM_IOCTL_RM_DRAW              DRM_IOWR(0x28, struct drm_draw)
+#define DRM_IOCTL_DMA                  DRM_IOWR(0x29, struct drm_dma)
+#define DRM_IOCTL_LOCK                 DRM_IOW( 0x2a, struct drm_lock)
+#define DRM_IOCTL_UNLOCK               DRM_IOW( 0x2b, struct drm_lock)
+#define DRM_IOCTL_FINISH               DRM_IOW( 0x2c, struct drm_lock)
+
+#define DRM_IOCTL_AGP_ACQUIRE          DRM_IO(  0x30)
+#define DRM_IOCTL_AGP_RELEASE          DRM_IO(  0x31)
+#define DRM_IOCTL_AGP_ENABLE           DRM_IOW( 0x32, struct drm_agp_mode)
+#define DRM_IOCTL_AGP_INFO             DRM_IOR( 0x33, struct drm_agp_info)
+#define DRM_IOCTL_AGP_ALLOC            DRM_IOWR(0x34, struct drm_agp_buffer)
+#define DRM_IOCTL_AGP_FREE             DRM_IOW( 0x35, struct drm_agp_buffer)
+#define DRM_IOCTL_AGP_BIND             DRM_IOW( 0x36, struct drm_agp_binding)
+#define DRM_IOCTL_AGP_UNBIND           DRM_IOW( 0x37, struct drm_agp_binding)
+
+#define DRM_IOCTL_SG_ALLOC             DRM_IOW( 0x38, struct drm_scatter_gather)
+#define DRM_IOCTL_SG_FREE              DRM_IOW( 0x39, struct drm_scatter_gather)
+
+#define DRM_IOCTL_WAIT_VBLANK          DRM_IOWR(0x3a, union drm_wait_vblank)
+
+#define DRM_IOCTL_UPDATE_DRAW           DRM_IOW(0x3f, struct drm_update_draw)
+
+#define DRM_IOCTL_MM_INIT               DRM_IOWR(0xc0, struct drm_mm_init_arg)
+#define DRM_IOCTL_MM_TAKEDOWN           DRM_IOWR(0xc1, struct drm_mm_type_arg)
+#define DRM_IOCTL_MM_LOCK               DRM_IOWR(0xc2, struct drm_mm_type_arg)
+#define DRM_IOCTL_MM_UNLOCK             DRM_IOWR(0xc3, struct drm_mm_type_arg)
+
+#define DRM_IOCTL_FENCE_CREATE          DRM_IOWR(0xc4, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_REFERENCE       DRM_IOWR(0xc6, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_UNREFERENCE     DRM_IOWR(0xc7, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_SIGNALED        DRM_IOWR(0xc8, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_FLUSH           DRM_IOWR(0xc9, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_WAIT            DRM_IOWR(0xca, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_EMIT            DRM_IOWR(0xcb, struct drm_fence_arg)
+#define DRM_IOCTL_FENCE_BUFFERS         DRM_IOWR(0xcc, struct drm_fence_arg)
+
+#define DRM_IOCTL_BO_CREATE             DRM_IOWR(0xcd, struct drm_bo_create_arg)
+#define DRM_IOCTL_BO_MAP                DRM_IOWR(0xcf, struct drm_bo_map_wait_idle_arg)
+#define DRM_IOCTL_BO_UNMAP              DRM_IOWR(0xd0, struct drm_bo_handle_arg)
+#define DRM_IOCTL_BO_REFERENCE          DRM_IOWR(0xd1, struct drm_bo_reference_info_arg)
+#define DRM_IOCTL_BO_UNREFERENCE        DRM_IOWR(0xd2, struct drm_bo_handle_arg)
+#define DRM_IOCTL_BO_SETSTATUS          DRM_IOWR(0xd3, struct drm_bo_map_wait_idle_arg)
+#define DRM_IOCTL_BO_INFO               DRM_IOWR(0xd4, struct drm_bo_reference_info_arg)
+#define DRM_IOCTL_BO_WAIT_IDLE          DRM_IOWR(0xd5, struct drm_bo_map_wait_idle_arg)
+#define DRM_IOCTL_BO_VERSION          DRM_IOR(0xd6, struct drm_bo_version_arg)
+
+
+#define DRM_IOCTL_MODE_GETRESOURCES     DRM_IOWR(0xA0, struct drm_mode_card_res)
+#define DRM_IOCTL_MODE_GETCRTC          DRM_IOWR(0xA1, struct drm_mode_crtc)
+#define DRM_IOCTL_MODE_GETOUTPUT        DRM_IOWR(0xA2, struct drm_mode_get_output)
+#define DRM_IOCTL_MODE_SETCRTC          DRM_IOWR(0xA3, struct drm_mode_crtc)
+#define DRM_IOCTL_MODE_ADDFB            DRM_IOWR(0xA4, struct drm_mode_fb_cmd)
+#define DRM_IOCTL_MODE_RMFB             DRM_IOWR(0xA5, unsigned int)
+#define DRM_IOCTL_MODE_GETFB            DRM_IOWR(0xA6, struct drm_mode_fb_cmd)
+
+#define DRM_IOCTL_MODE_ADDMODE         DRM_IOWR(0xA7, struct drm_mode_modeinfo)
+#define DRM_IOCTL_MODE_RMMODE          DRM_IOWR(0xA8, unsigned int)
+#define DRM_IOCTL_MODE_ATTACHMODE      DRM_IOWR(0xA9, struct drm_mode_mode_cmd)
+#define DRM_IOCTL_MODE_DETACHMODE      DRM_IOWR(0xAA, struct drm_mode_mode_cmd)
+
+#define DRM_IOCTL_MODE_GETPROPERTY     DRM_IOWR(0xAB, struct drm_mode_get_property)
+/*@}*/
+
+/**
+ * Device specific ioctls should only be in their respective headers
+ * The device specific ioctl range is from 0x40 to 0x99.
+ * Generic IOCTLS restart at 0xA0.
+ *
+ * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and
+ * drmCommandReadWrite().
+ */
+#define DRM_COMMAND_BASE                0x40
+#define DRM_COMMAND_END                 0xA0
+
+/* typedef area */
+#if !defined(__KERNEL__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+typedef struct drm_clip_rect drm_clip_rect_t;
+typedef struct drm_tex_region drm_tex_region_t;
+typedef struct drm_hw_lock drm_hw_lock_t;
+typedef struct drm_version drm_version_t;
+typedef struct drm_unique drm_unique_t;
+typedef struct drm_list drm_list_t;
+typedef struct drm_block drm_block_t;
+typedef struct drm_control drm_control_t;
+typedef enum drm_map_type drm_map_type_t;
+typedef enum drm_map_flags drm_map_flags_t;
+typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;
+typedef struct drm_map drm_map_t;
+typedef struct drm_client drm_client_t;
+typedef enum drm_stat_type drm_stat_type_t;
+typedef struct drm_stats drm_stats_t;
+typedef enum drm_lock_flags drm_lock_flags_t;
+typedef struct drm_lock drm_lock_t;
+typedef enum drm_dma_flags drm_dma_flags_t;
+typedef struct drm_buf_desc drm_buf_desc_t;
+typedef struct drm_buf_info drm_buf_info_t;
+typedef struct drm_buf_free drm_buf_free_t;
+typedef struct drm_buf_pub drm_buf_pub_t;
+typedef struct drm_buf_map drm_buf_map_t;
+typedef struct drm_dma drm_dma_t;
+typedef union drm_wait_vblank drm_wait_vblank_t;
+typedef struct drm_agp_mode drm_agp_mode_t;
+typedef enum drm_ctx_flags drm_ctx_flags_t;
+typedef struct drm_ctx drm_ctx_t;
+typedef struct drm_ctx_res drm_ctx_res_t;
+typedef struct drm_draw drm_draw_t;
+typedef struct drm_update_draw drm_update_draw_t;
+typedef struct drm_auth drm_auth_t;
+typedef struct drm_irq_busid drm_irq_busid_t;
+typedef enum drm_vblank_seq_type drm_vblank_seq_type_t;
+typedef struct drm_agp_buffer drm_agp_buffer_t;
+typedef struct drm_agp_binding drm_agp_binding_t;
+typedef struct drm_agp_info drm_agp_info_t;
+typedef struct drm_scatter_gather drm_scatter_gather_t;
+typedef struct drm_set_version drm_set_version_t;
+
+typedef struct drm_fence_arg drm_fence_arg_t;
+typedef struct drm_mm_type_arg drm_mm_type_arg_t;
+typedef struct drm_mm_init_arg drm_mm_init_arg_t;
+typedef enum drm_bo_type drm_bo_type_t;
+#endif
+
+#endif
diff --git a/psb-kernel-source-4.41.1/drmP.h b/psb-kernel-source-4.41.1/drmP.h
new file mode 100644 (file)
index 0000000..2449fe0
--- /dev/null
@@ -0,0 +1,1332 @@
+/**
+ * \file drmP.h
+ * Private header for Direct Rendering Manager
+ *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ * \author Gareth Hughes <gareth@valinux.com>
+ */
+
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _DRM_P_H_
+#define _DRM_P_H_
+
+#ifdef __KERNEL__
+#ifdef __alpha__
+/* add include of current.h so that "current" is defined
+ * before static inline funcs in wait.h. Doing this so we
+ * can build the DRM (part of PI DRI). 4/21/2000 S + B */
+#include <asm/current.h>
+#endif                         /* __alpha__ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/init.h>
+#include <linux/file.h>
+#include <linux/pci.h>
+#include <linux/version.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>    /* For (un)lock_kernel */
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/i2c.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
+#include <linux/mutex.h>
+#endif
+#if defined(__alpha__) || defined(__powerpc__)
+#include <asm/pgtable.h>       /* For pte_wrprotect */
+#endif
+#include <asm/io.h>
+#include <asm/mman.h>
+#include <asm/uaccess.h>
+#ifdef CONFIG_MTRR
+#include <asm/mtrr.h>
+#endif
+#if defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE)
+#include <asm/agp.h>
+#include <linux/types.h>
+#include <linux/agp_backend.h>
+#endif
+#include <linux/workqueue.h>
+#include <linux/poll.h>
+#include <asm/pgalloc.h>
+#include "drm.h"
+#include <linux/slab.h>
+#include <linux/idr.h>
+
+#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 1
+#endif
+
+#include "drm_os_linux.h"
+#include "drm_hashtab.h"
+#include "drm_internal.h"
+
+struct drm_device;
+struct drm_file;
+
+/* If you want the memory alloc debug functionality, change define below */
+/* #define DEBUG_MEMORY */
+
+/***********************************************************************/
+/** \name DRM template customization defaults */
+/*@{*/
+
+/* driver capabilities and requirements mask */
+#define DRIVER_USE_AGP     0x1
+#define DRIVER_REQUIRE_AGP 0x2
+#define DRIVER_USE_MTRR    0x4
+#define DRIVER_PCI_DMA     0x8
+#define DRIVER_SG          0x10
+#define DRIVER_HAVE_DMA    0x20
+#define DRIVER_HAVE_IRQ    0x40
+#define DRIVER_IRQ_SHARED  0x80
+#define DRIVER_IRQ_VBL     0x100
+#define DRIVER_DMA_QUEUE   0x200
+#define DRIVER_FB_DMA      0x400
+#define DRIVER_IRQ_VBL2    0x800
+
+
+/*@}*/
+
+/***********************************************************************/
+/** \name Begin the DRM... */
+/*@{*/
+
+#define DRM_DEBUG_CODE 2         /**< Include debugging code if > 1, then
+                                    also include looping detection. */
+
+#define DRM_MAGIC_HASH_ORDER  4 /**< Size of key hash table. Must be power of 2. */
+#define DRM_KERNEL_CONTEXT    0         /**< Change drm_resctx if changed */
+#define DRM_RESERVED_CONTEXTS 1         /**< Change drm_resctx if changed */
+#define DRM_LOOPING_LIMIT     5000000
+#define DRM_TIME_SLICE       (HZ/20)  /**< Time slice for GLXContexts */
+#define DRM_LOCK_SLICE       1 /**< Time slice for lock, in jiffies */
+
+#define DRM_FLAG_DEBUG   0x01
+
+#define DRM_MEM_DMA       0
+#define DRM_MEM_SAREA     1
+#define DRM_MEM_DRIVER    2
+#define DRM_MEM_MAGIC     3
+#define DRM_MEM_IOCTLS    4
+#define DRM_MEM_MAPS      5
+#define DRM_MEM_VMAS      6
+#define DRM_MEM_BUFS      7
+#define DRM_MEM_SEGS      8
+#define DRM_MEM_PAGES     9
+#define DRM_MEM_FILES    10
+#define DRM_MEM_QUEUES   11
+#define DRM_MEM_CMDS     12
+#define DRM_MEM_MAPPINGS  13
+#define DRM_MEM_BUFLISTS  14
+#define DRM_MEM_AGPLISTS  15
+#define DRM_MEM_TOTALAGP  16
+#define DRM_MEM_BOUNDAGP  17
+#define DRM_MEM_CTXBITMAP 18
+#define DRM_MEM_STUB      19
+#define DRM_MEM_SGLISTS   20
+#define DRM_MEM_CTXLIST   21
+#define DRM_MEM_MM        22
+#define DRM_MEM_HASHTAB   23
+#define DRM_MEM_OBJECTS   24
+#define DRM_MEM_FENCE     25
+#define DRM_MEM_TTM       26
+#define DRM_MEM_BUFOBJ    27
+
+#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
+#define DRM_MAP_HASH_OFFSET 0x10000000
+#define DRM_MAP_HASH_ORDER 12
+#define DRM_OBJECT_HASH_ORDER 12
+#define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
+#define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
+/*
+ * This should be small enough to allow the use of kmalloc for hash tables
+ * instead of vmalloc.
+ */
+
+#define DRM_FILE_HASH_ORDER 8
+#define DRM_MM_INIT_MAX_PAGES 256
+
+/*@}*/
+
+#include "drm_compat.h"
+
+
+/***********************************************************************/
+/** \name Macros to make printk easier */
+/*@{*/
+
+/**
+ * Error output.
+ *
+ * \param fmt printf() like format string.
+ * \param arg arguments
+ */
+#define DRM_ERROR(fmt, arg...) \
+       printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __FUNCTION__ , ##arg)
+
+/**
+ * Memory error output.
+ *
+ * \param area memory area where the error occurred.
+ * \param fmt printf() like format string.
+ * \param arg arguments
+ */
+#define DRM_MEM_ERROR(area, fmt, arg...) \
+       printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __FUNCTION__, \
+              drm_mem_stats[area].name , ##arg)
+#define DRM_INFO(fmt, arg...)  printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg)
+
+/**
+ * Debug output.
+ *
+ * \param fmt printf() like format string.
+ * \param arg arguments
+ */
+#if DRM_DEBUG_CODE
+#define DRM_DEBUG(fmt, arg...)                                         \
+       do {                                                            \
+               if ( drm_debug )                                        \
+                       printk(KERN_DEBUG                               \
+                              "[" DRM_NAME ":%s] " fmt ,               \
+                              __FUNCTION__ , ##arg);                   \
+       } while (0)
+#else
+#define DRM_DEBUG(fmt, arg...)          do { } while (0)
+#endif
+
+#define DRM_PROC_LIMIT (PAGE_SIZE-80)
+
+#define DRM_PROC_PRINT(fmt, arg...)                                    \
+   len += sprintf(&buf[len], fmt , ##arg);                             \
+   if (len > DRM_PROC_LIMIT) { *eof = 1; return len - offset; }
+
+#define DRM_PROC_PRINT_RET(ret, fmt, arg...)                           \
+   len += sprintf(&buf[len], fmt , ##arg);                             \
+   if (len > DRM_PROC_LIMIT) { ret; *eof = 1; return len - offset; }
+
+/*@}*/
+
+/***********************************************************************/
+/** \name Internal types and structures */
+/*@{*/
+
+#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
+#define DRM_MIN(a,b) min(a,b)
+#define DRM_MAX(a,b) max(a,b)
+
+#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
+#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
+#define DRM_WAITCOUNT(dev,idx) DRM_BUFCOUNT(&dev->queuelist[idx]->waitlist)
+
+#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
+/**
+ * Get the private SAREA mapping.
+ *
+ * \param _dev DRM device.
+ * \param _ctx context number.
+ * \param _map output mapping.
+ */
+#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do {      \
+       (_map) = (_dev)->context_sareas[_ctx];          \
+} while(0)
+
+/**
+ * Test that the hardware lock is held by the caller, returning otherwise.
+ *
+ * \param dev DRM device.
+ * \param file_priv DRM file private pointer of the caller.
+ */
+#define LOCK_TEST_WITH_RETURN( dev, file_priv )                                \
+do {                                                                   \
+       if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||           \
+            dev->lock.file_priv != file_priv ) {                       \
+               DRM_ERROR( "%s called without lock held, held  %d owner %p %p\n",\
+                          __FUNCTION__, _DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ),\
+                          dev->lock.file_priv, file_priv );            \
+               return -EINVAL;                                         \
+       }                                                               \
+} while (0)
+
+/**
+ * Copy and IOCTL return string to user space
+ */
+#define DRM_COPY( name, value )                                                \
+       len = strlen( value );                                          \
+       if ( len > name##_len ) len = name##_len;                       \
+       name##_len = strlen( value );                                   \
+       if ( len && name ) {                                            \
+               if ( copy_to_user( name, value, len ) )                 \
+                       return -EFAULT;                                 \
+       }
+
+/**
+ * Ioctl function type.
+ *
+ * \param dev DRM device structure
+ * \param data pointer to kernel-space stored data, copied in and out according
+ *            to ioctl description.
+ * \param file_priv DRM file private pointer.
+ */
+typedef int drm_ioctl_t(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+
+typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
+                              unsigned long arg);
+
+#define DRM_AUTH        0x1
+#define DRM_MASTER      0x2
+#define DRM_ROOT_ONLY   0x4
+
+struct drm_ioctl_desc {
+       unsigned int cmd;
+       drm_ioctl_t *func;
+       int flags;
+};
+/**
+ * Creates a driver or general drm_ioctl_desc array entry for the given
+ * ioctl, for use by drm_ioctl().
+ */
+#define DRM_IOCTL_DEF(ioctl, func, flags) \
+       [DRM_IOCTL_NR(ioctl)] = {ioctl, func, flags}
+
+struct drm_magic_entry {
+       struct list_head head;
+       struct drm_hash_item hash_item;
+       struct drm_file *priv;
+};
+
+struct drm_vma_entry {
+       struct list_head head;
+       struct vm_area_struct *vma;
+       pid_t pid;
+};
+
+/**
+ * DMA buffer.
+ */
+struct drm_buf {
+       int idx;                       /**< Index into master buflist */
+       int total;                     /**< Buffer size */
+       int order;                     /**< log-base-2(total) */
+       int used;                      /**< Amount of buffer in use (for DMA) */
+       unsigned long offset;          /**< Byte offset (used internally) */
+       void *address;                 /**< Address of buffer */
+       unsigned long bus_address;     /**< Bus address of buffer */
+       struct drm_buf *next;          /**< Kernel-only: used for free list */
+       __volatile__ int waiting;      /**< On kernel DMA queue */
+       __volatile__ int pending;      /**< On hardware DMA queue */
+       wait_queue_head_t dma_wait;    /**< Processes waiting */
+       struct drm_file *file_priv;    /**< Private of holding file descr */
+       int context;                   /**< Kernel queue for this buffer */
+       int while_locked;              /**< Dispatch this buffer while locked */
+       enum {
+               DRM_LIST_NONE = 0,
+               DRM_LIST_FREE = 1,
+               DRM_LIST_WAIT = 2,
+               DRM_LIST_PEND = 3,
+               DRM_LIST_PRIO = 4,
+               DRM_LIST_RECLAIM = 5
+       } list;                        /**< Which list we're on */
+
+       int dev_priv_size;              /**< Size of buffer private storage */
+       void *dev_private;              /**< Per-buffer private storage */
+};
+
+/** bufs is one longer than it has to be */
+struct drm_waitlist {
+       int count;                      /**< Number of possible buffers */
+       struct drm_buf **bufs;          /**< List of pointers to buffers */
+       struct drm_buf **rp;                    /**< Read pointer */
+       struct drm_buf **wp;                    /**< Write pointer */
+       struct drm_buf **end;           /**< End pointer */
+       spinlock_t read_lock;
+       spinlock_t write_lock;
+};
+
+struct drm_freelist {
+       int initialized;               /**< Freelist in use */
+       atomic_t count;                /**< Number of free buffers */
+       struct drm_buf *next;          /**< End pointer */
+
+       wait_queue_head_t waiting;     /**< Processes waiting on free bufs */
+       int low_mark;                  /**< Low water mark */
+       int high_mark;                 /**< High water mark */
+       atomic_t wfh;                  /**< If waiting for high mark */
+       spinlock_t lock;
+};
+
+typedef struct drm_dma_handle {
+       dma_addr_t busaddr;
+       void *vaddr;
+       size_t size;
+} drm_dma_handle_t;
+
+/**
+ * Buffer entry.  There is one of this for each buffer size order.
+ */
+struct drm_buf_entry {
+       int buf_size;                   /**< size */
+       int buf_count;                  /**< number of buffers */
+       struct drm_buf *buflist;                /**< buffer list */
+       int seg_count;
+       int page_order;
+       struct drm_dma_handle **seglist;
+       struct drm_freelist freelist;
+};
+
+
+enum drm_ref_type {
+       _DRM_REF_USE = 0,
+       _DRM_REF_TYPE1,
+       _DRM_NO_REF_TYPES
+};
+
+
+/** File private data */
+struct drm_file {
+       int authenticated;
+       int master;
+       int minor;
+       pid_t pid;
+       uid_t uid;
+       drm_magic_t magic;
+       unsigned long ioctl_count;
+       struct list_head lhead;
+       struct drm_head *head;
+       int remove_auth_on_close;
+       unsigned long lock_count;
+
+       /*
+        * The user object hash table is global and resides in the
+        * drm_device structure. We protect the lists and hash tables with the
+        * device struct_mutex. A bit coarse-grained but probably the best
+        * option.
+        */
+
+       struct list_head refd_objects;
+
+       struct drm_open_hash refd_object_hash[_DRM_NO_REF_TYPES];
+       struct file *filp;
+       void *driver_priv;
+
+       struct list_head fbs;
+};
+
+/** Wait queue */
+struct drm_queue {
+       atomic_t use_count;             /**< Outstanding uses (+1) */
+       atomic_t finalization;          /**< Finalization in progress */
+       atomic_t block_count;           /**< Count of processes waiting */
+       atomic_t block_read;            /**< Queue blocked for reads */
+       wait_queue_head_t read_queue;   /**< Processes waiting on block_read */
+       atomic_t block_write;           /**< Queue blocked for writes */
+       wait_queue_head_t write_queue;  /**< Processes waiting on block_write */
+#if 1
+       atomic_t total_queued;          /**< Total queued statistic */
+       atomic_t total_flushed;         /**< Total flushes statistic */
+       atomic_t total_locks;           /**< Total locks statistics */
+#endif
+       enum drm_ctx_flags flags;       /**< Context preserving and 2D-only */
+       struct drm_waitlist waitlist;   /**< Pending buffers */
+       wait_queue_head_t flush_queue;  /**< Processes waiting until flush */
+};
+
+/**
+ * Lock data.
+ */
+struct drm_lock_data {
+       struct drm_hw_lock *hw_lock;            /**< Hardware lock */
+       /** Private of lock holder's file (NULL=kernel) */
+       struct drm_file *file_priv;
+       wait_queue_head_t lock_queue;   /**< Queue of blocked processes */
+       unsigned long lock_time;        /**< Time of last lock in jiffies */
+       spinlock_t spinlock;
+       uint32_t kernel_waiters;
+       uint32_t user_waiters;
+       int idle_has_lock;
+};
+
+/**
+ * DMA data.
+ */
+struct drm_device_dma {
+
+       struct drm_buf_entry bufs[DRM_MAX_ORDER + 1];   /**< buffers, grouped by their size order */
+       int buf_count;                  /**< total number of buffers */
+       struct drm_buf **buflist;               /**< Vector of pointers into drm_device_dma::bufs */
+       int seg_count;
+       int page_count;                 /**< number of pages */
+       unsigned long *pagelist;        /**< page list */
+       unsigned long byte_count;
+       enum {
+               _DRM_DMA_USE_AGP = 0x01,
+               _DRM_DMA_USE_SG = 0x02,
+               _DRM_DMA_USE_FB = 0x04,
+               _DRM_DMA_USE_PCI_RO = 0x08
+       } flags;
+
+};
+
+/**
+ * AGP memory entry.  Stored as a doubly linked list.
+ */
+struct drm_agp_mem {
+       unsigned long handle;           /**< handle */
+       DRM_AGP_MEM *memory;
+       unsigned long bound;            /**< address */
+       int pages;
+       struct list_head head;
+};
+
+/**
+ * AGP data.
+ *
+ * \sa drm_agp_init() and drm_device::agp.
+ */
+struct drm_agp_head {
+       DRM_AGP_KERN agp_info;          /**< AGP device information */
+       struct list_head memory;
+       unsigned long mode;             /**< AGP mode */
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11)
+       struct agp_bridge_data *bridge;
+#endif
+       int enabled;                    /**< whether the AGP bus as been enabled */
+       int acquired;                   /**< whether the AGP device has been acquired */
+       unsigned long base;
+       int agp_mtrr;
+       int cant_use_aperture;
+       unsigned long page_mask;
+};
+
+/**
+ * Scatter-gather memory.
+ */
+struct drm_sg_mem {
+       unsigned long handle;
+       void *virtual;
+       int pages;
+       struct page **pagelist;
+       dma_addr_t *busaddr;
+};
+
+struct drm_sigdata {
+       int context;
+       struct drm_hw_lock *lock;
+};
+
+
+/*
+ * Generic memory manager structs
+ */
+
+struct drm_mm_node {
+       struct list_head fl_entry;
+       struct list_head ml_entry;
+       int free;
+       unsigned long start;
+       unsigned long size;
+       struct drm_mm *mm;
+       void *private;
+};
+
+struct drm_mm {
+       struct list_head fl_entry;
+       struct list_head ml_entry;
+};
+
+
+/**
+ * Mappings list
+ */
+struct drm_map_list {
+       struct list_head head;          /**< list head */
+       struct drm_hash_item hash;
+       struct drm_map *map;                    /**< mapping */
+       uint64_t user_token;
+       struct drm_mm_node *file_offset_node;
+};
+
+typedef struct drm_map drm_local_map_t;
+
+/**
+ * Context handle list
+ */
+struct drm_ctx_list {
+       struct list_head head;          /**< list head */
+       drm_context_t handle;           /**< context handle */
+       struct drm_file *tag;           /**< associated fd private data */
+};
+
+struct drm_vbl_sig {
+       struct list_head head;
+       unsigned int sequence;
+       struct siginfo info;
+       struct task_struct *task;
+};
+
+/* location of GART table */
+#define DRM_ATI_GART_MAIN 1
+#define DRM_ATI_GART_FB   2
+
+#define DRM_ATI_GART_PCI 1
+#define DRM_ATI_GART_PCIE 2
+#define DRM_ATI_GART_IGP 3
+
+struct drm_ati_pcigart_info {
+       int gart_table_location;
+       int gart_reg_if;
+       void *addr;
+       dma_addr_t bus_addr;
+       drm_local_map_t mapping;
+       int table_size;
+};
+
+#include "drm_objects.h"
+#include "drm_edid.h"
+#include "drm_crtc.h"
+
+/**
+ * DRM driver structure. This structure represent the common code for
+ * a family of cards. There will one drm_device for each card present
+ * in this family
+ */
+
+struct drm_driver {
+       int (*load) (struct drm_device *, unsigned long flags);
+       int (*firstopen) (struct drm_device *);
+       int (*open) (struct drm_device *, struct drm_file *);
+       void (*preclose) (struct drm_device *, struct drm_file *file_priv);
+       void (*postclose) (struct drm_device *, struct drm_file *);
+       void (*lastclose) (struct drm_device *);
+       int (*unload) (struct drm_device *);
+       int (*suspend) (struct drm_device *);
+       int (*resume) (struct drm_device *);
+       int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
+       void (*dma_ready) (struct drm_device *);
+       int (*dma_quiescent) (struct drm_device *);
+       int (*context_ctor) (struct drm_device *dev, int context);
+       int (*context_dtor) (struct drm_device *dev, int context);
+       int (*kernel_context_switch) (struct drm_device *dev, int old,
+                                     int new);
+       void (*kernel_context_switch_unlock) (struct drm_device *dev);
+       int (*vblank_wait) (struct drm_device *dev, unsigned int *sequence);
+       int (*vblank_wait2) (struct drm_device *dev, unsigned int *sequence);
+       int (*dri_library_name) (struct drm_device *dev, char * buf);
+
+       /**
+        * Called by \c drm_device_is_agp.  Typically used to determine if a
+        * card is really attached to AGP or not.
+        *
+        * \param dev  DRM device handle
+        *
+        * \returns
+        * One of three values is returned depending on whether or not the
+        * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
+        * (return of 1), or may or may not be AGP (return of 2).
+        */
+       int (*device_is_agp) (struct drm_device *dev);
+
+/* these have to be filled in */
+        irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
+       void (*irq_preinstall) (struct drm_device *dev);
+       void (*irq_postinstall) (struct drm_device *dev);
+       void (*irq_uninstall) (struct drm_device *dev);
+       void (*reclaim_buffers) (struct drm_device *dev,
+                                struct drm_file *file_priv);
+       void (*reclaim_buffers_locked) (struct drm_device *dev,
+                                       struct drm_file *file_priv);
+       void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
+                                           struct drm_file *file_priv);
+       unsigned long (*get_map_ofs) (struct drm_map *map);
+       unsigned long (*get_reg_ofs) (struct drm_device *dev);
+       void (*set_version) (struct drm_device *dev,
+                            struct drm_set_version *sv);
+
+       /* FB routines, if present */
+       int (*fb_probe)(struct drm_device *dev, struct drm_crtc *crtc);
+       int (*fb_remove)(struct drm_device *dev, struct drm_crtc *crtc);
+
+       struct drm_fence_driver *fence_driver;
+       struct drm_bo_driver *bo_driver;
+
+       int major;
+       int minor;
+       int patchlevel;
+       char *name;
+       char *desc;
+       char *date;
+
+/* variables */
+       u32 driver_features;
+       int dev_priv_size;
+       struct drm_ioctl_desc *ioctls;
+       int num_ioctls;
+       struct file_operations fops;
+       struct pci_driver pci_driver;
+};
+
+/**
+ * DRM head structure. This structure represent a video head on a card
+ * that may contain multiple heads. Embed one per head of these in the
+ * private drm_device structure.
+ */
+struct drm_head {
+       int minor;                      /**< Minor device number */
+       struct drm_device *dev;
+       struct proc_dir_entry *dev_root;  /**< proc directory entry */
+       dev_t device;                   /**< Device number for mknod */
+       struct class_device *dev_class;
+};
+
+
+/**
+ * DRM device structure. This structure represent a complete card that
+ * may contain multiple heads.
+ */
+struct drm_device {
+       struct device dev;              /**< Linux device */
+       char *unique;                   /**< Unique identifier: e.g., busid */
+       int unique_len;                 /**< Length of unique field */
+       char *devname;                  /**< For /proc/interrupts */
+       int if_version;                 /**< Highest interface version set */
+
+       int blocked;                    /**< Blocked due to VC switch? */
+
+       /** \name Locks */
+       /*@{ */
+       spinlock_t count_lock;          /**< For inuse, drm_device::open_count, drm_device::buf_use */
+       struct mutex struct_mutex;      /**< For others */
+       /*@} */
+
+       /** \name Usage Counters */
+       /*@{ */
+       int open_count;                 /**< Outstanding files open */
+       atomic_t ioctl_count;           /**< Outstanding IOCTLs pending */
+       atomic_t vma_count;             /**< Outstanding vma areas open */
+       int buf_use;                    /**< Buffers in use -- cannot alloc */
+       atomic_t buf_alloc;             /**< Buffer allocation in progress */
+       /*@} */
+
+       /** \name Performance counters */
+       /*@{ */
+       unsigned long counters;
+       enum drm_stat_type types[15];
+       atomic_t counts[15];
+       /*@} */
+
+       /** \name Authentication */
+       /*@{ */
+       struct list_head filelist;
+       struct drm_open_hash magiclist;
+       struct list_head magicfree;
+       /*@} */
+
+       /** \name Memory management */
+       /*@{ */
+       struct list_head maplist;       /**< Linked list of regions */
+       int map_count;                  /**< Number of mappable regions */
+       struct drm_open_hash map_hash;       /**< User token hash table for maps */
+       struct drm_mm offset_manager;        /**< User token manager */
+       struct drm_open_hash object_hash;    /**< User token hash table for objects */
+       struct address_space *dev_mapping;  /**< For unmap_mapping_range() */
+       struct page *ttm_dummy_page;
+
+       /** \name Context handle management */
+       /*@{ */
+       struct list_head ctxlist;       /**< Linked list of context handles */
+       int ctx_count;                  /**< Number of context handles */
+       struct mutex ctxlist_mutex;     /**< For ctxlist */
+
+       struct idr ctx_idr;
+
+       struct list_head vmalist;       /**< List of vmas (for debugging) */
+       struct drm_lock_data lock;              /**< Information on hardware lock */
+       /*@} */
+
+       /** \name DMA queues (contexts) */
+       /*@{ */
+       int queue_count;                /**< Number of active DMA queues */
+       int queue_reserved;             /**< Number of reserved DMA queues */
+       int queue_slots;                /**< Actual length of queuelist */
+       struct drm_queue **queuelist;   /**< Vector of pointers to DMA queues */
+       struct drm_device_dma *dma;             /**< Optional pointer for DMA support */
+       /*@} */
+
+       /** \name Context support */
+       /*@{ */
+       int irq;                        /**< Interrupt used by board */
+       int irq_enabled;                /**< True if irq handler is enabled */
+       __volatile__ long context_flag; /**< Context swapping flag */
+       __volatile__ long interrupt_flag; /**< Interruption handler flag */
+       __volatile__ long dma_flag;     /**< DMA dispatch flag */
+       struct timer_list timer;        /**< Timer for delaying ctx switch */
+       wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */
+       int last_checked;               /**< Last context checked for DMA */
+       int last_context;               /**< Last current context */
+       unsigned long last_switch;      /**< jiffies at last context switch */
+       /*@} */
+
+       struct work_struct work;
+
+       /** \name VBLANK IRQ support */
+       /*@{ */
+
+       wait_queue_head_t vbl_queue;    /**< VBLANK wait queue */
+       atomic_t vbl_received;
+       atomic_t vbl_received2;         /**< number of secondary VBLANK interrupts */
+       spinlock_t vbl_lock;
+       struct list_head vbl_sigs;              /**< signal list to send on VBLANK */
+       struct list_head vbl_sigs2;     /**< signals to send on secondary VBLANK */
+       unsigned int vbl_pending;
+       spinlock_t tasklet_lock;        /**< For drm_locked_tasklet */
+       void (*locked_tasklet_func)(struct drm_device *dev);
+
+       /*@} */
+       cycles_t ctx_start;
+       cycles_t lck_start;
+
+       struct fasync_struct *buf_async;/**< Processes waiting for SIGIO */
+       wait_queue_head_t buf_readers;  /**< Processes waiting to read */
+       wait_queue_head_t buf_writers;  /**< Processes waiting to ctx switch */
+
+       struct drm_agp_head *agp;               /**< AGP data */
+
+       struct pci_dev *pdev;           /**< PCI device structure */
+       int pci_vendor;                 /**< PCI vendor id */
+       int pci_device;                 /**< PCI device id */
+#ifdef __alpha__
+       struct pci_controller *hose;
+#endif
+       struct drm_sg_mem *sg;          /**< Scatter gather memory */
+       void *dev_private;              /**< device private data */
+       struct drm_sigdata sigdata;             /**< For block_all_signals */
+       sigset_t sigmask;
+
+       struct drm_driver *driver;
+       drm_local_map_t *agp_buffer_map;
+       unsigned int agp_buffer_token;
+       struct drm_head primary;                /**< primary screen head */
+
+       struct drm_fence_manager fm;
+       struct drm_buffer_manager bm;
+
+       /** \name Drawable information */
+       /*@{ */
+       spinlock_t drw_lock;
+       struct idr drw_idr;
+       /*@} */
+
+       /* DRM mode setting */
+       struct drm_mode_config mode_config;
+};
+
+#if __OS_HAS_AGP
+struct drm_agp_ttm_backend {
+       struct drm_ttm_backend backend;
+       DRM_AGP_MEM *mem;
+       struct agp_bridge_data *bridge;
+       int populated;
+};
+#endif
+
+typedef struct ati_pcigart_ttm_backend {
+       struct drm_ttm_backend backend;
+       int populated;
+       void (*gart_flush_fn)(struct drm_device *dev);
+       struct drm_ati_pcigart_info *gart_info;
+       unsigned long offset;
+       struct page **pages;
+       int num_pages;
+       int bound;
+       struct drm_device *dev;
+} ati_pcigart_ttm_backend_t;
+
+static __inline__ int drm_core_check_feature(struct drm_device *dev,
+                                            int feature)
+{
+       return ((dev->driver->driver_features & feature) ? 1 : 0);
+}
+
+#ifdef __alpha__
+#define drm_get_pci_domain(dev) dev->hose->index
+#else
+#define drm_get_pci_domain(dev) 0
+#endif
+
+#if __OS_HAS_AGP
+static inline int drm_core_has_AGP(struct drm_device *dev)
+{
+       return drm_core_check_feature(dev, DRIVER_USE_AGP);
+}
+#else
+#define drm_core_has_AGP(dev) (0)
+#endif
+
+#if __OS_HAS_MTRR
+static inline int drm_core_has_MTRR(struct drm_device *dev)
+{
+       return drm_core_check_feature(dev, DRIVER_USE_MTRR);
+}
+
+#define DRM_MTRR_WC            MTRR_TYPE_WRCOMB
+
+static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
+                              unsigned int flags)
+{
+       return mtrr_add(offset, size, flags, 1);
+}
+
+static inline int drm_mtrr_del(int handle, unsigned long offset,
+                              unsigned long size, unsigned int flags)
+{
+       return mtrr_del(handle, offset, size);
+}
+
+#else
+static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
+                              unsigned int flags)
+{
+       return -ENODEV;
+}
+
+static inline int drm_mtrr_del(int handle, unsigned long offset,
+                              unsigned long size, unsigned int flags)
+{
+       return -ENODEV;
+}
+
+#define drm_core_has_MTRR(dev) (0)
+#define DRM_MTRR_WC            0
+#endif
+
+
+/******************************************************************/
+/** \name Internal function definitions */
+/*@{*/
+
+                               /* Driver support (drm_drv.h) */
+extern int drm_fb_loaded;
+extern int drm_init(struct drm_driver *driver,
+                             struct pci_device_id *pciidlist);
+extern void drm_exit(struct drm_driver *driver);
+extern void drm_cleanup_pci(struct pci_dev *pdev);
+extern int drm_ioctl(struct inode *inode, struct file *filp,
+                    unsigned int cmd, unsigned long arg);
+extern long drm_unlocked_ioctl(struct file *filp,
+                              unsigned int cmd, unsigned long arg);
+extern long drm_compat_ioctl(struct file *filp,
+                            unsigned int cmd, unsigned long arg);
+
+extern int drm_lastclose(struct drm_device *dev);
+
+                               /* Device support (drm_fops.h) */
+extern int drm_open(struct inode *inode, struct file *filp);
+extern int drm_stub_open(struct inode *inode, struct file *filp);
+extern int drm_fasync(int fd, struct file *filp, int on);
+extern int drm_release(struct inode *inode, struct file *filp);
+unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
+
+                               /* Mapping support (drm_vm.h) */
+extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
+extern unsigned long drm_core_get_map_ofs(struct drm_map * map);
+extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);
+extern pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma);
+
+                               /* Memory management support (drm_memory.h) */
+#include "drm_memory.h"
+extern void drm_mem_init(void);
+extern int drm_mem_info(char *buf, char **start, off_t offset,
+                       int request, int *eof, void *data);
+extern void *drm_calloc(size_t nmemb, size_t size, int area);
+extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
+extern unsigned long drm_alloc_pages(int order, int area);
+extern void drm_free_pages(unsigned long address, int order, int area);
+extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type);
+extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
+extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
+extern int drm_unbind_agp(DRM_AGP_MEM * handle);
+
+extern void drm_free_memctl(size_t size);
+extern int drm_alloc_memctl(size_t size);
+extern void drm_query_memctl(uint64_t *cur_used,
+                            uint64_t *emer_used,
+                            uint64_t *low_threshold,
+                            uint64_t *high_threshold,
+                            uint64_t *emer_threshold);
+extern void drm_init_memctl(size_t low_threshold,
+                           size_t high_threshold,
+                           size_t unit_size);
+
+                               /* Misc. IOCTL support (drm_ioctl.h) */
+extern int drm_irq_by_busid(struct drm_device *dev, void *data,
+                           struct drm_file *file_priv);
+extern int drm_getunique(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+extern int drm_setunique(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+extern int drm_getmap(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_getclient(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+extern int drm_getstats(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_setversion(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv);
+extern int drm_noop(struct drm_device *dev, void *data,
+                   struct drm_file *file_priv);
+
+                               /* Context IOCTL support (drm_context.h) */
+extern int drm_resctx(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_addctx(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_modctx(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_getctx(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_switchctx(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+extern int drm_newctx(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_rmctx(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv);
+
+extern int drm_ctxbitmap_init(struct drm_device *dev);
+extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
+extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
+
+extern int drm_setsareactx(struct drm_device *dev, void *data,
+                          struct drm_file *file_priv);
+extern int drm_getsareactx(struct drm_device *dev, void *data,
+                          struct drm_file *file_priv);
+
+                               /* Drawable IOCTL support (drm_drawable.h) */
+extern int drm_adddraw(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv);
+extern int drm_rmdraw(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_update_drawable_info(struct drm_device *dev, void *data,
+                                   struct drm_file *file_priv);
+extern struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
+                                                      drm_drawable_t id);
+extern void drm_drawable_free_all(struct drm_device *dev);
+
+                               /* Authentication IOCTL support (drm_auth.h) */
+extern int drm_getmagic(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_authmagic(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+
+                               /* Locking IOCTL support (drm_lock.h) */
+extern int drm_lock(struct drm_device *dev, void *data,
+                   struct drm_file *file_priv);
+extern int drm_unlock(struct drm_device *dev, void *data,
+                     struct drm_file *file_priv);
+extern int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
+extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
+extern void drm_idlelock_take(struct drm_lock_data *lock_data);
+extern void drm_idlelock_release(struct drm_lock_data *lock_data);
+
+/*
+ * These are exported to drivers so that they can implement fencing using
+ * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
+ */
+
+extern int drm_i_have_hw_lock(struct drm_device *dev,
+                             struct drm_file *file_priv);
+
+                               /* Buffer management support (drm_bufs.h) */
+extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
+extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
+extern int drm_addbufs_fb (struct drm_device *dev, struct drm_buf_desc * request);
+extern int drm_addmap(struct drm_device *dev, unsigned int offset,
+                     unsigned int size, enum drm_map_type type,
+                     enum drm_map_flags flags, drm_local_map_t ** map_ptr);
+extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
+                           struct drm_file *file_priv);
+extern int drm_rmmap(struct drm_device *dev, drm_local_map_t *map);
+extern int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *map);
+extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
+                          struct drm_file *file_priv);
+extern int drm_addbufs(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv);
+extern int drm_infobufs(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_markbufs(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_freebufs(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_mapbufs(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv);
+extern int drm_order(unsigned long size);
+extern unsigned long drm_get_resource_start(struct drm_device *dev,
+                                           unsigned int resource);
+extern unsigned long drm_get_resource_len(struct drm_device *dev,
+                                         unsigned int resource);
+extern struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
+                                                 drm_local_map_t *map);
+
+
+                               /* DMA support (drm_dma.h) */
+extern int drm_dma_setup(struct drm_device *dev);
+extern void drm_dma_takedown(struct drm_device *dev);
+extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
+extern void drm_core_reclaim_buffers(struct drm_device *dev,
+                                    struct drm_file *filp);
+
+                               /* IRQ support (drm_irq.h) */
+extern int drm_control(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv);
+extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
+extern int drm_irq_install(struct drm_device *dev);
+extern int drm_irq_uninstall(struct drm_device *dev);
+extern void drm_driver_irq_preinstall(struct drm_device *dev);
+extern void drm_driver_irq_postinstall(struct drm_device *dev);
+extern void drm_driver_irq_uninstall(struct drm_device *dev);
+
+extern int drm_wait_vblank(struct drm_device *dev, void *data,
+                          struct drm_file *file_priv);
+extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
+extern void drm_vbl_send_signals(struct drm_device *dev);
+extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*));
+
+                               /* AGP/GART support (drm_agpsupport.h) */
+extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
+extern int drm_agp_acquire(struct drm_device *dev);
+extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *file_priv);
+extern int drm_agp_release(struct drm_device *dev);
+extern int drm_agp_release_ioctl(struct drm_device *dev, void *data,
+                                struct drm_file *file_priv);
+extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
+extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
+                               struct drm_file *file_priv);
+extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
+extern int drm_agp_info_ioctl(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
+extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv);
+extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
+extern int drm_agp_free_ioctl(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
+extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv);
+extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
+extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+extern DRM_AGP_MEM *drm_agp_allocate_memory(size_t pages, u32 type);
+#else
+extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size_t pages, u32 type);
+#endif
+extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
+extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
+extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
+extern struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev);
+extern void drm_agp_chipset_flush(struct drm_device *dev);
+                               /* Stub support (drm_stub.h) */
+extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
+                    struct drm_driver *driver);
+extern int drm_put_dev(struct drm_device *dev);
+extern int drm_put_head(struct drm_head * head);
+extern unsigned int drm_debug; /* 1 to enable debug output */
+extern unsigned int drm_cards_limit;
+extern struct drm_head **drm_heads;
+extern struct class *drm_class;
+extern struct proc_dir_entry *drm_proc_root;
+
+extern drm_local_map_t *drm_getsarea(struct drm_device *dev);
+
+                               /* Proc support (drm_proc.h) */
+extern int drm_proc_init(struct drm_device *dev,
+                        int minor,
+                        struct proc_dir_entry *root,
+                        struct proc_dir_entry **dev_root);
+extern int drm_proc_cleanup(int minor,
+                           struct proc_dir_entry *root,
+                           struct proc_dir_entry *dev_root);
+
+                               /* Scatter Gather Support (drm_scatter.h) */
+extern void drm_sg_cleanup(struct drm_sg_mem * entry);
+extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv);
+extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
+extern int drm_sg_free(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv);
+
+                              /* ATI PCIGART support (ati_pcigart.h) */
+extern int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info);
+extern int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info);
+extern struct drm_ttm_backend *ati_pcigart_init_ttm(struct drm_device *dev, struct drm_ati_pcigart_info *info, void (*gart_flush_fn)(struct drm_device *dev));
+
+extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
+                          size_t align, dma_addr_t maxaddr);
+extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t *dmah);
+extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t *dmah);
+
+                              /* sysfs support (drm_sysfs.c) */
+struct drm_sysfs_class;
+extern struct class *drm_sysfs_create(struct module *owner, char *name);
+extern void drm_sysfs_destroy(void);
+extern int drm_sysfs_device_add(struct drm_device *dev, struct drm_head *head);
+extern void drm_sysfs_device_remove(struct drm_device *dev);
+
+/*
+ * Basic memory manager support (drm_mm.c)
+ */
+
+extern struct drm_mm_node * drm_mm_get_block(struct drm_mm_node * parent, unsigned long size,
+                                              unsigned alignment);
+extern void drm_mm_put_block(struct drm_mm_node *cur);
+extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size,
+                                               unsigned alignment, int best_match);
+extern int drm_mm_init(struct drm_mm *mm, unsigned long start, unsigned long size);
+extern void drm_mm_takedown(struct drm_mm *mm);
+extern int drm_mm_clean(struct drm_mm *mm);
+extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
+extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size);
+extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size);
+
+static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
+{
+       return block->mm;
+}
+
+extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev);
+extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev);
+
+static __inline__ struct drm_map *drm_core_findmap(struct drm_device *dev,
+                                                  unsigned int token)
+{
+       struct drm_map_list *_entry;
+       list_for_each_entry(_entry, &dev->maplist, head)
+               if (_entry->user_token == token)
+                       return _entry->map;
+       return NULL;
+}
+
+static __inline__ int drm_device_is_agp(struct drm_device *dev)
+{
+       if ( dev->driver->device_is_agp != NULL ) {
+               int err = (*dev->driver->device_is_agp)(dev);
+
+               if (err != 2) {
+                       return err;
+               }
+       }
+
+       return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
+}
+
+static __inline__ int drm_device_is_pcie(struct drm_device *dev)
+{
+       return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP);
+}
+
+static __inline__ void drm_core_dropmap(struct drm_map *map)
+{
+}
+
+#ifndef DEBUG_MEMORY
+/** Wrapper around kmalloc() */
+static __inline__ void *drm_alloc(size_t size, int area)
+{
+       return kmalloc(size, GFP_KERNEL);
+}
+
+/** Wrapper around kfree() */
+static __inline__ void drm_free(void *pt, size_t size, int area)
+{
+       kfree(pt);
+}
+#else
+extern void *drm_alloc(size_t size, int area);
+extern void drm_free(void *pt, size_t size, int area);
+#endif
+
+/*
+ * Accounting variants of standard calls.
+ */
+
+static inline void *drm_ctl_alloc(size_t size, int area)
+{
+       void *ret;
+       if (drm_alloc_memctl(size))
+               return NULL;
+       ret = drm_alloc(size, area);
+       if (!ret)
+               drm_free_memctl(size);
+       return ret;
+}
+
+static inline void *drm_ctl_calloc(size_t nmemb, size_t size, int area)
+{
+       void *ret;
+
+       if (drm_alloc_memctl(nmemb*size))
+               return NULL;
+       ret = drm_calloc(nmemb, size, area);
+       if (!ret)
+               drm_free_memctl(nmemb*size);
+       return ret;
+}
+
+static inline void drm_ctl_free(void *pt, size_t size, int area)
+{
+       drm_free(pt, size, area);
+       drm_free_memctl(size);
+}
+
+static inline size_t drm_size_align(size_t size)
+{
+       size_t tmpSize = 4;
+       if (size > PAGE_SIZE)
+               return PAGE_ALIGN(size);
+
+       while (tmpSize < size)
+               tmpSize <<= 1;
+
+       return (size_t) tmpSize;
+}
+
+
+/*@}*/
+
+#endif                         /* __KERNEL__ */
+#endif
diff --git a/psb-kernel-source-4.41.1/drm_agpsupport.c b/psb-kernel-source-4.41.1/drm_agpsupport.c
new file mode 100644 (file)
index 0000000..5808e21
--- /dev/null
@@ -0,0 +1,652 @@
+/**
+ * \file drm_agpsupport.c
+ * DRM support for AGP/GART backend
+ *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ * \author Gareth Hughes <gareth@valinux.com>
+ */
+
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "drmP.h"
+#include <linux/module.h>
+
+#if __OS_HAS_AGP
+
+/**
+ * Get AGP information.
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a (output) drm_agp_info structure.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device has been initialized and acquired and fills in the
+ * drm_agp_info structure with the information in drm_agp_head::agp_info.
+ */
+int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info)
+{
+       DRM_AGP_KERN *kern;
+
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+
+       kern = &dev->agp->agp_info;
+       info->agp_version_major = kern->version.major;
+       info->agp_version_minor = kern->version.minor;
+       info->mode = kern->mode;
+       info->aperture_base = kern->aper_base;
+       info->aperture_size = kern->aper_size * 1024 * 1024;
+       info->memory_allowed = kern->max_memory << PAGE_SHIFT;
+       info->memory_used = kern->current_memory << PAGE_SHIFT;
+       info->id_vendor = kern->device->vendor;
+       info->id_device = kern->device->device;
+
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_info);
+
+int drm_agp_info_ioctl(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv)
+{
+       struct drm_agp_info *info = data;
+       int err;
+
+       err = drm_agp_info(dev, info);
+       if (err)
+               return err;
+
+       return 0;
+}
+
+/**
+ * Acquire the AGP device.
+ *
+ * \param dev DRM device that is to acquire AGP.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device hasn't been acquired before and calls
+ * \c agp_backend_acquire.
+ */
+int drm_agp_acquire(struct drm_device * dev)
+{
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       int retcode;
+#endif
+
+       if (!dev->agp)
+               return -ENODEV;
+       if (dev->agp->acquired)
+               return -EBUSY;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       if ((retcode = agp_backend_acquire()))
+               return retcode;
+#else
+       if (!(dev->agp->bridge = agp_backend_acquire(dev->pdev)))
+               return -ENODEV;
+#endif
+
+       dev->agp->acquired = 1;
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_acquire);
+
+/**
+ * Acquire the AGP device (ioctl).
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg user argument.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device hasn't been acquired before and calls
+ * \c agp_backend_acquire.
+ */
+int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
+{
+       return drm_agp_acquire((struct drm_device *) file_priv->head->dev);
+}
+
+/**
+ * Release the AGP device.
+ *
+ * \param dev DRM device that is to release AGP.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device has been acquired and calls \c agp_backend_release.
+ */
+int drm_agp_release(struct drm_device *dev)
+{
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       agp_backend_release();
+#else
+       agp_backend_release(dev->agp->bridge);
+#endif
+       dev->agp->acquired = 0;
+       return 0;
+
+}
+EXPORT_SYMBOL(drm_agp_release);
+
+int drm_agp_release_ioctl(struct drm_device *dev, void *data,
+                         struct drm_file *file_priv)
+{
+       return drm_agp_release(dev);
+}
+
+/**
+ * Enable the AGP bus.
+ *
+ * \param dev DRM device that has previously acquired AGP.
+ * \param mode Requested AGP mode.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device has been acquired but not enabled, and calls
+ * \c agp_enable.
+ */
+int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode)
+{
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+
+       dev->agp->mode = mode.mode;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       agp_enable(mode.mode);
+#else
+       agp_enable(dev->agp->bridge, mode.mode);
+#endif
+       dev->agp->enabled = 1;
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_enable);
+
+int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv)
+{
+       struct drm_agp_mode *mode = data;
+
+       return drm_agp_enable(dev, *mode);
+}
+
+/**
+ * Allocate AGP memory.
+ *
+ * \param inode device inode.
+ * \param file_priv file private pointer.
+ * \param cmd command.
+ * \param arg pointer to a drm_agp_buffer structure.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device is present and has been acquired, allocates the
+ * memory via alloc_agp() and creates a drm_agp_mem entry for it.
+ */
+int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
+{
+       struct drm_agp_mem *entry;
+       DRM_AGP_MEM *memory;
+       unsigned long pages;
+       u32 type;
+
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+       if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
+               return -ENOMEM;
+
+       memset(entry, 0, sizeof(*entry));
+
+       pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
+       type = (u32) request->type;
+       if (!(memory = drm_alloc_agp(dev, pages, type))) {
+               drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
+               return -ENOMEM;
+       }
+
+       entry->handle = (unsigned long)memory->key + 1;
+       entry->memory = memory;
+       entry->bound = 0;
+       entry->pages = pages;
+       list_add(&entry->head, &dev->agp->memory);
+
+       request->handle = entry->handle;
+       request->physical = memory->physical;
+
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_alloc);
+
+
+int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
+                       struct drm_file *file_priv)
+{
+       struct drm_agp_buffer *request = data;
+
+       return drm_agp_alloc(dev, request);
+}
+
+/**
+ * Search for the AGP memory entry associated with a handle.
+ *
+ * \param dev DRM device structure.
+ * \param handle AGP memory handle.
+ * \return pointer to the drm_agp_mem structure associated with \p handle.
+ *
+ * Walks through drm_agp_head::memory until finding a matching handle.
+ */
+static struct drm_agp_mem *drm_agp_lookup_entry(struct drm_device * dev,
+                                          unsigned long handle)
+{
+       struct drm_agp_mem *entry;
+
+       list_for_each_entry(entry, &dev->agp->memory, head) {
+               if (entry->handle == handle)
+                       return entry;
+       }
+       return NULL;
+}
+
+/**
+ * Unbind AGP memory from the GATT (ioctl).
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a drm_agp_binding structure.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device is present and acquired, looks-up the AGP memory
+ * entry and passes it to the unbind_agp() function.
+ */
+int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request)
+{
+       struct drm_agp_mem *entry;
+       int ret;
+
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
+               return -EINVAL;
+       if (!entry->bound)
+               return -EINVAL;
+       ret = drm_unbind_agp(entry->memory);
+       if (ret == 0)
+               entry->bound = 0;
+       return ret;
+}
+EXPORT_SYMBOL(drm_agp_unbind);
+
+
+int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
+                        struct drm_file *file_priv)
+{
+       struct drm_agp_binding *request = data;
+
+       return drm_agp_unbind(dev, request);
+}
+
+
+/**
+ * Bind AGP memory into the GATT (ioctl)
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a drm_agp_binding structure.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device is present and has been acquired and that no memory
+ * is currently bound into the GATT. Looks-up the AGP memory entry and passes
+ * it to bind_agp() function.
+ */
+int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request)
+{
+       struct drm_agp_mem *entry;
+       int retcode;
+       int page;
+
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
+               return -EINVAL;
+       if (entry->bound)
+               return -EINVAL;
+       page = (request->offset + PAGE_SIZE - 1) / PAGE_SIZE;
+       if ((retcode = drm_bind_agp(entry->memory, page)))
+               return retcode;
+       entry->bound = dev->agp->base + (page << PAGE_SHIFT);
+       DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
+                 dev->agp->base, entry->bound);
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_bind);
+
+
+int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv)
+{
+       struct drm_agp_binding *request = data;
+
+       return drm_agp_bind(dev, request);
+}
+
+
+/**
+ * Free AGP memory (ioctl).
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a drm_agp_buffer structure.
+ * \return zero on success or a negative number on failure.
+ *
+ * Verifies the AGP device is present and has been acquired and looks up the
+ * AGP memory entry. If the memory it's currently bound, unbind it via
+ * unbind_agp(). Frees it via free_agp() as well as the entry itself
+ * and unlinks from the doubly linked list it's inserted in.
+ */
+int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
+{
+       struct drm_agp_mem *entry;
+
+       if (!dev->agp || !dev->agp->acquired)
+               return -EINVAL;
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
+               return -EINVAL;
+       if (entry->bound)
+               drm_unbind_agp(entry->memory);
+
+       list_del(&entry->head);
+
+       drm_free_agp(entry->memory, entry->pages);
+       drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_free);
+
+
+
+int drm_agp_free_ioctl(struct drm_device *dev, void *data,
+                      struct drm_file *file_priv)
+{
+       struct drm_agp_buffer *request = data;
+
+       return drm_agp_free(dev, request);
+}
+
+
+/**
+ * Initialize the AGP resources.
+ *
+ * \return pointer to a drm_agp_head structure.
+ *
+ * Gets the drm_agp_t structure which is made available by the agpgart module
+ * via the inter_module_* functions. Creates and initializes a drm_agp_head
+ * structure.
+ */
+struct drm_agp_head *drm_agp_init(struct drm_device *dev)
+{
+       struct drm_agp_head *head = NULL;
+
+       if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
+               return NULL;
+       memset((void *)head, 0, sizeof(*head));
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       agp_copy_info(&head->agp_info);
+#else
+       head->bridge = agp_find_bridge(dev->pdev);
+       if (!head->bridge) {
+               if (!(head->bridge = agp_backend_acquire(dev->pdev))) {
+                       drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
+                       return NULL;
+               }
+               agp_copy_info(head->bridge, &head->agp_info);
+               agp_backend_release(head->bridge);
+       } else {
+               agp_copy_info(head->bridge, &head->agp_info);
+       }
+#endif
+       if (head->agp_info.chipset == NOT_SUPPORTED) {
+               drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
+               return NULL;
+       }
+       INIT_LIST_HEAD(&head->memory);
+       head->cant_use_aperture = head->agp_info.cant_use_aperture;
+       head->page_mask = head->agp_info.page_mask;
+       head->base = head->agp_info.aper_base;
+       return head;
+}
+
+/** Calls agp_allocate_memory() */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+DRM_AGP_MEM *drm_agp_allocate_memory(size_t pages, u32 type)
+{
+       return agp_allocate_memory(pages, type);
+}
+#else
+DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge,
+                                    size_t pages, u32 type)
+{
+       return agp_allocate_memory(bridge, pages, type);
+}
+#endif
+
+/** Calls agp_free_memory() */
+int drm_agp_free_memory(DRM_AGP_MEM * handle)
+{
+       if (!handle)
+               return 0;
+       agp_free_memory(handle);
+       return 1;
+}
+
+/** Calls agp_bind_memory() */
+int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start)
+{
+       if (!handle)
+               return -EINVAL;
+       return agp_bind_memory(handle, start);
+}
+EXPORT_SYMBOL(drm_agp_bind_memory);
+
+/** Calls agp_unbind_memory() */
+int drm_agp_unbind_memory(DRM_AGP_MEM * handle)
+{
+       if (!handle)
+               return -EINVAL;
+       return agp_unbind_memory(handle);
+}
+
+
+
+/*
+ * AGP ttm backend interface.
+ */
+
+#ifndef AGP_USER_TYPES
+#define AGP_USER_TYPES (1 << 16)
+#define AGP_USER_MEMORY (AGP_USER_TYPES)
+#define AGP_USER_CACHED_MEMORY (AGP_USER_TYPES + 1)
+#endif
+#define AGP_REQUIRED_MAJOR 0
+#define AGP_REQUIRED_MINOR 102
+
+static int drm_agp_needs_unbind_cache_adjust(struct drm_ttm_backend *backend)
+{
+       return ((backend->flags & DRM_BE_FLAG_BOUND_CACHED) ? 0 : 1);
+}
+
+
+static int drm_agp_populate(struct drm_ttm_backend *backend,
+                           unsigned long num_pages, struct page **pages)
+{
+       struct drm_agp_ttm_backend *agp_be =
+               container_of(backend, struct drm_agp_ttm_backend, backend);
+       struct page **cur_page, **last_page = pages + num_pages;
+       DRM_AGP_MEM *mem;
+
+       DRM_DEBUG("drm_agp_populate_ttm\n");
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
+       mem = drm_agp_allocate_memory(num_pages, AGP_USER_MEMORY);
+#else
+       mem = drm_agp_allocate_memory(agp_be->bridge, num_pages, AGP_USER_MEMORY);
+#endif
+       if (!mem)
+               return -ENOMEM;
+
+       DRM_DEBUG("Current page count is %ld\n", (long) mem->page_count);
+       mem->page_count = 0;
+       for (cur_page = pages; cur_page < last_page; ++cur_page)
+               mem->memory[mem->page_count++] = phys_to_gart(page_to_phys(*cur_page));
+       agp_be->mem = mem;
+       return 0;
+}
+
+static int drm_agp_bind_ttm(struct drm_ttm_backend *backend,
+                           struct drm_bo_mem_reg *bo_mem)
+{
+       struct drm_agp_ttm_backend *agp_be =
+               container_of(backend, struct drm_agp_ttm_backend, backend);
+       DRM_AGP_MEM *mem = agp_be->mem;
+       int ret;
+       int snooped = (bo_mem->flags & DRM_BO_FLAG_CACHED) && !(bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED);
+
+       DRM_DEBUG("drm_agp_bind_ttm\n");
+       mem->is_flushed = TRUE;
+       mem->type = AGP_USER_MEMORY;
+       /* CACHED MAPPED implies not snooped memory */
+       if (snooped)
+               mem->type = AGP_USER_CACHED_MEMORY;
+
+       ret = drm_agp_bind_memory(mem, bo_mem->mm_node->start);
+       if (ret)
+               DRM_ERROR("AGP Bind memory failed\n");
+
+       DRM_FLAG_MASKED(backend->flags, (bo_mem->flags & DRM_BO_FLAG_CACHED) ?
+                       DRM_BE_FLAG_BOUND_CACHED : 0,
+                       DRM_BE_FLAG_BOUND_CACHED);
+       return ret;
+}
+
+static int drm_agp_unbind_ttm(struct drm_ttm_backend *backend)
+{
+       struct drm_agp_ttm_backend *agp_be =
+               container_of(backend, struct drm_agp_ttm_backend, backend);
+
+       DRM_DEBUG("drm_agp_unbind_ttm\n");
+       if (agp_be->mem->is_bound)
+               return drm_agp_unbind_memory(agp_be->mem);
+       else
+               return 0;
+}
+
+static void drm_agp_clear_ttm(struct drm_ttm_backend *backend)
+{
+       struct drm_agp_ttm_backend *agp_be =
+               container_of(backend, struct drm_agp_ttm_backend, backend);
+       DRM_AGP_MEM *mem = agp_be->mem;
+
+       DRM_DEBUG("drm_agp_clear_ttm\n");
+       if (mem) {
+               backend->func->unbind(backend);
+               agp_free_memory(mem);
+       }
+       agp_be->mem = NULL;
+}
+
+static void drm_agp_destroy_ttm(struct drm_ttm_backend *backend)
+{
+       struct drm_agp_ttm_backend *agp_be;
+
+       if (backend) {
+               DRM_DEBUG("drm_agp_destroy_ttm\n");
+               agp_be = container_of(backend, struct drm_agp_ttm_backend, backend);
+               if (agp_be && agp_be->mem)
+                       backend->func->clear(backend);
+       }
+}
+
+static struct drm_ttm_backend_func agp_ttm_backend = {
+       .needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust,
+       .populate = drm_agp_populate,
+       .clear = drm_agp_clear_ttm,
+       .bind = drm_agp_bind_ttm,
+       .unbind = drm_agp_unbind_ttm,
+       .destroy =  drm_agp_destroy_ttm,
+};
+
+struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev)
+{
+
+       struct drm_agp_ttm_backend *agp_be;
+       struct agp_kern_info *info;
+
+       if (!dev->agp) {
+               DRM_ERROR("AGP is not initialized.\n");
+               return NULL;
+       }
+       info = &dev->agp->agp_info;
+
+       if (info->version.major != AGP_REQUIRED_MAJOR ||
+           info->version.minor < AGP_REQUIRED_MINOR) {
+               DRM_ERROR("Wrong agpgart version %d.%d\n"
+                         "\tYou need at least version %d.%d.\n",
+                         info->version.major,
+                         info->version.minor,
+                         AGP_REQUIRED_MAJOR,
+                         AGP_REQUIRED_MINOR);
+               return NULL;
+       }
+
+
+       agp_be = drm_calloc(1, sizeof(*agp_be), DRM_MEM_TTM);
+       if (!agp_be)
+               return NULL;
+
+       agp_be->mem = NULL;
+
+       agp_be->bridge = dev->agp->bridge;
+       agp_be->populated = FALSE;
+       agp_be->backend.func = &agp_ttm_backend;
+       agp_be->backend.dev = dev;
+
+       return &agp_be->backend;
+}
+EXPORT_SYMBOL(drm_agp_init_ttm);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
+void drm_agp_flush_chipset(struct drm_device *dev)
+{
+       agp_flush_chipset(dev->agp->bridge);
+}
+EXPORT_SYMBOL(drm_agp_flush_chipset);
+#endif
+
+#endif                         /* __OS_HAS_AGP */
diff --git a/psb-kernel-source-4.41.1/drm_auth.c b/psb-kernel-source-4.41.1/drm_auth.c
new file mode 100644 (file)
index 0000000..c904a91
--- /dev/null
@@ -0,0 +1,189 @@
+/**
+ * \file drm_auth.c
+ * IOCTLs for authentication
+ *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ * \author Gareth Hughes <gareth@valinux.com>
+ */
+
+/*
+ * Created: Tue Feb  2 08:37:54 1999 by faith@valinux.com
+ *
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "drmP.h"
+
+/**
+ * Find the file with the given magic number.
+ *
+ * \param dev DRM device.
+ * \param magic magic number.
+ *
+ * Searches in drm_device::magiclist within all files with the same hash key
+ * the one with matching magic number, while holding the drm_device::struct_mutex
+ * lock.
+ */
+static struct drm_file *drm_find_file(struct drm_device * dev, drm_magic_t magic)
+{
+       struct drm_file *retval = NULL;
+       struct drm_magic_entry *pt;
+       struct drm_hash_item *hash;
+
+       mutex_lock(&dev->struct_mutex);
+       if (!drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
+               pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
+               retval = pt->priv;
+       }
+       mutex_unlock(&dev->struct_mutex);
+       return retval;
+}
+
+/**
+ * Adds a magic number.
+ *
+ * \param dev DRM device.
+ * \param priv file private data.
+ * \param magic magic number.
+ *
+ * Creates a drm_magic_entry structure and appends to the linked list
+ * associated the magic number hash key in drm_device::magiclist, while holding
+ * the drm_device::struct_mutex lock.
+ */
+static int drm_add_magic(struct drm_device * dev, struct drm_file * priv,
+                        drm_magic_t magic)
+{
+       struct drm_magic_entry *entry;
+
+       DRM_DEBUG("%d\n", magic);
+
+       entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
+       if (!entry)
+               return -ENOMEM;
+       memset(entry, 0, sizeof(*entry));
+       entry->priv = priv;
+       entry->hash_item.key = (unsigned long)magic;
+       mutex_lock(&dev->struct_mutex);
+       drm_ht_insert_item(&dev->magiclist, &entry->hash_item);
+       list_add_tail(&entry->head, &dev->magicfree);
+       mutex_unlock(&dev->struct_mutex);
+
+       return 0;
+}
+
+/**
+ * Remove a magic number.
+ *
+ * \param dev DRM device.
+ * \param magic magic number.
+ *
+ * Searches and unlinks the entry in drm_device::magiclist with the magic
+ * number hash key, while holding the drm_device::struct_mutex lock.
+ */
+static int drm_remove_magic(struct drm_device * dev, drm_magic_t magic)
+{
+       struct drm_magic_entry *pt;
+       struct drm_hash_item *hash;
+
+       DRM_DEBUG("%d\n", magic);
+
+       mutex_lock(&dev->struct_mutex);
+       if (drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
+               mutex_unlock(&dev->struct_mutex);
+               return -EINVAL;
+       }
+       pt = drm_hash_entry(hash, struct drm_magic_entry, hash_item);
+       drm_ht_remove_item(&dev->magiclist, hash);
+       list_del(&pt->head);
+       mutex_unlock(&dev->struct_mutex);
+
+       drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
+
+       return 0;
+}
+
+/**
+ * Get a unique magic number (ioctl).
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a resulting drm_auth structure.
+ * \return zero on success, or a negative number on failure.
+ *
+ * If there is a magic number in drm_file::magic then use it, otherwise
+ * searches an unique non-zero magic number and add it associating it with \p
+ * file_priv.
+ */
+int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
+{
+       static drm_magic_t sequence = 0;
+       static DEFINE_SPINLOCK(lock);
+       struct drm_auth *auth = data;
+
+       /* Find unique magic */
+       if (file_priv->magic) {
+               auth->magic = file_priv->magic;
+       } else {
+               do {
+                       spin_lock(&lock);
+                       if (!sequence)
+                               ++sequence;     /* reserve 0 */
+                       auth->magic = sequence++;
+                       spin_unlock(&lock);
+               } while (drm_find_file(dev, auth->magic));
+               file_priv->magic = auth->magic;
+               drm_add_magic(dev, file_priv, auth->magic);
+       }
+
+       DRM_DEBUG("%u\n", auth->magic);
+
+       return 0;
+}
+
+/**
+ * Authenticate with a magic.
+ *
+ * \param inode device inode.
+ * \param file_priv DRM file private.
+ * \param cmd command.
+ * \param arg pointer to a drm_auth structure.
+ * \return zero if authentication successed, or a negative number otherwise.
+ *
+ * Checks if \p file_priv is associated with the magic number passed in \arg.
+ */
+int drm_authmagic(struct drm_device *dev, void *data,
+                 struct drm_file *file_priv)
+{
+       struct drm_auth *auth = data;
+       struct drm_file *file;
+
+       DRM_DEBUG("%u\n", auth->magic);
+       if ((file = drm_find_file(dev, auth->magic))) {
+               file->authenticated = 1;
+               drm_remove_magic(dev, auth->magic);
+               return 0;
+       }
+       return -EINVAL;
+}
diff --git a/psb-kernel-source-4.41.1/drm_bo.c b/psb-kernel-source-4.41.1/drm_bo.c
new file mode 100644 (file)
index 0000000..7066c3a
--- /dev/null
@@ -0,0 +1,2668 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#include "drmP.h"
+
+/*
+ * Locking may look a bit complicated but isn't really:
+ *
+ * The buffer usage atomic_t needs to be protected by dev->struct_mutex
+ * when there is a chance that it can be zero before or after the operation.
+ *
+ * dev->struct_mutex also protects all lists and list heads,
+ * Hash tables and hash heads.
+ *
+ * bo->mutex protects the buffer object itself excluding the usage field.
+ * bo->mutex does also protect the buffer list heads, so to manipulate those,
+ * we need both the bo->mutex and the dev->struct_mutex.
+ *
+ * Locking order is bo->mutex, dev->struct_mutex. Therefore list traversal
+ * is a bit complicated. When dev->struct_mutex is released to grab bo->mutex,
+ * the list traversal will, in general, need to be restarted.
+ *
+ */
+
+static void drm_bo_destroy_locked(struct drm_buffer_object *bo);
+static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo);
+static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo);
+static void drm_bo_unmap_virtual(struct drm_buffer_object *bo);
+
+static inline uint64_t drm_bo_type_flags(unsigned type)
+{
+       return (1ULL << (24 + type));
+}
+
+/*
+ * bo locked. dev->struct_mutex locked.
+ */
+
+void drm_bo_add_to_pinned_lru(struct drm_buffer_object *bo)
+{
+       struct drm_mem_type_manager *man;
+
+       DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
+       DRM_ASSERT_LOCKED(&bo->mutex);
+
+       man = &bo->dev->bm.man[bo->pinned_mem_type];
+       list_add_tail(&bo->pinned_lru, &man->pinned);
+}
+
+void drm_bo_add_to_lru(struct drm_buffer_object *bo)
+{
+       struct drm_mem_type_manager *man;
+
+       DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
+
+       if (!(bo->mem.mask & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT))
+           || bo->mem.mem_type != bo->pinned_mem_type) {
+               man = &bo->dev->bm.man[bo->mem.mem_type];
+               list_add_tail(&bo->lru, &man->lru);
+       } else {
+               INIT_LIST_HEAD(&bo->lru);
+       }
+}
+
+static int drm_bo_vm_pre_move(struct drm_buffer_object *bo, int old_is_pci)
+{
+#ifdef DRM_ODD_MM_COMPAT
+       int ret;
+
+       if (!bo->map_list.map)
+               return 0;
+
+       ret = drm_bo_lock_kmm(bo);
+       if (ret)
+               return ret;
+       drm_bo_unmap_virtual(bo);
+       if (old_is_pci)
+               drm_bo_finish_unmap(bo);
+#else
+       if (!bo->map_list.map)
+               return 0;
+
+       drm_bo_unmap_virtual(bo);
+#endif
+       return 0;
+}
+
+static void drm_bo_vm_post_move(struct drm_buffer_object *bo)
+{
+#ifdef DRM_ODD_MM_COMPAT
+       int ret;
+
+       if (!bo->map_list.map)
+               return;
+
+       ret = drm_bo_remap_bound(bo);
+       if (ret) {
+               DRM_ERROR("Failed to remap a bound buffer object.\n"
+                         "\tThis might cause a sigbus later.\n");
+       }
+       drm_bo_unlock_kmm(bo);
+#endif
+}
+
+/*
+ * Call bo->mutex locked.
+ */
+
+static int drm_bo_add_ttm(struct drm_buffer_object *bo)
+{
+       struct drm_device *dev = bo->dev;
+       int ret = 0;
+
+       DRM_ASSERT_LOCKED(&bo->mutex);
+       bo->ttm = NULL;
+
+       switch (bo->type) {
+       case drm_bo_type_dc:
+       case drm_bo_type_kernel:
+               bo->ttm = drm_ttm_init(dev, bo->num_pages << PAGE_SHIFT);
+               if (!bo->ttm)
+                       ret = -ENOMEM;
+               break;
+       case drm_bo_type_user:
+               bo->ttm = drm_ttm_init(dev, bo->num_pages << PAGE_SHIFT);
+               if (!bo->ttm)
+                       ret = -ENOMEM;
+
+               ret = drm_ttm_set_user(bo->ttm, current,
+                                      bo->mem.mask & DRM_BO_FLAG_WRITE,
+                                      bo->buffer_start,
+                                      bo->num_pages,
+                                      dev->bm.dummy_read_page);
+               if (ret)
+                       return ret;
+
+               break;
+       default:
+               DRM_ERROR("Illegal buffer object type\n");
+               ret = -EINVAL;
+               break;
+       }
+
+       return ret;
+}
+
+static int drm_bo_handle_move_mem(struct drm_buffer_object *bo,
+                                 struct drm_bo_mem_reg *mem,
+                                 int evict, int no_wait)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+       int old_is_pci = drm_mem_reg_is_pci(dev, &bo->mem);
+       int new_is_pci = drm_mem_reg_is_pci(dev, mem);
+       struct drm_mem_type_manager *old_man = &bm->man[bo->mem.mem_type];
+       struct drm_mem_type_manager *new_man = &bm->man[mem->mem_type];
+       int ret = 0;
+
+       if (old_is_pci || new_is_pci ||
+           ((mem->flags ^ bo->mem.flags) & DRM_BO_FLAG_CACHED))
+               ret = drm_bo_vm_pre_move(bo, old_is_pci);
+       if (ret)
+               return ret;
+
+       /*
+        * Create and bind a ttm if required.
+        */
+
+       if (!(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (bo->ttm == NULL)) {
+               ret = drm_bo_add_ttm(bo);
+               if (ret)
+                       goto out_err;
+
+               if (mem->mem_type != DRM_BO_MEM_LOCAL) {
+                       ret = drm_bind_ttm(bo->ttm, mem);
+                       if (ret)
+                               goto out_err;
+               }
+
+               if (bo->mem.mem_type == DRM_BO_MEM_LOCAL) {
+
+                       struct drm_bo_mem_reg *old_mem = &bo->mem;
+                       uint64_t save_flags = old_mem->flags;
+                       uint64_t save_mask = old_mem->mask;
+                       
+                       *old_mem = *mem;
+                       mem->mm_node = NULL;
+                       old_mem->mask = save_mask;
+                       DRM_FLAG_MASKED(save_flags, mem->flags, 
+                                       DRM_BO_MASK_MEMTYPE);
+                       goto moved;
+               }
+               
+       }
+
+       if (!(old_man->flags & _DRM_FLAG_MEMTYPE_FIXED) &&
+                  !(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED)) {
+
+               ret = drm_bo_move_ttm(bo, evict, no_wait, mem);
+
+       } else if (dev->driver->bo_driver->move) {
+               ret = dev->driver->bo_driver->move(bo, evict, no_wait, mem);
+
+       } else {
+
+               ret = drm_bo_move_memcpy(bo, evict, no_wait, mem);
+
+       }
+
+       if (ret)
+               goto out_err;
+
+moved:
+       if (old_is_pci || new_is_pci)
+               drm_bo_vm_post_move(bo);
+
+       if (bo->priv_flags & _DRM_BO_FLAG_EVICTED) {
+               ret =
+                   dev->driver->bo_driver->invalidate_caches(dev,
+                                                             bo->mem.flags);
+               if (ret)
+                       DRM_ERROR("Can not flush read caches\n");
+       }
+
+       DRM_FLAG_MASKED(bo->priv_flags,
+                       (evict) ? _DRM_BO_FLAG_EVICTED : 0,
+                       _DRM_BO_FLAG_EVICTED);
+
+       if (bo->mem.mm_node)
+               bo->offset = (bo->mem.mm_node->start << PAGE_SHIFT) +
+                       bm->man[bo->mem.mem_type].gpu_offset;
+
+
+       return 0;
+
+out_err:
+       if (old_is_pci || new_is_pci)
+               drm_bo_vm_post_move(bo);
+
+       new_man = &bm->man[bo->mem.mem_type];
+       if ((new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && bo->ttm) {
+               drm_ttm_unbind(bo->ttm);
+               drm_destroy_ttm(bo->ttm);
+               bo->ttm = NULL;
+       }
+
+       return ret;
+}
+
+/*
+ * Call bo->mutex locked.
+ * Wait until the buffer is idle.
+ */
+
+int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int ignore_signals,
+               int no_wait)
+{
+       int ret;
+
+       DRM_ASSERT_LOCKED(&bo->mutex);
+
+       if (bo->fence) {
+               if (drm_fence_object_signaled(bo->fence, bo->fence_type)) {
+                       drm_fence_usage_deref_unlocked(&bo->fence);
+                       return 0;
+               }
+               if (no_wait)
+                       return -EBUSY;
+
+               ret = drm_fence_object_wait(bo->fence, lazy, ignore_signals,
+                                         bo->fence_type);
+               if (ret) {
+                       return ret;
+               }
+
+               drm_fence_usage_deref_unlocked(&bo->fence);
+       }
+       return 0;
+}
+EXPORT_SYMBOL(drm_bo_wait);
+
+static int drm_bo_expire_fence(struct drm_buffer_object *bo, int allow_errors)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+
+       if (bo->fence) {
+               if (bm->nice_mode) {
+                       unsigned long _end = jiffies + 3 * DRM_HZ;
+                       int ret;
+                       do {
+                               ret = drm_bo_wait(bo, 0, 1, 0);
+                               if (ret && allow_errors)
+                                       return ret;
+
+                       } while (ret && !time_after_eq(jiffies, _end));
+
+                       if (bo->fence) {
+                               bm->nice_mode = 0;
+                               DRM_ERROR("Detected GPU lockup or "
+                                         "fence driver was taken down. "
+                                         "Evicting buffer.\n");
+                       }
+               }
+               if (bo->fence)
+                       drm_fence_usage_deref_unlocked(&bo->fence);
+       }
+       return 0;
+}
+
+/*
+ * Call dev->struct_mutex locked.
+ * Attempts to remove all private references to a buffer by expiring its
+ * fence object and removing from lru lists and memory managers.
+ */
+
+static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+
+       DRM_ASSERT_LOCKED(&dev->struct_mutex);
+
+       atomic_inc(&bo->usage);
+       mutex_unlock(&dev->struct_mutex);
+       mutex_lock(&bo->mutex);
+
+       DRM_FLAG_MASKED(bo->priv_flags, 0, _DRM_BO_FLAG_UNFENCED);
+
+       if (bo->fence && drm_fence_object_signaled(bo->fence,
+                                                  bo->fence_type))
+               drm_fence_usage_deref_unlocked(&bo->fence);
+
+       if (bo->fence && remove_all)
+               (void)drm_bo_expire_fence(bo, 0);
+
+       mutex_lock(&dev->struct_mutex);
+
+       if (!atomic_dec_and_test(&bo->usage))
+               goto out;
+
+       if (!bo->fence) {
+               list_del_init(&bo->lru);
+               if (bo->mem.mm_node) {
+                       drm_mm_put_block(bo->mem.mm_node);
+                       if (bo->pinned_node == bo->mem.mm_node)
+                               bo->pinned_node = NULL;
+                       bo->mem.mm_node = NULL;
+               }
+               list_del_init(&bo->pinned_lru);
+               if (bo->pinned_node) {
+                       drm_mm_put_block(bo->pinned_node);
+                       bo->pinned_node = NULL;
+               }
+               list_del_init(&bo->ddestroy);
+               mutex_unlock(&bo->mutex);
+               drm_bo_destroy_locked(bo);
+               return;
+       }
+
+       if (list_empty(&bo->ddestroy)) {
+               drm_fence_object_flush(bo->fence, bo->fence_type);
+               list_add_tail(&bo->ddestroy, &bm->ddestroy);
+               schedule_delayed_work(&bm->wq,
+                                     ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100);
+       }
+
+out:
+       mutex_unlock(&bo->mutex);
+       return;
+}
+
+static void drm_bo_unreserve_size(unsigned long size)
+{
+       drm_free_memctl(size);
+}
+
+/*
+ * Verify that refcount is 0 and that there are no internal references
+ * to the buffer object. Then destroy it.
+ */
+
+static void drm_bo_destroy_locked(struct drm_buffer_object *bo)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+       unsigned long reserved_size;
+
+       DRM_ASSERT_LOCKED(&dev->struct_mutex);
+
+       if (list_empty(&bo->lru) && bo->mem.mm_node == NULL &&
+           list_empty(&bo->pinned_lru) && bo->pinned_node == NULL &&
+           list_empty(&bo->ddestroy) && atomic_read(&bo->usage) == 0) {
+               if (bo->fence != NULL) {
+                       DRM_ERROR("Fence was non-zero.\n");
+                       drm_bo_cleanup_refs(bo, 0);
+                       return;
+               }
+
+#ifdef DRM_ODD_MM_COMPAT
+               BUG_ON(!list_empty(&bo->vma_list));
+               BUG_ON(!list_empty(&bo->p_mm_list));
+#endif
+
+               if (bo->ttm) {
+                       drm_ttm_unbind(bo->ttm);
+                       drm_destroy_ttm(bo->ttm);
+                       bo->ttm = NULL;
+               }
+
+               atomic_dec(&bm->count);
+
+               reserved_size = bo->reserved_size;
+
+               drm_free(bo, sizeof(*bo), DRM_MEM_BUFOBJ);
+               drm_bo_unreserve_size(reserved_size);
+
+               return;
+       }
+
+       /*
+        * Some stuff is still trying to reference the buffer object.
+        * Get rid of those references.
+        */
+
+       drm_bo_cleanup_refs(bo, 0);
+
+       return;
+}
+
+/*
+ * Call dev->struct_mutex locked.
+ */
+
+static void drm_bo_delayed_delete(struct drm_device *dev, int remove_all)
+{
+       struct drm_buffer_manager *bm = &dev->bm;
+
+       struct drm_buffer_object *entry, *nentry;
+       struct list_head *list, *next;
+
+       list_for_each_safe(list, next, &bm->ddestroy) {
+               entry = list_entry(list, struct drm_buffer_object, ddestroy);
+
+               nentry = NULL;
+               if (next != &bm->ddestroy) {
+                       nentry = list_entry(next, struct drm_buffer_object,
+                                           ddestroy);
+                       atomic_inc(&nentry->usage);
+               }
+
+               drm_bo_cleanup_refs(entry, remove_all);
+
+               if (nentry)
+                       atomic_dec(&nentry->usage);
+       }
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+static void drm_bo_delayed_workqueue(void *data)
+#else
+static void drm_bo_delayed_workqueue(struct work_struct *work)
+#endif
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+       struct drm_device *dev = (struct drm_device *) data;
+       struct drm_buffer_manager *bm = &dev->bm;
+#else
+       struct drm_buffer_manager *bm =
+           container_of(work, struct drm_buffer_manager, wq.work);
+       struct drm_device *dev = container_of(bm, struct drm_device, bm);
+#endif
+
+       DRM_DEBUG("Delayed delete Worker\n");
+
+       mutex_lock(&dev->struct_mutex);
+       if (!bm->initialized) {
+               mutex_unlock(&dev->struct_mutex);
+               return;
+       }
+       drm_bo_delayed_delete(dev, 0);
+       if (bm->initialized && !list_empty(&bm->ddestroy)) {
+               schedule_delayed_work(&bm->wq,
+                                     ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100);
+       }
+       mutex_unlock(&dev->struct_mutex);
+}
+
+void drm_bo_usage_deref_locked(struct drm_buffer_object **bo)
+{
+       struct drm_buffer_object *tmp_bo = *bo;
+       bo = NULL;
+
+       DRM_ASSERT_LOCKED(&tmp_bo->dev->struct_mutex);
+
+       if (atomic_dec_and_test(&tmp_bo->usage))
+               drm_bo_destroy_locked(tmp_bo);
+}
+EXPORT_SYMBOL(drm_bo_usage_deref_locked);
+
+static void drm_bo_base_deref_locked(struct drm_file *file_priv,
+                                    struct drm_user_object *uo)
+{
+       struct drm_buffer_object *bo =
+           drm_user_object_entry(uo, struct drm_buffer_object, base);
+
+       DRM_ASSERT_LOCKED(&bo->dev->struct_mutex);
+
+       drm_bo_takedown_vm_locked(bo);
+       drm_bo_usage_deref_locked(&bo);
+}
+
+void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo)
+{
+       struct drm_buffer_object *tmp_bo = *bo;
+       struct drm_device *dev = tmp_bo->dev;
+
+       *bo = NULL;
+       if (atomic_dec_and_test(&tmp_bo->usage)) {
+               mutex_lock(&dev->struct_mutex);
+               if (atomic_read(&tmp_bo->usage) == 0)
+                       drm_bo_destroy_locked(tmp_bo);
+               mutex_unlock(&dev->struct_mutex);
+       }
+}
+EXPORT_SYMBOL(drm_bo_usage_deref_unlocked);
+
+void drm_putback_buffer_objects(struct drm_device *dev)
+{
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct list_head *list = &bm->unfenced;
+       struct drm_buffer_object *entry, *next;
+
+       mutex_lock(&dev->struct_mutex);
+       list_for_each_entry_safe(entry, next, list, lru) {
+               atomic_inc(&entry->usage);
+               mutex_unlock(&dev->struct_mutex);
+
+               mutex_lock(&entry->mutex);
+               BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED));
+               mutex_lock(&dev->struct_mutex);
+
+               list_del_init(&entry->lru);
+               DRM_FLAG_MASKED(entry->priv_flags, 0, _DRM_BO_FLAG_UNFENCED);
+               wake_up_all(&entry->event_queue);
+
+               /*
+                * FIXME: Might want to put back on head of list
+                * instead of tail here.
+                */
+
+               drm_bo_add_to_lru(entry);
+               mutex_unlock(&entry->mutex);
+               drm_bo_usage_deref_locked(&entry);
+       }
+       mutex_unlock(&dev->struct_mutex);
+}
+EXPORT_SYMBOL(drm_putback_buffer_objects);
+
+
+/*
+ * Note. The caller has to register (if applicable)
+ * and deregister fence object usage.
+ */
+
+int drm_fence_buffer_objects(struct drm_device *dev,
+                            struct list_head *list,
+                            uint32_t fence_flags,
+                            struct drm_fence_object *fence,
+                            struct drm_fence_object **used_fence)
+{
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct drm_buffer_object *entry;
+       uint32_t fence_type = 0;
+       uint32_t fence_class = ~0;
+       int count = 0;
+       int ret = 0;
+       struct list_head *l;
+
+       mutex_lock(&dev->struct_mutex);
+
+       if (!list)
+               list = &bm->unfenced;
+
+       if (fence)
+               fence_class = fence->fence_class;
+
+       list_for_each_entry(entry, list, lru) {
+               BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED));
+               fence_type |= entry->new_fence_type;
+               if (fence_class == ~0)
+                       fence_class = entry->new_fence_class;
+               else if (entry->new_fence_class != fence_class) {
+                       DRM_ERROR("Unmatching fence classes on unfenced list: "
+                                 "%d and %d.\n",
+                                 fence_class,
+                                 entry->new_fence_class);
+                       ret = -EINVAL;
+                       goto out;
+               }
+               count++;
+       }
+
+       if (!count) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       if (fence) {
+               if ((fence_type & fence->type) != fence_type ||
+                   (fence->fence_class != fence_class)) {
+                       DRM_ERROR("Given fence doesn't match buffers "
+                                 "on unfenced list.\n");
+                       ret = -EINVAL;
+                       goto out;
+               }
+       } else {
+               mutex_unlock(&dev->struct_mutex);
+               ret = drm_fence_object_create(dev, fence_class, fence_type,
+                                             fence_flags | DRM_FENCE_FLAG_EMIT,
+                                             &fence);
+               mutex_lock(&dev->struct_mutex);
+               if (ret)
+                       goto out;
+       }
+
+       count = 0;
+       l = list->next;
+       while (l != list) {
+               prefetch(l->next);
+               entry = list_entry(l, struct drm_buffer_object, lru);
+               atomic_inc(&entry->usage);
+               mutex_unlock(&dev->struct_mutex);
+               mutex_lock(&entry->mutex);
+               mutex_lock(&dev->struct_mutex);
+               list_del_init(l);
+               if (entry->priv_flags & _DRM_BO_FLAG_UNFENCED) {
+                       count++;
+                       if (entry->fence)
+                               drm_fence_usage_deref_locked(&entry->fence);
+                       entry->fence = drm_fence_reference_locked(fence);
+                       entry->fence_class = entry->new_fence_class;
+                       entry->fence_type = entry->new_fence_type;
+                       DRM_FLAG_MASKED(entry->priv_flags, 0,
+                                       _DRM_BO_FLAG_UNFENCED);
+                       wake_up_all(&entry->event_queue);
+                       drm_bo_add_to_lru(entry);
+               }
+               mutex_unlock(&entry->mutex);
+               drm_bo_usage_deref_locked(&entry);
+               l = list->next;
+       }
+       DRM_DEBUG("Fenced %d buffers\n", count);
+out:
+       mutex_unlock(&dev->struct_mutex);
+       *used_fence = fence;
+       return ret;
+}
+EXPORT_SYMBOL(drm_fence_buffer_objects);
+
+/*
+ * bo->mutex locked
+ */
+
+static int drm_bo_evict(struct drm_buffer_object *bo, unsigned mem_type,
+                       int no_wait)
+{
+       int ret = 0;
+       struct drm_device *dev = bo->dev;
+       struct drm_bo_mem_reg evict_mem;
+
+       /*
+        * Someone might have modified the buffer before we took the
+        * buffer mutex.
+        */
+
+       if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)
+               goto out;
+       if (bo->mem.mem_type != mem_type)
+               goto out;
+
+       ret = drm_bo_wait(bo, 0, 0, no_wait);
+
+       if (ret && ret != -EAGAIN) {
+               DRM_ERROR("Failed to expire fence before "
+                         "buffer eviction.\n");
+               goto out;
+       }
+
+       evict_mem = bo->mem;
+       evict_mem.mm_node = NULL;
+
+       evict_mem = bo->mem;
+       evict_mem.mask = dev->driver->bo_driver->evict_mask(bo);
+       ret = drm_bo_mem_space(bo, &evict_mem, no_wait);
+
+       if (ret) {
+               if (ret != -EAGAIN)
+                       DRM_ERROR("Failed to find memory space for "
+                                 "buffer 0x%p eviction.\n", bo);
+               goto out;
+       }
+
+       ret = drm_bo_handle_move_mem(bo, &evict_mem, 1, no_wait);
+
+       if (ret) {
+               if (ret != -EAGAIN)
+                       DRM_ERROR("Buffer eviction failed\n");
+               goto out;
+       }
+
+       mutex_lock(&dev->struct_mutex);
+       if (evict_mem.mm_node) {
+               if (evict_mem.mm_node != bo->pinned_node)
+                       drm_mm_put_block(evict_mem.mm_node);
+               evict_mem.mm_node = NULL;
+       }
+       list_del(&bo->lru);
+       drm_bo_add_to_lru(bo);
+       mutex_unlock(&dev->struct_mutex);
+
+       DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_EVICTED,
+                       _DRM_BO_FLAG_EVICTED);
+
+out:
+       return ret;
+}
+
+/**
+ * Repeatedly evict memory from the LRU for @mem_type until we create enough
+ * space, or we've evicted everything and there isn't enough space.
+ */
+static int drm_bo_mem_force_space(struct drm_device *dev,
+                                 struct drm_bo_mem_reg *mem,
+                                 uint32_t mem_type, int no_wait)
+{
+       struct drm_mm_node *node;
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct drm_buffer_object *entry;
+       struct drm_mem_type_manager *man = &bm->man[mem_type];
+       struct list_head *lru;
+       unsigned long num_pages = mem->num_pages;
+       int ret;
+
+       mutex_lock(&dev->struct_mutex);
+       do {
+               node = drm_mm_search_free(&man->manager, num_pages,
+                                         mem->page_alignment, 1);
+               if (node)
+                       break;
+
+               lru = &man->lru;
+               if (lru->next == lru)
+                       break;
+
+               entry = list_entry(lru->next, struct drm_buffer_object, lru);
+               atomic_inc(&entry->usage);
+               mutex_unlock(&dev->struct_mutex);
+               mutex_lock(&entry->mutex);
+               BUG_ON(entry->mem.flags & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT));
+
+               ret = drm_bo_evict(entry, mem_type, no_wait);
+               mutex_unlock(&entry->mutex);
+               drm_bo_usage_deref_unlocked(&entry);
+               if (ret)
+                       return ret;
+               mutex_lock(&dev->struct_mutex);
+       } while (1);
+
+       if (!node) {
+               mutex_unlock(&dev->struct_mutex);
+               return -ENOMEM;
+       }
+
+       node = drm_mm_get_block(node, num_pages, mem->page_alignment);
+       if (!node) {
+               mutex_unlock(&dev->struct_mutex);
+               return -ENOMEM;
+       }
+
+       mutex_unlock(&dev->struct_mutex);
+       mem->mm_node = node;
+       mem->mem_type = mem_type;
+       return 0;
+}
+
+static int drm_bo_mt_compatible(struct drm_mem_type_manager *man,
+                               int disallow_fixed,
+                               uint32_t mem_type,
+                               uint64_t mask, uint32_t *res_mask)
+{
+       uint64_t cur_flags = drm_bo_type_flags(mem_type);
+       uint64_t flag_diff;
+
+       if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && disallow_fixed)
+               return 0;
+       if (man->flags & _DRM_FLAG_MEMTYPE_CACHED)
+               cur_flags |= DRM_BO_FLAG_CACHED;
+       if (man->flags & _DRM_FLAG_MEMTYPE_MAPPABLE)
+               cur_flags |= DRM_BO_FLAG_MAPPABLE;
+       if (man->flags & _DRM_FLAG_MEMTYPE_CSELECT)
+               DRM_FLAG_MASKED(cur_flags, mask, DRM_BO_FLAG_CACHED);
+
+       if ((cur_flags & mask & DRM_BO_MASK_MEM) == 0)
+               return 0;
+
+       if (mem_type == DRM_BO_MEM_LOCAL) {
+               *res_mask = cur_flags;
+               return 1;
+       }
+
+       flag_diff = (mask ^ cur_flags);
+       if (flag_diff & DRM_BO_FLAG_CACHED_MAPPED)
+               cur_flags |= DRM_BO_FLAG_CACHED_MAPPED;
+
+       if ((flag_diff & DRM_BO_FLAG_CACHED) &&
+           (!(mask & DRM_BO_FLAG_CACHED) ||
+            (mask & DRM_BO_FLAG_FORCE_CACHING)))
+               return 0;
+
+       if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
+           ((mask & DRM_BO_FLAG_MAPPABLE) ||
+            (mask & DRM_BO_FLAG_FORCE_MAPPABLE)))
+               return 0;
+
+       *res_mask = cur_flags;
+       return 1;
+}
+
+/**
+ * Creates space for memory region @mem according to its type.
+ *
+ * This function first searches for free space in compatible memory types in
+ * the priority order defined by the driver.  If free space isn't found, then
+ * drm_bo_mem_force_space is attempted in priority order to evict and find
+ * space.
+ */
+int drm_bo_mem_space(struct drm_buffer_object *bo,
+                    struct drm_bo_mem_reg *mem, int no_wait)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct drm_mem_type_manager *man;
+
+       uint32_t num_prios = dev->driver->bo_driver->num_mem_type_prio;
+       const uint32_t *prios = dev->driver->bo_driver->mem_type_prio;
+       uint32_t i;
+       uint32_t mem_type = DRM_BO_MEM_LOCAL;
+       uint32_t cur_flags;
+       int type_found = 0;
+       int type_ok = 0;
+       int has_eagain = 0;
+       struct drm_mm_node *node = NULL;
+       int ret;
+
+       mem->mm_node = NULL;
+       for (i = 0; i < num_prios; ++i) {
+               mem_type = prios[i];
+               man = &bm->man[mem_type];
+
+               type_ok = drm_bo_mt_compatible(man,
+                                              bo->type == drm_bo_type_user,
+                                              mem_type, mem->mask,
+                                              &cur_flags);
+
+               if (!type_ok)
+                       continue;
+
+               if (mem_type == DRM_BO_MEM_LOCAL)
+                       break;
+
+               if ((mem_type == bo->pinned_mem_type) &&
+                   (bo->pinned_node != NULL)) {
+                       node = bo->pinned_node;
+                       break;
+               }
+
+               mutex_lock(&dev->struct_mutex);
+               if (man->has_type && man->use_type) {
+                       type_found = 1;
+                       node = drm_mm_search_free(&man->manager, mem->num_pages,
+                                                 mem->page_alignment, 1);
+                       if (node)
+                               node = drm_mm_get_block(node, mem->num_pages,
+                                                       mem->page_alignment);
+               }
+               mutex_unlock(&dev->struct_mutex);
+               if (node)
+                       break;
+       }
+
+       if ((type_ok && (mem_type == DRM_BO_MEM_LOCAL)) || node) {
+               mem->mm_node = node;
+               mem->mem_type = mem_type;
+               mem->flags = cur_flags;
+               return 0;
+       }
+
+       if (!type_found)
+               return -EINVAL;
+
+       num_prios = dev->driver->bo_driver->num_mem_busy_prio;
+       prios = dev->driver->bo_driver->mem_busy_prio;
+
+       for (i = 0; i < num_prios; ++i) {
+               mem_type = prios[i];
+               man = &bm->man[mem_type];
+
+               if (!man->has_type)
+                       continue;
+
+               if (!drm_bo_mt_compatible(man,
+                                         bo->type == drm_bo_type_user,
+                                         mem_type,
+                                         mem->mask,
+                                         &cur_flags))
+                       continue;
+
+               ret = drm_bo_mem_force_space(dev, mem, mem_type, no_wait);
+
+               if (ret == 0 && mem->mm_node) {
+                       mem->flags = cur_flags;
+                       return 0;
+               }
+
+               if (ret == -EAGAIN)
+                       has_eagain = 1;
+       }
+
+       ret = (has_eagain) ? -EAGAIN : -ENOMEM;
+       return ret;
+}
+EXPORT_SYMBOL(drm_bo_mem_space);
+
+static int drm_bo_new_mask(struct drm_buffer_object *bo,
+                          uint64_t new_flags, uint64_t used_mask)
+{
+       uint32_t new_props;
+
+       if (bo->type == drm_bo_type_user &&
+           ((new_flags & (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING)) !=
+            (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING))) {
+               DRM_ERROR("User buffers require cache-coherent memory.\n");
+               return -EINVAL;
+       }
+
+       if ((used_mask & DRM_BO_FLAG_NO_EVICT) && !DRM_SUSER(DRM_CURPROC)) {
+               DRM_ERROR("DRM_BO_FLAG_NO_EVICT is only available to priviliged processes.\n");
+               return -EPERM;
+       }
+       
+       if (likely(used_mask & DRM_BO_MASK_MEM) && 
+           (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) &&
+           !DRM_SUSER(DRM_CURPROC)) {
+               if (likely(bo->mem.flags & new_flags & used_mask & 
+                          DRM_BO_MASK_MEM)) 
+                       new_flags = (new_flags & ~DRM_BO_MASK_MEM) | 
+                               (bo->mem.flags & DRM_BO_MASK_MEM);
+               else {
+                       DRM_ERROR("Incompatible memory type specification "
+                                 "for NO_EVICT buffer.\n");
+                       return -EPERM;
+               }
+       }
+
+       if ((new_flags & DRM_BO_FLAG_NO_MOVE)) {
+               DRM_ERROR("DRM_BO_FLAG_NO_MOVE is not properly implemented yet.\n");
+               return -EPERM;
+       }
+
+       new_props = new_flags & (DRM_BO_FLAG_EXE | DRM_BO_FLAG_WRITE |
+                                DRM_BO_FLAG_READ);
+
+       if (!new_props) {
+               DRM_ERROR("Invalid buffer object rwx properties\n");
+               return -EINVAL;
+       }
+
+       bo->mem.mask = new_flags;
+       return 0;
+}
+
+/*
+ * Call dev->struct_mutex locked.
+ */
+
+struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv,
+                                             uint32_t handle, int check_owner)
+{
+       struct drm_user_object *uo;
+       struct drm_buffer_object *bo;
+
+       uo = drm_lookup_user_object(file_priv, handle);
+
+       if (!uo || (uo->type != drm_buffer_type)) {
+               DRM_ERROR("Could not find buffer object 0x%08x\n", handle);
+               return NULL;
+       }
+
+       if (check_owner && file_priv != uo->owner) {
+               if (!drm_lookup_ref_object(file_priv, uo, _DRM_REF_USE))
+                       return NULL;
+       }
+
+       bo = drm_user_object_entry(uo, struct drm_buffer_object, base);
+       atomic_inc(&bo->usage);
+       return bo;
+}
+EXPORT_SYMBOL(drm_lookup_buffer_object);
+
+/*
+ * Call bo->mutex locked.
+ * Returns 1 if the buffer is currently rendered to or from. 0 otherwise.
+ * Doesn't do any fence flushing as opposed to the drm_bo_busy function.
+ */
+
+static int drm_bo_quick_busy(struct drm_buffer_object *bo)
+{
+       struct drm_fence_object *fence = bo->fence;
+
+       BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+       if (fence) {
+               if (drm_fence_object_signaled(fence, bo->fence_type)) {
+                       drm_fence_usage_deref_unlocked(&bo->fence);
+                       return 0;
+               }
+               return 1;
+       }
+       return 0;
+}
+
+/*
+ * Call bo->mutex locked.
+ * Returns 1 if the buffer is currently rendered to or from. 0 otherwise.
+ */
+
+static int drm_bo_busy(struct drm_buffer_object *bo)
+{
+       struct drm_fence_object *fence = bo->fence;
+
+       BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+       if (fence) {
+               if (drm_fence_object_signaled(fence, bo->fence_type)) {
+                       drm_fence_usage_deref_unlocked(&bo->fence);
+                       return 0;
+               }
+               drm_fence_object_flush(fence, DRM_FENCE_TYPE_EXE);
+               if (drm_fence_object_signaled(fence, bo->fence_type)) {
+                       drm_fence_usage_deref_unlocked(&bo->fence);
+                       return 0;
+               }
+               return 1;
+       }
+       return 0;
+}
+
+static int drm_bo_evict_cached(struct drm_buffer_object *bo)
+{
+       int ret = 0;
+
+       BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+       if (bo->mem.mm_node)
+               ret = drm_bo_evict(bo, DRM_BO_MEM_TT, 1);
+       return ret;
+}
+
+/*
+ * Wait until a buffer is unmapped.
+ */
+
+static int drm_bo_wait_unmapped(struct drm_buffer_object *bo, int no_wait)
+{
+       int ret = 0;
+
+       if ((atomic_read(&bo->mapped) >= 0) && no_wait)
+               return -EBUSY;
+
+       DRM_WAIT_ON(ret, bo->event_queue, 3 * DRM_HZ,
+                   atomic_read(&bo->mapped) == -1);
+
+       if (ret == -EINTR)
+               ret = -EAGAIN;
+
+       return ret;
+}
+
+static int drm_bo_check_unfenced(struct drm_buffer_object *bo)
+{
+       int ret;
+
+       mutex_lock(&bo->mutex);
+       ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+       mutex_unlock(&bo->mutex);
+       return ret;
+}
+
+/*
+ * Wait until a buffer, scheduled to be fenced moves off the unfenced list.
+ * Until then, we cannot really do anything with it except delete it.
+ */
+
+static int drm_bo_wait_unfenced(struct drm_buffer_object *bo, int no_wait,
+                               int eagain_if_wait)
+{
+       int ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+
+       if (ret && no_wait)
+               return -EBUSY;
+       else if (!ret)
+               return 0;
+
+       ret = 0;
+       mutex_unlock(&bo->mutex);
+       DRM_WAIT_ON(ret, bo->event_queue, 3 * DRM_HZ,
+                   !drm_bo_check_unfenced(bo));
+       mutex_lock(&bo->mutex);
+       if (ret == -EINTR)
+               return -EAGAIN;
+       ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED);
+       if (ret) {
+               DRM_ERROR("Timeout waiting for buffer to become fenced\n");
+               return -EBUSY;
+       }
+       if (eagain_if_wait)
+               return -EAGAIN;
+
+       return 0;
+}
+
+/*
+ * Fill in the ioctl reply argument with buffer info.
+ * Bo locked.
+ */
+
+void drm_bo_fill_rep_arg(struct drm_buffer_object *bo,
+                        struct drm_bo_info_rep *rep)
+{
+       if (!rep)
+               return;
+
+       rep->handle = bo->base.hash.key;
+       rep->flags = bo->mem.flags;
+       rep->size = bo->num_pages * PAGE_SIZE;
+       rep->offset = bo->offset;
+
+       if (bo->type == drm_bo_type_dc)
+               rep->arg_handle = bo->map_list.user_token;
+       else
+               rep->arg_handle = 0;
+
+       rep->mask = bo->mem.mask;
+       rep->buffer_start = bo->buffer_start;
+       rep->fence_flags = bo->fence_type;
+       rep->rep_flags = 0;
+       rep->page_alignment = bo->mem.page_alignment;
+
+       if ((bo->priv_flags & _DRM_BO_FLAG_UNFENCED) || drm_bo_quick_busy(bo)) {
+               DRM_FLAG_MASKED(rep->rep_flags, DRM_BO_REP_BUSY,
+                               DRM_BO_REP_BUSY);
+       }
+}
+EXPORT_SYMBOL(drm_bo_fill_rep_arg);
+
+/*
+ * Wait for buffer idle and register that we've mapped the buffer.
+ * Mapping is registered as a drm_ref_object with type _DRM_REF_TYPE1,
+ * so that if the client dies, the mapping is automatically
+ * unregistered.
+ */
+
+static int drm_buffer_object_map(struct drm_file *file_priv, uint32_t handle,
+                                uint32_t map_flags, unsigned hint,
+                                struct drm_bo_info_rep *rep)
+{
+       struct drm_buffer_object *bo;
+       struct drm_device *dev = file_priv->head->dev;
+       int ret = 0;
+       int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
+
+       mutex_lock(&dev->struct_mutex);
+       bo = drm_lookup_buffer_object(file_priv, handle, 1);
+       mutex_unlock(&dev->struct_mutex);
+
+       if (!bo)
+               return -EINVAL;
+
+       mutex_lock(&bo->mutex);
+       ret = drm_bo_wait_unfenced(bo, no_wait, 0);
+       if (ret)
+               goto out;
+
+       /*
+        * If this returns true, we are currently unmapped.
+        * We need to do this test, because unmapping can
+        * be done without the bo->mutex held.
+        */
+
+       while (1) {
+               if (atomic_inc_and_test(&bo->mapped)) {
+                       if (no_wait && drm_bo_busy(bo)) {
+                               atomic_dec(&bo->mapped);
+                               ret = -EBUSY;
+                               goto out;
+                       }
+
+                       ret = drm_bo_wait(bo, 0, 0, no_wait);
+                       if (ret) {
+                               atomic_dec(&bo->mapped);
+                               goto out;
+                       }
+
+                       if (bo->mem.flags & DRM_BO_FLAG_CACHED_MAPPED)
+                               drm_bo_evict_cached(bo);
+
+                       break;
+               } else if (bo->mem.flags & DRM_BO_FLAG_CACHED_MAPPED) {
+
+                       /*
+                        * We are already mapped with different flags.
+                        * need to wait for unmap.
+                        */
+
+                       ret = drm_bo_wait_unmapped(bo, no_wait);
+                       if (ret)
+                               goto out;
+
+                       continue;
+               }
+               break;
+       }
+
+       mutex_lock(&dev->struct_mutex);
+       ret = drm_add_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
+       mutex_unlock(&dev->struct_mutex);
+       if (ret) {
+               if (atomic_add_negative(-1, &bo->mapped))
+                       wake_up_all(&bo->event_queue);
+
+       } else
+               drm_bo_fill_rep_arg(bo, rep);
+out:
+       mutex_unlock(&bo->mutex);
+       drm_bo_usage_deref_unlocked(&bo);
+       return ret;
+}
+
+static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle)
+{
+       struct drm_device *dev = file_priv->head->dev;
+       struct drm_buffer_object *bo;
+       struct drm_ref_object *ro;
+       int ret = 0;
+
+       mutex_lock(&dev->struct_mutex);
+
+       bo = drm_lookup_buffer_object(file_priv, handle, 1);
+       if (!bo) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       ro = drm_lookup_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1);
+       if (!ro) {
+               ret = -EINVAL;
+               goto out;
+       }
+
+       drm_remove_ref_object(file_priv, ro);
+       drm_bo_usage_deref_locked(&bo);
+out:
+       mutex_unlock(&dev->struct_mutex);
+       return ret;
+}
+
+/*
+ * Call struct-sem locked.
+ */
+
+static void drm_buffer_user_object_unmap(struct drm_file *file_priv,
+                                        struct drm_user_object *uo,
+                                        enum drm_ref_type action)
+{
+       struct drm_buffer_object *bo =
+           drm_user_object_entry(uo, struct drm_buffer_object, base);
+
+       /*
+        * We DON'T want to take the bo->lock here, because we want to
+        * hold it when we wait for unmapped buffer.
+        */
+
+       BUG_ON(action != _DRM_REF_TYPE1);
+
+       if (atomic_add_negative(-1, &bo->mapped))
+               wake_up_all(&bo->event_queue);
+}
+
+/*
+ * bo->mutex locked.
+ * Note that new_mem_flags are NOT transferred to the bo->mem.mask.
+ */
+
+int drm_bo_move_buffer(struct drm_buffer_object *bo, uint64_t new_mem_flags,
+                      int no_wait, int move_unfenced)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+       int ret = 0;
+       struct drm_bo_mem_reg mem;
+       /*
+        * Flush outstanding fences.
+        */
+
+       drm_bo_busy(bo);
+
+       /*
+        * Wait for outstanding fences.
+        */
+
+       ret = drm_bo_wait(bo, 0, 0, no_wait);
+       if (ret)
+               return ret;
+
+       mem.num_pages = bo->num_pages;
+       mem.size = mem.num_pages << PAGE_SHIFT;
+       mem.mask = new_mem_flags;
+       mem.page_alignment = bo->mem.page_alignment;
+
+       mutex_lock(&bm->evict_mutex);
+       mutex_lock(&dev->struct_mutex);
+       list_del_init(&bo->lru);
+       mutex_unlock(&dev->struct_mutex);
+
+       /*
+        * Determine where to move the buffer.
+        */
+       ret = drm_bo_mem_space(bo, &mem, no_wait);
+       if (ret)
+               goto out_unlock;
+
+       ret = drm_bo_handle_move_mem(bo, &mem, 0, no_wait);
+
+out_unlock:
+       mutex_lock(&dev->struct_mutex);
+       if (ret || !move_unfenced) {
+               if (mem.mm_node) {
+                       if (mem.mm_node != bo->pinned_node)
+                               drm_mm_put_block(mem.mm_node);
+                       mem.mm_node = NULL;
+               }
+               drm_bo_add_to_lru(bo);
+               if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) {
+                       wake_up_all(&bo->event_queue);
+                       DRM_FLAG_MASKED(bo->priv_flags, 0,
+                                       _DRM_BO_FLAG_UNFENCED);
+               }
+       } else {
+               list_add_tail(&bo->lru, &bm->unfenced);
+               DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED,
+                               _DRM_BO_FLAG_UNFENCED);
+       }
+       mutex_unlock(&dev->struct_mutex);
+       mutex_unlock(&bm->evict_mutex);
+       return ret;
+}
+
+static int drm_bo_mem_compat(struct drm_bo_mem_reg *mem)
+{
+       uint32_t flag_diff = (mem->mask ^ mem->flags);
+
+       if ((mem->mask & mem->flags & DRM_BO_MASK_MEM) == 0)
+               return 0;
+       if ((flag_diff & DRM_BO_FLAG_CACHED) &&
+           (/* !(mem->mask & DRM_BO_FLAG_CACHED) ||*/
+            (mem->mask & DRM_BO_FLAG_FORCE_CACHING)))
+               return 0;
+
+       if ((flag_diff & DRM_BO_FLAG_MAPPABLE) &&
+           ((mem->mask & DRM_BO_FLAG_MAPPABLE) ||
+            (mem->mask & DRM_BO_FLAG_FORCE_MAPPABLE)))
+               return 0;
+       return 1;
+}
+
+/*
+ * bo locked.
+ */
+
+static int drm_buffer_object_validate(struct drm_buffer_object *bo,
+                                     uint32_t fence_class,
+                                     int move_unfenced, int no_wait)
+{
+       struct drm_device *dev = bo->dev;
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct drm_bo_driver *driver = dev->driver->bo_driver;
+       uint32_t ftype;
+       int ret;
+
+       DRM_DEBUG("New flags 0x%016llx, Old flags 0x%016llx\n",
+                 (unsigned long long) bo->mem.mask,
+                 (unsigned long long) bo->mem.flags);
+
+       ret = driver->fence_type(bo, &fence_class, &ftype);
+
+       if (ret) {
+               DRM_ERROR("Driver did not support given buffer permissions\n");
+               return ret;
+       }
+
+       /*
+        * We're switching command submission mechanism,
+        * or cannot simply rely on the hardware serializing for us.
+        *
+        * Insert a driver-dependant barrier or wait for buffer idle.
+        */
+
+       if ((fence_class != bo->fence_class) ||
+           ((ftype ^ bo->fence_type) & bo->fence_type)) {
+
+               ret = -EINVAL;
+               if (driver->command_stream_barrier) {
+                       ret = driver->command_stream_barrier(bo,
+                                                            fence_class,
+                                                            ftype,
+                                                            no_wait);
+               }
+               if (ret)
+                       ret = drm_bo_wait(bo, 0, 0, no_wait);
+
+               if (ret)
+                       return ret;
+
+       }
+
+       bo->new_fence_class = fence_class;
+       bo->new_fence_type = ftype;
+
+       ret = drm_bo_wait_unmapped(bo, no_wait);
+       if (ret) {
+               DRM_ERROR("Timed out waiting for buffer unmap.\n");
+               return ret;
+       }
+
+       /*
+        * Check whether we need to move buffer.
+        */
+
+       if (!drm_bo_mem_compat(&bo->mem)) {
+               ret = drm_bo_move_buffer(bo, bo->mem.mask, no_wait,
+                                        move_unfenced);
+               if (ret) {
+                       if (ret != -EAGAIN)
+                               DRM_ERROR("Failed moving buffer.\n");
+                       if (ret == -ENOMEM)
+                               DRM_ERROR("Out of aperture space.\n");
+                       return ret;
+               }
+       }
+
+       /*
+        * Pinned buffers.
+        */
+
+       if (bo->mem.mask & (DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE)) {
+               bo->pinned_mem_type = bo->mem.mem_type;
+               mutex_lock(&dev->struct_mutex);
+               list_del_init(&bo->pinned_lru);
+               drm_bo_add_to_pinned_lru(bo);
+
+               if (bo->pinned_node != bo->mem.mm_node) {
+                       if (bo->pinned_node != NULL)
+                               drm_mm_put_block(bo->pinned_node);
+                       bo->pinned_node = bo->mem.mm_node;
+               }
+
+               mutex_unlock(&dev->struct_mutex);
+
+       } else if (bo->pinned_node != NULL) {
+
+               mutex_lock(&dev->struct_mutex);
+
+               if (bo->pinned_node != bo->mem.mm_node)
+                       drm_mm_put_block(bo->pinned_node);
+
+               list_del_init(&bo->pinned_lru);
+               bo->pinned_node = NULL;
+               mutex_unlock(&dev->struct_mutex);
+
+       }
+
+       /*
+        * We might need to add a TTM.
+        */
+
+       if (bo->mem.mem_type == DRM_BO_MEM_LOCAL && bo->ttm == NULL) {
+               ret = drm_bo_add_ttm(bo);
+               if (ret)
+                       return ret;
+       }
+       DRM_FLAG_MASKED(bo->mem.flags, bo->mem.mask, ~DRM_BO_MASK_MEMTYPE);
+
+       /*
+        * Finally, adjust lru to be sure.
+        */
+
+       mutex_lock(&dev->struct_mutex);
+       list_del(&bo->lru);
+       if (move_unfenced) {
+               list_add_tail(&bo->lru, &bm->unfenced);
+               DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED,
+                               _DRM_BO_FLAG_UNFENCED);
+       } else {
+               drm_bo_add_to_lru(bo);
+               if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) {
+                       wake_up_all(&bo->event_queue);
+                       DRM_FLAG_MASKED(bo->priv_flags, 0,
+                                       _DRM_BO_FLAG_UNFENCED);
+               }
+       }
+       mutex_unlock(&dev->struct_mutex);
+
+       return 0;
+}
+
+int drm_bo_do_validate(struct drm_buffer_object *bo,
+                      uint64_t flags, uint64_t mask, uint32_t hint,
+                      uint32_t fence_class,
+                      int no_wait,
+                      struct drm_bo_info_rep *rep)
+{
+       int ret;
+
+       mutex_lock(&bo->mutex);
+       ret = drm_bo_wait_unfenced(bo, no_wait, 0);
+
+       if (ret)
+               goto out;
+
+       DRM_FLAG_MASKED(flags, bo->mem.mask, ~mask);
+       ret = drm_bo_new_mask(bo, flags, mask);
+       if (ret)
+               goto out;
+
+       ret = drm_buffer_object_validate(bo,
+                                        fence_class,
+                                        !(hint & DRM_BO_HINT_DONT_FENCE),
+                                        no_wait);
+out:
+       if (rep)
+               drm_bo_fill_rep_arg(bo, rep);
+
+       mutex_unlock(&bo->mutex);
+       return ret;
+}
+EXPORT_SYMBOL(drm_bo_do_validate);
+
+
+int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle,
+                          uint32_t fence_class,
+                          uint64_t flags, uint64_t mask,
+                          uint32_t hint,
+                          int use_old_fence_class,
+                          struct drm_bo_info_rep *rep,
+                          struct drm_buffer_object **bo_rep)
+{
+       struct drm_device *dev = file_priv->head->dev;
+       struct drm_buffer_object *bo;
+       int ret;
+       int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
+
+       mutex_lock(&dev->struct_mutex);
+       bo = drm_lookup_buffer_object(file_priv, handle, 1);
+       mutex_unlock(&dev->struct_mutex);
+
+       if (!bo)
+               return -EINVAL;
+
+       if (use_old_fence_class)
+               fence_class = bo->fence_class;
+
+       /*
+        * Only allow creator to change shared buffer mask.
+        */
+
+       if (bo->base.owner != file_priv)
+               mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE);
+
+
+       ret = drm_bo_do_validate(bo, flags, mask, hint, fence_class,
+                                no_wait, rep);
+
+       if (!ret && bo_rep)
+               *bo_rep = bo;
+       else
+               drm_bo_usage_deref_unlocked(&bo);
+
+       return ret;
+}
+EXPORT_SYMBOL(drm_bo_handle_validate);
+
+static int drm_bo_handle_info(struct drm_file *file_priv, uint32_t handle,
+                             struct drm_bo_info_rep *rep)
+{
+       struct drm_device *dev = file_priv->head->dev;
+       struct drm_buffer_object *bo;
+
+       mutex_lock(&dev->struct_mutex);
+       bo = drm_lookup_buffer_object(file_priv, handle, 1);
+       mutex_unlock(&dev->struct_mutex);
+
+       if (!bo)
+               return -EINVAL;
+
+       mutex_lock(&bo->mutex);
+       if (!(bo->priv_flags & _DRM_BO_FLAG_UNFENCED))
+               (void)drm_bo_busy(bo);
+       drm_bo_fill_rep_arg(bo, rep);
+       mutex_unlock(&bo->mutex);
+       drm_bo_usage_deref_unlocked(&bo);
+       return 0;
+}
+
+static int drm_bo_handle_wait(struct drm_file *file_priv, uint32_t handle,
+                             uint32_t hint,
+                             struct drm_bo_info_rep *rep)
+{
+       struct drm_device *dev = file_priv->head->dev;
+       struct drm_buffer_object *bo;
+       int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
+       int ret;
+
+       mutex_lock(&dev->struct_mutex);
+       bo = drm_lookup_buffer_object(file_priv, handle, 1);
+       mutex_unlock(&dev->struct_mutex);
+
+       if (!bo)
+               return -EINVAL;
+
+       mutex_lock(&bo->mutex);
+       ret = drm_bo_wait_unfenced(bo, no_wait, 0);
+       if (ret)
+               goto out;
+       ret = drm_bo_wait(bo, hint & DRM_BO_HINT_WAIT_LAZY, 0, no_wait);
+       if (ret)
+               goto out;
+
+       drm_bo_fill_rep_arg(bo, rep);
+
+out:
+       mutex_unlock(&bo->mutex);
+       drm_bo_usage_deref_unlocked(&bo);
+       return ret;
+}
+
+static int drm_bo_reserve_size(struct drm_device *dev,
+                              int user_bo,
+                              unsigned long num_pages,
+                              unsigned long *size)
+{
+       struct drm_bo_driver *driver = dev->driver->bo_driver;
+
+       *size = drm_size_align(sizeof(struct drm_buffer_object)) +
+               /* Always account for a TTM, even for fixed memory types */
+               drm_ttm_size(dev, num_pages, user_bo) +
+               /* user space mapping structure */
+               drm_size_align(sizeof(drm_local_map_t)) +
+               /* file offset space, aperture space, pinned space */
+               3*drm_size_align(sizeof(struct drm_mm_node *)) +
+               /* ttm backend */
+               driver->backend_size(dev, num_pages);
+
+       return drm_alloc_memctl(*size);
+}
+
+int drm_buffer_object_create(struct drm_device *dev,
+                            unsigned long size,
+                            enum drm_bo_type type,
+                            uint64_t mask,
+                            uint32_t hint,
+                            uint32_t page_alignment,
+                            unsigned long buffer_start,
+                            struct drm_buffer_object **buf_obj)
+{
+       struct drm_buffer_manager *bm = &dev->bm;
+       struct drm_buffer_object *bo;
+       int ret = 0;
+       unsigned long num_pages;
+       unsigned long reserved_size;
+
+       size += buffer_start & ~PAGE_MASK;
+       num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       if (num_pages == 0) {
+               DRM_ERROR("Illegal buffer object size.\n");
+               return -EINVAL;
+       }
+
+       ret = drm_bo_reserve_size(dev, type == drm_bo_type_user,
+                                 num_pages, &reserved_size);
+
+       if (ret) {
+               DRM_DEBUG("Failed reserving space for buffer object.\n");
+               return ret;
+       }
+
+       bo = drm_calloc(1, sizeof(*bo), DRM_MEM_BUFOBJ);
+
+       if (!bo) {
+               drm_bo_unreserve_size(num_pages);
+               return -ENOMEM;
+       }
+
+       mutex_init(&bo->mutex);
+       mutex_lock(&bo->mutex);
+
+       bo->reserved_size = reserved_size;
+       atomic_set(&bo->usage, 1);
+       atomic_set(&bo->mapped, -1);
+       DRM_INIT_WAITQUEUE(&bo->event_queue);
+       INIT_LIST_HEAD(&bo->lru);
+       INIT_LIST_HEAD(&bo->pinned_lru);
+       INIT_LIST_HEAD(&bo->ddestroy);
+#ifdef DRM_ODD_MM_COMPAT
+       INIT_LIST_HEAD(&bo->p_mm_list);
+       INIT_LIST_HEAD(&bo->vma_list);
+#endif
+       bo->dev = dev;
+       bo->type = type;
+       bo->num_pages = num_pages;
+       bo->mem.mem_type = DRM_BO_MEM_LOCAL;
+       bo->mem.num_pages = bo->num_pages;
+       bo->mem.mm_node = NULL;
+       bo->mem.page_alignment = page_alignment;
+       bo->buffer_start = buffer_start & PAGE_MASK;
+       bo->priv_flags = 0;
+       bo->mem.flags = DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED |
+               DRM_BO_FLAG_MAPPABLE;
+       bo->mem.mask = DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED |
+               DRM_BO_FLAG_MAPPABLE;
+       atomic_inc(&bm->count);
+       ret = drm_bo_new_mask(bo, mask, mask);
+       if (ret)
+               goto out_err;
+
+       if (bo->type == drm_bo_type_dc) {
+               mutex_lock(&dev->struct_mutex);
+               ret = drm_bo_setup_vm_locked(bo);
+               mutex_unlock(&dev->struct_mutex);
+               if (ret)
+                       goto out_err;
+       }
+
+       ret = drm_buffer_object_validate(bo, 0, 0, hint & DRM_BO_HINT_DONT_BLOCK);
+       if (ret)
+               goto out_err;
+
+       mutex_unlock(&bo->mutex);
+       *buf_obj = bo;
+       return 0;
+
+out_err:
+       mutex_unlock(&bo->mutex);
+
+       drm_bo_usage_deref_unlocked(&bo);
+       return ret;
+}
+EXPORT_SYMBOL(drm_buffer_object_create);
+
+
+static int drm_bo_add_user_object(struct drm_file *file_priv,
+                                 struct drm_buffer_object *bo, int shareable)
+{
+       struct drm_device *dev = file_priv->head->dev;
+       int ret;
+
+       mutex_lock(&dev->struct_mutex);
+       ret = drm_add_user_object(file_priv, &bo->base, shareable);
+       if (ret)
+               goto out;
+
+       bo->base.remove = drm_bo_base_deref_locked;
+       bo->base.type = drm_buffer_type;
+       bo->base.ref_struct_locked = NULL;
+       bo->base.unref = drm_buffer_user_object_unmap;
+
+out:
+       mutex_unlock(&dev->struct_mutex);
+       return ret;
+}
+
+int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
+{
+       struct drm_bo_create_arg *arg = data;
+       struct drm_bo_create_req *req = &arg->d.req;
+       struct drm_bo_info_rep *rep = &arg->d.rep;
+       struct drm_buffer_object *entry;
+       enum drm_bo_type bo_type;
+       int ret = 0;
+
+       DRM_DEBUG("drm_bo_create_ioctl: %dkb, %dkb align\n",
+           (int)(req->size / 1024), req->page_alignment * 4);
+
+       if (!dev->bm.initialized) {
+               DRM_ERROR("Buffer object manager is not initialized.\n");
+               return -EINVAL;
+       }
+
+       bo_type = (req->buffer_start) ? drm_bo_type_user : drm_bo_type_dc;
+
+       if (bo_type == drm_bo_type_user)
+               req->mask &= ~DRM_BO_FLAG_SHAREABLE;
+