Merge commit 'e0067bdc75566629c9143818c8f3970c16c8825e'

Bug: 110964307
Bug: 116741782
Signed-off-by: Alistair Strachan <astrachan@google.com>
Change-Id: I2130490f8fa61743217cbf2081640773960ea843

128 files changed, 16604 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..7efae50
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+*.swp
+*.a
+*.so
+build
+*.txt.user
+*.patch
+py/__pycache__
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..c6d1083
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "ext/pybind11"]
+        path = ext/pybind11
+        url = https://github.com/pybind/pybind11.git
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..353026a
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,81 @@
+# Ubuntu 14.04 Trusty support
+sudo: required
+dist: trusty
+
+# Only build test master & travis
+branches:
+  only:
+  - master
+  - travis
+
+# Enable C++ support
+language: cpp
+
+addons:
+  apt:
+    sources: &sources
+      - ubuntu-toolchain-r-test
+    packages: &packages
+      - libegl1-mesa-dev
+      - libgles2-mesa-dev
+      - libwayland-dev
+      - libx11-xcb-dev
+      - libx11-dev
+      - libgbm-dev
+
+# Need MYCC and MYCXX as travis overwrites CC and CXX
+
+matrix:
+  include:
+    - compiler: gcc
+      addons:
+        apt:
+          sources: *sources
+          packages: [*packages, 'g++-4.8']
+      env: MYCC=gcc-4.8 MYCXX=g++-4.8
+
+    - compiler: gcc
+      addons:
+        apt:
+          sources: *sources
+          packages: [*packages, 'g++-4.9']
+      # g++-4.9 gives a warning, disable it
+      env: MYCC=gcc-4.9 MYCXX=g++-4.9 CXXFLAGS=-Wno-maybe-uninitialized
+
+    - compiler: gcc
+      addons:
+        apt:
+          sources: *sources
+          packages: [*packages, 'g++-5']
+      env: MYCC=gcc-5 MYCXX=g++-5
+
+    - compiler: gcc
+      addons:
+        apt:
+          sources: *sources
+          packages: [*packages, 'g++-6']
+      env: MYCC=gcc-6 MYCXX=g++-6
+
+    - compiler: gcc
+      addons:
+        apt:
+          sources: *sources
+          packages: [*packages, 'g++-7']
+      env: MYCC=gcc-7 MYCXX=g++-7
+
+    - compiler: clang
+      addons:
+        apt:
+          sources: [*sources, 'llvm-toolchain-precise-3.8']
+          packages: [*packages, 'clang-3.8']
+      env: MYCC=clang-3.8 MYCXX=clang++-3.8
+
+# Build steps
+script:
+  - mkdir build
+  - cd build
+  - CC=$MYCC CXX=$MYCXX cmake -DTREAT_WARNINGS_AS_ERRORS=1 -DKMSXX_ENABLE_KMSCUBE=1 -DKMSXX_ENABLE_PYTHON=1 .. && make VERBOSE=1
+
+notifications:
+  email:
+    - tomi.valkeinen@iki.fi
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..57088bc
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,88 @@
+cmake_minimum_required(VERSION 2.8)
+project(kms++)
+
+include(LTO.cmake)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+include(CheckCXXCompilerFlag)
+
+IF(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "Setting build type to 'Release' as none was specified.")
+    SET(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+ENDIF()
+
+string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
+
+option(BUILD_SHARED_LIBS "Build shared libs" FALSE)
+option(TREAT_WARNINGS_AS_ERRORS "Treat warnings as errors" FALSE)
+
+set(KMSXX_ENABLE_PYTHON ON CACHE BOOL "Enable Python wrappers")
+set(KMSXX_PYTHON_VERSION "python3;python2" CACHE STRING "Python pkgconfig package")
+
+set(KMSXX_ENABLE_KMSCUBE OFF CACHE BOOL "Enable kmscube")
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra -Wno-unused-parameter")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wno-unused-parameter")
+
+if (CMAKE_COMPILER_IS_GNUCC)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+        # GCC 4.x seems to warn too much
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-field-initializers")
+    endif()
+endif()
+
+# HACK: cmake always adds "-rdynamic", this removes it
+SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+
+set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+
+if (TREAT_WARNINGS_AS_ERRORS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif()
+
+# static link libc
+# set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++")
+
+check_lto()
+
+if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG)
+    if (LTO_WORKS)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -flto")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+        set(CMAKE_AR "${LTO_AR}")
+        set(CMAKE_RANLIB "${LTO_RANLIB}")
+    endif()
+endif()
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(LIBDRM libdrm>=2.4.64 REQUIRED)
+
+pkg_check_modules(LIBDRM_OMAP libdrm_omap)
+if(LIBDRM_OMAP_FOUND)
+    add_definitions(-DHAS_LIBDRM_OMAP)
+endif()
+
+enable_testing()
+
+add_subdirectory(kms++)
+add_subdirectory(kms++util)
+add_subdirectory(utils)
+
+if(KMSXX_ENABLE_KMSCUBE)
+        add_subdirectory(kmscube)
+endif()
+
+if(KMSXX_ENABLE_PYTHON)
+        add_subdirectory(py)
+endif()
+
+add_custom_target(docs SOURCES "README.md")
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..14e2f77
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/LTO.cmake b/LTO.cmake
new file mode 100644
index 0000000..9a18d77
--- /dev/null
+++ b/LTO.cmake
@@ -0,0 +1,32 @@
+function(check_lto)
+    if (DEFINED LTO_WORKS)
+        return()
+    endif()
+
+    set(LTO_WORKS FALSE CACHE INTERNAL "LTO works")
+
+    CHECK_CXX_COMPILER_FLAG("-flto" HAS_LTO_FLAG)
+
+    if (NOT HAS_LTO_FLAG)
+        return()
+    endif()
+
+    find_program(LTO_AR NAMES "${CMAKE_C_COMPILER}-ar" gcc-ar)
+    find_program(LTO_RANLIB NAMES "${CMAKE_C_COMPILER}-ranlib" gcc-ranlib)
+
+    if (NOT LTO_AR OR NOT LTO_RANLIB)
+        return()
+    endif()
+
+    EXECUTE_PROCESS(COMMAND "${LTO_AR}" --version RESULT_VARIABLE ret OUTPUT_QUIET ERROR_QUIET)
+    if (ret)
+        return()
+    endif()
+
+    EXECUTE_PROCESS(COMMAND "${LTO_RANLIB}" --version RESULT_VARIABLE ret OUTPUT_QUIET ERROR_QUIET)
+    if (ret)
+        return()
+    endif()
+
+    set(LTO_WORKS TRUE CACHE INTERNAL "LTO works")
+endfunction()
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f0f3b97
--- /dev/null
+++ b/README.md
@@ -0,0 +1,99 @@
+[![Build Status](https://travis-ci.org/tomba/kmsxx.svg?branch=master)](https://travis-ci.org/tomba/kmsxx)
+
+# kms++ - C++ library for kernel mode setting
+
+kms++ is a C++11 library for kernel mode setting.
+
+Also included are some simple utilities for KMS and python bindings for kms++.
+
+## Utilities
+
+- kmstest - set modes and planes and show test pattern on crtcs/planes, and test page flips
+- kmsprint - print information about DRM objects
+- kmsview - view raw images
+- kmscube - rotating 3D cube on crtcs/planes
+- kmscapture - show captured frames from a camera on screen
+
+## Dependencies:
+
+- libdrm
+- Python 3.x (for python bindings)
+
+## Build instructions:
+
+To build the Python bindings you need to set up the git-submodule for pybind11:
+
+```
+git submodule update --init
+```
+
+And to compile:
+
+```
+$ mkdir build
+$ cd build
+$ cmake ..
+$ make -j4
+```
+
+## Cross compiling instructions:
+
+Directions for cross compiling depend on your environment.
+
+These are for mine with buildroot:
+
+```
+$ mkdir build
+$ cd build
+$ cmake -DCMAKE_TOOLCHAIN_FILE=<buildrootpath>/output/host/usr/share/buildroot/toolchainfile.cmake ..
+$ make -j4
+```
+
+Your environment may provide similar toolchainfile. If not, you can create a toolchainfile of your own, something along these lines:
+
+```
+SET(CMAKE_SYSTEM_NAME Linux)
+
+SET(BROOT "<buildroot>/output/")
+
+# specify the cross compiler
+SET(CMAKE_C_COMPILER   ${BROOT}/host/usr/bin/arm-buildroot-linux-gnueabihf-gcc)
+SET(CMAKE_CXX_COMPILER ${BROOT}/host/usr/bin/arm-buildroot-linux-gnueabihf-g++)
+
+# where is the target environment
+SET(CMAKE_FIND_ROOT_PATH ${BROOT}/target ${BROOT}/host)
+
+SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+```
+
+## Build options
+
+You can use the following cmake flags to control the build. Use `-DFLAG=VALUE` to set them.
+
+Option name           | Values          | Default         | Notes
+--------------------- | -------------   | --------------- | --------
+CMAKE_BUILD_TYPE      | Release/Debug   | Release         |
+BUILD_SHARED_LIBS     | ON/OFF          | OFF             |
+KMSXX_ENABLE_PYTHON   | ON/OFF          | ON              |
+KMSXX_ENABLE_KMSCUBE  | ON/OFF          | OFF             |
+KMSXX_PYTHON_VERSION  | python3/python2 | python3;python2 | Name of the python pkgconfig file
+
+## Env variables
+
+You can use the following runtime environmental variables to control the behavior of kms++.
+
+Variable                          | Description
+--------------------------------- | -------------
+KMSXX_DISABLE_UNIVERSAL_PLANES    | Set to disable the use of universal planes
+KMSXX_DISABLE_ATOMIC              | Set to disable the use of atomic modesetting
+
+## Python notes
+
+You can run the python code directly from the build dir by defining PYTHONPATH env variable. For example:
+
+```
+PYTHONPATH=build/py py/tests/hpd.py
+
+```
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..9696666
--- /dev/null
+++ b/TODO
@@ -0,0 +1,8 @@
+
+C++ move semantics for classes (especially for Framebuffers)?
+
+Proper error checks and use of exceptions
+
+Free drmModeConnectorPtr (and similar for other drm objects) after use, instead
+of storing it.
+
diff --git a/ext/pybind11 b/ext/pybind11
new file mode 160000
+Subproject 086d53e8c66a84d0ec723d5435918c76edd878e
diff --git a/kms++/CMakeLists.txt b/kms++/CMakeLists.txt
new file mode 100644
index 0000000..10352a2
--- /dev/null
+++ b/kms++/CMakeLists.txt
@@ -0,0 +1,33 @@
+include_directories(${LIBDRM_INCLUDE_DIRS})
+link_directories(${LIBDRM_LIBRARY_DIRS})
+
+include_directories(${LIBDRM_OMAP_INCLUDE_DIRS})
+link_directories(${LIBDRM_OMAP_LIBRARY_DIRS})
+
+file(GLOB SRCS "src/*.cpp" "src/*.h")
+file(GLOB PUB_HDRS "inc/kms++/*.h")
+
+if(LIBDRM_OMAP_FOUND)
+    file(GLOB OMAP_SRCS "src/omap/*.cpp" "src/omap/*.h")
+    file(GLOB OMAP_PUB_HDRS "inc/kms++/omap/*.h")
+
+    set(SRCS ${SRCS} ${OMAP_SRCS})
+    set(PUB_HDRS ${PUB_HDRS} ${OMAP_PUB_HDRS})
+endif()
+
+add_library(kms++ ${SRCS} ${PUB_HDRS})
+
+target_include_directories(kms++ PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/inc>
+    $<INSTALL_INTERFACE:include>
+    PRIVATE src)
+
+target_link_libraries(kms++ ${LIBDRM_LIBRARIES} ${LIBDRM_OMAP_LIBRARIES})
+
+set_target_properties(kms++ PROPERTIES
+    PUBLIC_HEADER "${PUB_HDRS}")
+
+install(TARGETS kms++
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    PUBLIC_HEADER DESTINATION include/kms++)
diff --git a/kms++/inc/kms++/atomicreq.h b/kms++/inc/kms++/atomicreq.h
new file mode 100644
index 0000000..a678b54
--- /dev/null
+++ b/kms++/inc/kms++/atomicreq.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <map>
+
+struct _drmModeAtomicReq;
+
+#include "decls.h"
+
+namespace kms
+{
+class AtomicReq
+{
+public:
+        AtomicReq(Card& card);
+        ~AtomicReq();
+
+        AtomicReq(const AtomicReq& other) = delete;
+        AtomicReq& operator=(const AtomicReq& other) = delete;
+
+        void add(uint32_t ob_id, uint32_t prop_id, uint64_t value);
+        void add(DrmPropObject *ob, Property *prop, uint64_t value);
+        void add(DrmPropObject *ob, const std::string& prop, uint64_t value);
+        void add(DrmPropObject *ob, const std::map<std::string, uint64_t>& values);
+
+        void add_display(Connector* conn, Crtc* crtc, Blob* videomode,
+                         Plane* primary, Framebuffer* fb);
+
+        int test(bool allow_modeset = false);
+        int commit(void* data, bool allow_modeset = false);
+        int commit_sync(bool allow_modeset = false);
+
+private:
+        Card& m_card;
+        _drmModeAtomicReq* m_req;
+};
+
+}
diff --git a/kms++/inc/kms++/blob.h b/kms++/inc/kms++/blob.h
new file mode 100644
index 0000000..fd872f1
--- /dev/null
+++ b/kms++/inc/kms++/blob.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "drmobject.h"
+#include <vector>
+
+namespace kms
+{
+
+class Blob : public DrmObject
+{
+public:
+        Blob(Card& card, uint32_t blob_id);
+        Blob(Card& card, void* data, size_t len);
+        virtual ~Blob();
+
+        std::vector<uint8_t> data();
+
+private:
+        bool m_created;
+};
+
+}
diff --git a/kms++/inc/kms++/card.h b/kms++/inc/kms++/card.h
new file mode 100644
index 0000000..c86278d
--- /dev/null
+++ b/kms++/inc/kms++/card.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <map>
+
+#include "decls.h"
+#include "pipeline.h"
+
+namespace kms
+{
+class Card
+{
+        friend class Framebuffer;
+public:
+        Card();
+        Card(const std::string& device);
+        virtual ~Card();
+
+        Card(const Card& other) = delete;
+        Card& operator=(const Card& other) = delete;
+
+        int fd() const { return m_fd; }
+
+        void drop_master();
+
+        Connector* get_first_connected_connector() const;
+
+        DrmObject* get_object(uint32_t id) const;
+        Connector* get_connector(uint32_t id) const;
+        Crtc* get_crtc(uint32_t id) const;
+        Encoder* get_encoder(uint32_t id) const;
+        Plane* get_plane(uint32_t id) const;
+        Property* get_prop(uint32_t id) const;
+
+        bool master() const { return m_master; }
+        bool has_atomic() const { return m_has_atomic; }
+        bool has_has_universal_planes() const { return m_has_universal_planes; }
+
+        const std::vector<Connector*> get_connectors() const { return m_connectors; }
+        const std::vector<Encoder*> get_encoders() const { return m_encoders; }
+        const std::vector<Crtc*> get_crtcs() const { return m_crtcs; }
+        const std::vector<Plane*> get_planes() const { return m_planes; }
+        const std::vector<Property*> get_properties() const { return m_properties; }
+
+        const std::vector<DrmObject*> get_objects() const;
+
+        std::vector<Pipeline> get_connected_pipelines();
+
+        void call_page_flip_handlers();
+
+        int disable_all();
+
+private:
+        void restore_modes();
+
+        std::map<uint32_t, DrmObject*> m_obmap;
+
+        std::vector<Connector*> m_connectors;
+        std::vector<Encoder*> m_encoders;
+        std::vector<Crtc*> m_crtcs;
+        std::vector<Plane*> m_planes;
+        std::vector<Property*> m_properties;
+        std::vector<Framebuffer*> m_framebuffers;
+
+        int m_fd;
+        bool m_master;
+
+        bool m_has_atomic;
+        bool m_has_universal_planes;
+};
+}
diff --git a/kms++/inc/kms++/connector.h b/kms++/inc/kms++/connector.h
new file mode 100644
index 0000000..3407730
--- /dev/null
+++ b/kms++/inc/kms++/connector.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <vector>
+
+#include "drmpropobject.h"
+#include "videomode.h"
+
+namespace kms
+{
+
+struct ConnectorPriv;
+
+class Connector : public DrmPropObject
+{
+        friend class Card;
+public:
+        void refresh();
+
+        Videomode get_default_mode() const;
+
+        Videomode get_mode(const std::string& mode) const;
+        Videomode get_mode(unsigned xres, unsigned yres, float vrefresh, bool ilace) const;
+
+        Crtc* get_current_crtc() const;
+        std::vector<Crtc*> get_possible_crtcs() const;
+
+        bool connected() const;
+
+        const std::string& fullname() const { return m_fullname; }
+        uint32_t connector_type() const;
+        uint32_t connector_type_id() const;
+        uint32_t mmWidth() const;
+        uint32_t mmHeight() const;
+        uint32_t subpixel() const;
+        const std::string& subpixel_str() const;
+        std::vector<Videomode> get_modes() const;
+        std::vector<Encoder*> get_encoders() const;
+private:
+        Connector(Card& card, uint32_t id, uint32_t idx);
+        ~Connector();
+
+        void setup();
+        void restore_mode();
+
+        ConnectorPriv* m_priv;
+
+        std::string m_fullname;
+
+        Encoder* m_current_encoder;
+
+        Crtc* m_saved_crtc;
+};
+}
diff --git a/kms++/inc/kms++/crtc.h b/kms++/inc/kms++/crtc.h
new file mode 100644
index 0000000..ea20ef8
--- /dev/null
+++ b/kms++/inc/kms++/crtc.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <vector>
+
+#include "drmpropobject.h"
+
+namespace kms
+{
+
+struct CrtcPriv;
+
+class Crtc : public DrmPropObject
+{
+        friend class Card;
+        friend class Connector;
+public:
+        void refresh();
+
+        const std::vector<Plane*>& get_possible_planes() const { return m_possible_planes; }
+
+        int set_mode(Connector* conn, const Videomode& mode);
+        int set_mode(Connector* conn, Framebuffer& fb, const Videomode& mode);
+
+        int set_plane(Plane *plane, Framebuffer &fb,
+                      int32_t dst_x, int32_t dst_y, uint32_t dst_w, uint32_t dst_h,
+                      float src_x, float src_y, float src_w, float src_h);
+        int disable_mode();
+
+        int disable_plane(Plane* plane);
+
+        Plane* get_primary_plane();
+
+        int page_flip(Framebuffer& fb, void *data);
+
+        uint32_t buffer_id() const;
+        uint32_t x() const;
+        uint32_t y() const;
+        uint32_t width() const;
+        uint32_t height() const;
+        int mode_valid() const;
+        Videomode mode() const;
+        int gamma_size() const;
+private:
+        Crtc(Card& card, uint32_t id, uint32_t idx);
+        ~Crtc();
+
+        void setup();
+        void restore_mode(Connector *conn);
+
+        CrtcPriv* m_priv;
+
+        std::vector<Plane*> m_possible_planes;
+};
+}
diff --git a/kms++/inc/kms++/decls.h b/kms++/inc/kms++/decls.h
new file mode 100644
index 0000000..91bce13
--- /dev/null
+++ b/kms++/inc/kms++/decls.h
@@ -0,0 +1,20 @@
+#pragma once
+
+namespace kms
+{
+class AtomicReq;
+class Blob;
+class Card;
+class Connector;
+class Crtc;
+class DrmObject;
+class DrmPropObject;
+class DumbFramebuffer;
+class Encoder;
+class ExtFramebuffer;
+class Framebuffer;
+class PageFlipHandlerBase;
+class Plane;
+class Property;
+struct Videomode;
+}
diff --git a/kms++/inc/kms++/drmobject.h b/kms++/inc/kms++/drmobject.h
new file mode 100644
index 0000000..a939aa7
--- /dev/null
+++ b/kms++/inc/kms++/drmobject.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <map>
+
+#include "decls.h"
+
+namespace kms
+{
+
+class DrmObject
+{
+        friend class Card;
+public:
+        DrmObject(const DrmObject& other) = delete;
+        DrmObject& operator=(const DrmObject& other) = delete;
+
+        uint32_t id() const { return m_id; }
+        Card& card() const { return m_card; }
+
+        uint32_t object_type() const { return m_object_type; }
+        uint32_t idx() const { return m_idx; }
+
+protected:
+        DrmObject(Card& card, uint32_t object_type);
+        DrmObject(Card& card, uint32_t id, uint32_t object_type, uint32_t idx = 0);
+
+        virtual ~DrmObject();
+
+        virtual void setup() { }
+
+        virtual void set_id(uint32_t id);
+
+private:
+        Card& m_card;
+
+        uint32_t m_id;
+        uint32_t m_object_type;
+        uint32_t m_idx;
+};
+}
diff --git a/kms++/inc/kms++/drmpropobject.h b/kms++/inc/kms++/drmpropobject.h
new file mode 100644
index 0000000..38de584
--- /dev/null
+++ b/kms++/inc/kms++/drmpropobject.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <map>
+#include <memory>
+
+#include "drmobject.h"
+#include "decls.h"
+
+namespace kms
+{
+
+class DrmPropObject : public DrmObject
+{
+        friend class Card;
+public:
+        void refresh_props();
+
+        Property* get_prop(const std::string& name) const;
+
+        uint64_t get_prop_value(uint32_t id) const;
+        uint64_t get_prop_value(const std::string& name) const;
+        std::unique_ptr<Blob> get_prop_value_as_blob(const std::string& name) const;
+
+        const std::map<uint32_t, uint64_t>& get_prop_map() const { return m_prop_values; }
+
+        int set_prop_value(uint32_t id, uint64_t value);
+        int set_prop_value(const std::string& name, uint64_t value);
+
+protected:
+        DrmPropObject(Card& card, uint32_t object_type);
+        DrmPropObject(Card& card, uint32_t id, uint32_t object_type, uint32_t idx = 0);
+
+        virtual ~DrmPropObject();
+
+private:
+        std::map<uint32_t, uint64_t> m_prop_values;
+};
+}
diff --git a/kms++/inc/kms++/dumbframebuffer.h b/kms++/inc/kms++/dumbframebuffer.h
new file mode 100644
index 0000000..fb99d0e
--- /dev/null
+++ b/kms++/inc/kms++/dumbframebuffer.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "framebuffer.h"
+#include "pixelformats.h"
+
+namespace kms
+{
+
+class DumbFramebuffer : public Framebuffer
+{
+public:
+        DumbFramebuffer(Card& card, uint32_t width, uint32_t height, const std::string& fourcc);
+        DumbFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format);
+        virtual ~DumbFramebuffer();
+
+        uint32_t width() const { return Framebuffer::width(); }
+        uint32_t height() const { return Framebuffer::height(); }
+
+        PixelFormat format() const { return m_format; }
+        unsigned num_planes() const { return m_num_planes; }
+
+        uint32_t handle(unsigned plane) const { return m_planes[plane].handle; }
+        uint32_t stride(unsigned plane) const { return m_planes[plane].stride; }
+        uint32_t size(unsigned plane) const { return m_planes[plane].size; }
+        uint32_t offset(unsigned plane) const { return m_planes[plane].offset; }
+        uint8_t* map(unsigned plane);
+        int prime_fd(unsigned plane);
+
+private:
+        struct FramebufferPlane {
+                uint32_t handle;
+                int prime_fd;
+                uint32_t size;
+                uint32_t stride;
+                uint32_t offset;
+                uint8_t *map;
+        };
+
+        void Create();
+        void Destroy();
+
+        unsigned m_num_planes;
+        struct FramebufferPlane m_planes[4];
+
+        PixelFormat m_format;
+};
+}
diff --git a/kms++/inc/kms++/encoder.h b/kms++/inc/kms++/encoder.h
new file mode 100644
index 0000000..1d36adc
--- /dev/null
+++ b/kms++/inc/kms++/encoder.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+#include "drmpropobject.h"
+
+namespace kms
+{
+
+struct EncoderPriv;
+
+class Encoder : public DrmPropObject
+{
+        friend class Card;
+public:
+        void refresh();
+
+        Crtc* get_crtc() const;
+        std::vector<Crtc*> get_possible_crtcs() const;
+
+        const std::string& get_encoder_type() const;
+private:
+        Encoder(Card& card, uint32_t id, uint32_t idx);
+        ~Encoder();
+
+        EncoderPriv* m_priv;
+};
+}
diff --git a/kms++/inc/kms++/extframebuffer.h b/kms++/inc/kms++/extframebuffer.h
new file mode 100644
index 0000000..5f0660c
--- /dev/null
+++ b/kms++/inc/kms++/extframebuffer.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "framebuffer.h"
+#include "pixelformats.h"
+
+namespace kms
+{
+
+class ExtFramebuffer : public Framebuffer
+{
+public:
+        ExtFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format,
+                       std::vector<uint32_t> handles, std::vector<uint32_t> pitches, std::vector<uint32_t> offsets);
+        ExtFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format,
+                       std::vector<int> fds, std::vector<uint32_t> pitches, std::vector<uint32_t> offsets);
+        virtual ~ExtFramebuffer();
+
+        uint32_t width() const { return Framebuffer::width(); }
+        uint32_t height() const { return Framebuffer::height(); }
+
+        PixelFormat format() const { return m_format; }
+        unsigned num_planes() const { return m_num_planes; }
+
+        uint32_t handle(unsigned plane) const { return m_planes[plane].handle; }
+        uint32_t stride(unsigned plane) const { return m_planes[plane].stride; }
+        uint32_t size(unsigned plane) const { return m_planes[plane].size; }
+        uint32_t offset(unsigned plane) const { return m_planes[plane].offset; }
+        uint8_t* map(unsigned plane);
+        int prime_fd(unsigned plane);
+
+private:
+        struct FramebufferPlane {
+                uint32_t handle;
+                int prime_fd;
+                uint32_t size;
+                uint32_t stride;
+                uint32_t offset;
+                uint8_t *map;
+        };
+
+        unsigned m_num_planes;
+        struct FramebufferPlane m_planes[4];
+
+        PixelFormat m_format;
+};
+
+}
diff --git a/kms++/inc/kms++/framebuffer.h b/kms++/inc/kms++/framebuffer.h
new file mode 100644
index 0000000..3d43d08
--- /dev/null
+++ b/kms++/inc/kms++/framebuffer.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "drmobject.h"
+#include "pixelformats.h"
+
+namespace kms
+{
+class IFramebuffer {
+public:
+        virtual ~IFramebuffer() { }
+
+        virtual uint32_t width() const = 0;
+        virtual uint32_t height() const = 0;
+
+        virtual PixelFormat format() const { throw std::runtime_error("not implemented"); }
+        virtual unsigned num_planes() const { throw std::runtime_error("not implemented"); }
+
+        virtual uint32_t stride(unsigned plane) const { throw std::runtime_error("not implemented"); }
+        virtual uint32_t size(unsigned plane) const { throw std::runtime_error("not implemented"); }
+        virtual uint32_t offset(unsigned plane) const { throw std::runtime_error("not implemented"); }
+        virtual uint8_t* map(unsigned plane) { throw std::runtime_error("not implemented"); }
+        virtual int prime_fd(unsigned plane) { throw std::runtime_error("not implemented"); }
+};
+
+class Framebuffer : public DrmObject, public IFramebuffer
+{
+public:
+        Framebuffer(Card& card, uint32_t id);
+        virtual ~Framebuffer();
+
+        uint32_t width() const { return m_width; }
+        uint32_t height() const { return m_height; }
+
+        void flush();
+protected:
+        Framebuffer(Card& card, uint32_t width, uint32_t height);
+
+private:
+        uint32_t m_width;
+        uint32_t m_height;
+};
+
+}
diff --git a/kms++/inc/kms++/kms++.h b/kms++/inc/kms++/kms++.h
new file mode 100644
index 0000000..3365ef7
--- /dev/null
+++ b/kms++/inc/kms++/kms++.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "atomicreq.h"
+#include "card.h"
+#include "connector.h"
+#include "crtc.h"
+#include "encoder.h"
+#include "framebuffer.h"
+#include "dumbframebuffer.h"
+#include "extframebuffer.h"
+#include "plane.h"
+#include "property.h"
+#include "blob.h"
+#include "pipeline.h"
+#include "pagefliphandler.h"
diff --git a/kms++/inc/kms++/mode_cvt.h b/kms++/inc/kms++/mode_cvt.h
new file mode 100644
index 0000000..8902e4a
--- /dev/null
+++ b/kms++/inc/kms++/mode_cvt.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <kms++/videomode.h>
+
+namespace kms
+{
+
+Videomode videomode_from_cvt(uint32_t hact, uint32_t vact, uint32_t refresh, bool ilace, bool reduced_v2, bool video_optimized);
+
+}
diff --git a/kms++/inc/kms++/modedb.h b/kms++/inc/kms++/modedb.h
new file mode 100644
index 0000000..b6447c6
--- /dev/null
+++ b/kms++/inc/kms++/modedb.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdint>
+#include "videomode.h"
+
+namespace kms
+{
+struct Videomode;
+
+extern const Videomode dmt_modes[];
+extern const Videomode cea_modes[];
+
+const Videomode& find_dmt(uint32_t width, uint32_t height, float vrefresh, bool ilace);
+const Videomode& find_cea(uint32_t width, uint32_t height, float vrefresh, bool ilace);
+
+}
diff --git a/kms++/inc/kms++/omap/omapcard.h b/kms++/inc/kms++/omap/omapcard.h
new file mode 100644
index 0000000..5c2f3a5
--- /dev/null
+++ b/kms++/inc/kms++/omap/omapcard.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <kms++/card.h>
+
+struct omap_device;
+
+namespace kms
+{
+class OmapCard : public Card
+{
+public:
+        OmapCard();
+        OmapCard(const std::string& device);
+        virtual ~OmapCard();
+
+        struct omap_device* dev() const { return m_omap_dev; }
+
+private:
+        struct omap_device* m_omap_dev;
+};
+}
diff --git a/kms++/inc/kms++/omap/omapframebuffer.h b/kms++/inc/kms++/omap/omapframebuffer.h
new file mode 100644
index 0000000..70bf946
--- /dev/null
+++ b/kms++/inc/kms++/omap/omapframebuffer.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <kms++/framebuffer.h>
+#include <kms++/pixelformats.h>
+
+struct omap_bo;
+
+namespace kms
+{
+class OmapCard;
+
+class OmapFramebuffer : public Framebuffer
+{
+public:
+        enum Flags
+        {
+                None = 0,
+                Tiled = 1 << 0,
+                MemContig = 1 << 1,
+                MemTiler = 1 << 2,
+                MemPin = 1 << 3,
+        };
+
+        OmapFramebuffer(OmapCard& card, uint32_t width, uint32_t height, const std::string& fourcc, Flags flags = Flags::None);
+        OmapFramebuffer(OmapCard& card, uint32_t width, uint32_t height, PixelFormat format, Flags flags = Flags::None);
+        virtual ~OmapFramebuffer();
+
+        uint32_t width() const { return Framebuffer::width(); }
+        uint32_t height() const { return Framebuffer::height(); }
+
+        PixelFormat format() const { return m_format; }
+        unsigned num_planes() const { return m_num_planes; }
+
+        uint32_t handle(unsigned plane) const { return m_planes[plane].handle; }
+        uint32_t stride(unsigned plane) const { return m_planes[plane].stride; }
+        uint32_t size(unsigned plane) const { return m_planes[plane].size; }
+        uint32_t offset(unsigned plane) const { return m_planes[plane].offset; }
+        uint8_t* map(unsigned plane);
+        int prime_fd(unsigned plane);
+
+private:
+        OmapCard& m_omap_card;
+
+        struct FramebufferPlane {
+                struct omap_bo* omap_bo;
+                uint32_t handle;
+                int prime_fd;
+                uint32_t size;
+                uint32_t stride;
+                uint32_t offset;
+                uint8_t* map;
+        };
+
+        void Create(Flags buffer_flags);
+        void Destroy();
+
+        unsigned m_num_planes;
+        struct FramebufferPlane m_planes[3];
+
+        PixelFormat m_format;
+};
+}
diff --git a/kms++/inc/kms++/omap/omapkms++.h b/kms++/inc/kms++/omap/omapkms++.h
new file mode 100644
index 0000000..0d86841
--- /dev/null
+++ b/kms++/inc/kms++/omap/omapkms++.h
@@ -0,0 +1,4 @@
+#pragma once
+
+#include <kms++/omap/omapcard.h>
+#include <kms++/omap/omapframebuffer.h>
diff --git a/kms++/inc/kms++/pagefliphandler.h b/kms++/inc/kms++/pagefliphandler.h
new file mode 100644
index 0000000..79cda0d
--- /dev/null
+++ b/kms++/inc/kms++/pagefliphandler.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace kms {
+class PageFlipHandlerBase
+{
+public:
+        PageFlipHandlerBase() { }
+        virtual ~PageFlipHandlerBase() { }
+        virtual void handle_page_flip(uint32_t frame, double time) = 0;
+};
+}
diff --git a/kms++/inc/kms++/pipeline.h b/kms++/inc/kms++/pipeline.h
new file mode 100644
index 0000000..ef04ec1
--- /dev/null
+++ b/kms++/inc/kms++/pipeline.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "decls.h"
+
+namespace kms
+{
+struct Pipeline {
+        Crtc* crtc;
+        Connector* connector;
+};
+}
diff --git a/kms++/inc/kms++/pixelformats.h b/kms++/inc/kms++/pixelformats.h
new file mode 100644
index 0000000..6392de1
--- /dev/null
+++ b/kms++/inc/kms++/pixelformats.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace kms
+{
+constexpr uint32_t MakeFourCC(const char *fourcc)
+{
+        return fourcc[0] | (fourcc[1] << 8) | (fourcc[2] << 16) | (fourcc[3] << 24);
+}
+
+enum class PixelFormat : uint32_t
+{
+        Undefined = 0,
+
+        NV12 = MakeFourCC("NV12"),
+        NV21 = MakeFourCC("NV21"),
+
+        UYVY = MakeFourCC("UYVY"),
+        YUYV = MakeFourCC("YUYV"),
+        YVYU = MakeFourCC("YVYU"),
+        VYUY = MakeFourCC("VYUY"),
+
+        XRGB8888 = MakeFourCC("XR24"),
+        XBGR8888 = MakeFourCC("XB24"),
+        ARGB8888 = MakeFourCC("AR24"),
+        ABGR8888 = MakeFourCC("AB24"),
+
+        RGB888 = MakeFourCC("RG24"),
+        BGR888 = MakeFourCC("BG24"),
+
+        RGB565 = MakeFourCC("RG16"),
+        BGR565 = MakeFourCC("BG16"),
+};
+
+static inline PixelFormat FourCCToPixelFormat(const std::string& fourcc)
+{
+        return (PixelFormat)MakeFourCC(fourcc.c_str());
+}
+
+static inline std::string PixelFormatToFourCC(PixelFormat f)
+{
+        char buf[5] = { (char)(((int)f >> 0) & 0xff),
+                        (char)(((int)f >> 8) & 0xff),
+                        (char)(((int)f >> 16) & 0xff),
+                        (char)(((int)f >> 24) & 0xff),
+                        0 };
+        return std::string(buf);
+}
+
+struct PixelFormatPlaneInfo
+{
+        uint8_t bitspp;
+        uint8_t xsub;
+        uint8_t ysub;
+};
+
+struct PixelFormatInfo
+{
+        uint8_t num_planes;
+        struct PixelFormatPlaneInfo planes[4];
+};
+
+const struct PixelFormatInfo& get_pixel_format_info(PixelFormat format);
+
+}
diff --git a/kms++/inc/kms++/plane.h b/kms++/inc/kms++/plane.h
new file mode 100644
index 0000000..27e819b
--- /dev/null
+++ b/kms++/inc/kms++/plane.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "drmpropobject.h"
+
+namespace kms
+{
+
+enum class PlaneType
+{
+        Overlay = 1 << 0,
+        Primary = 1 << 1,
+        Cursor = 1 << 2,
+};
+
+struct PlanePriv;
+
+class Plane : public DrmPropObject
+{
+        friend class Card;
+public:
+        bool supports_crtc(Crtc* crtc) const;
+        bool supports_format(PixelFormat fmt) const;
+
+        PlaneType plane_type() const;
+
+        std::vector<Crtc*> get_possible_crtcs() const;
+        std::vector<PixelFormat> get_formats() const;
+        uint32_t crtc_id() const;
+        uint32_t fb_id() const;
+
+        uint32_t crtc_x() const;
+        uint32_t crtc_y() const;
+        uint32_t x() const;
+        uint32_t y() const;
+        uint32_t gamma_size() const;
+private:
+        Plane(Card& card, uint32_t id, uint32_t idx);
+        ~Plane();
+
+        PlanePriv* m_priv;
+};
+}
diff --git a/kms++/inc/kms++/property.h b/kms++/inc/kms++/property.h
new file mode 100644
index 0000000..b9097ff
--- /dev/null
+++ b/kms++/inc/kms++/property.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "drmobject.h"
+#include <map>
+#include <vector>
+
+namespace kms
+{
+
+struct PropertyPriv;
+
+enum class PropertyType
+{
+        Range,
+        Enum,
+        Blob,
+        Bitmask,
+        Object,
+        SignedRange,
+};
+
+class Property : public DrmObject
+{
+        friend class Card;
+public:
+        const std::string& name() const;
+
+        bool is_immutable() const;
+        bool is_pending() const;
+
+        PropertyType type() const { return m_type; }
+        std::map<uint64_t, std::string> get_enums() const;
+        std::vector<uint64_t> get_values() const;
+        std::vector<uint32_t> get_blob_ids() const;
+private:
+        Property(Card& card, uint32_t id);
+        ~Property();
+
+        PropertyType m_type;
+
+        PropertyPriv* m_priv;
+        std::string m_name;
+};
+}
diff --git a/kms++/inc/kms++/videomode.h b/kms++/inc/kms++/videomode.h
new file mode 100644
index 0000000..d7f5258
--- /dev/null
+++ b/kms++/inc/kms++/videomode.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include <memory>
+
+#include "blob.h"
+
+namespace kms
+{
+
+enum class SyncPolarity
+{
+        Undefined,
+        Positive,
+        Negative,
+};
+
+struct Videomode
+{
+        std::string name;
+
+        uint32_t clock;
+        uint16_t hdisplay, hsync_start, hsync_end, htotal, hskew;
+        uint16_t vdisplay, vsync_start, vsync_end, vtotal, vscan;
+
+        uint32_t vrefresh;
+
+        uint32_t flags;         // DRM_MODE_FLAG_*
+        uint32_t type;          // DRM_MODE_TYPE_*
+
+        std::unique_ptr<Blob> to_blob(Card& card) const;
+
+        uint16_t hfp() const { return hsync_start - hdisplay; }
+        uint16_t hsw() const { return hsync_end - hsync_start; }
+        uint16_t hbp() const { return htotal - hsync_end; }
+
+        uint16_t vfp() const { return vsync_start - vdisplay; }
+        uint16_t vsw() const { return vsync_end - vsync_start; }
+        uint16_t vbp() const { return vtotal - vsync_end; }
+
+        float calculated_vrefresh() const;
+
+        bool interlace() const;
+        SyncPolarity hsync() const;
+        SyncPolarity vsync() const;
+
+        void set_interlace(bool ilace);
+        void set_hsync(SyncPolarity pol);
+        void set_vsync(SyncPolarity pol);
+
+        std::string to_string() const;
+};
+
+struct Videomode videomode_from_timings(uint32_t clock_khz,
+                                        uint16_t hact, uint16_t hfp, uint16_t hsw, uint16_t hbp,
+                                        uint16_t vact, uint16_t vfp, uint16_t vsw, uint16_t vbp);
+}
diff --git a/kms++/src/atomicreq.cpp b/kms++/src/atomicreq.cpp
new file mode 100644
index 0000000..28128f2
--- /dev/null
+++ b/kms++/src/atomicreq.cpp
@@ -0,0 +1,117 @@
+#include <cassert>
+#include <stdexcept>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+#ifndef DRM_CLIENT_CAP_ATOMIC
+
+#define DRM_MODE_ATOMIC_TEST_ONLY 0
+#define DRM_MODE_ATOMIC_NONBLOCK 0
+
+struct _drmModeAtomicReq;
+typedef struct _drmModeAtomicReq* drmModeAtomicReqPtr;
+
+static inline drmModeAtomicReqPtr drmModeAtomicAlloc() { return 0; }
+static inline void drmModeAtomicFree(drmModeAtomicReqPtr) { }
+static inline int drmModeAtomicAddProperty(drmModeAtomicReqPtr, uint32_t, uint32_t, uint64_t) { return 0; }
+static inline int drmModeAtomicCommit(int, drmModeAtomicReqPtr, int, void*) { return 0; }
+
+#endif // DRM_CLIENT_CAP_ATOMIC
+
+using namespace std;
+
+namespace kms
+{
+AtomicReq::AtomicReq(Card& card)
+        : m_card(card)
+{
+        assert(card.has_atomic());
+        m_req = drmModeAtomicAlloc();
+}
+
+AtomicReq::~AtomicReq()
+{
+        drmModeAtomicFree(m_req);
+}
+
+void AtomicReq::add(uint32_t ob_id, uint32_t prop_id, uint64_t value)
+{
+        int r = drmModeAtomicAddProperty(m_req, ob_id, prop_id, value);
+        if (r <= 0)
+                throw std::invalid_argument("foo");
+}
+
+void AtomicReq::add(DrmPropObject* ob, Property *prop, uint64_t value)
+{
+        add(ob->id(), prop->id(), value);
+}
+
+void AtomicReq::add(kms::DrmPropObject* ob, const string& prop, uint64_t value)
+{
+        add(ob, ob->get_prop(prop), value);
+}
+
+void AtomicReq::add(kms::DrmPropObject* ob, const map<string, uint64_t>& values)
+{
+        for(const auto& kvp : values)
+                add(ob, kvp.first, kvp.second);
+}
+
+void AtomicReq::add_display(Connector* conn, Crtc* crtc, Blob* videomode, Plane* primary, Framebuffer* fb)
+{
+        add(conn, {
+                    { "CRTC_ID", crtc->id() },
+            });
+
+        add(crtc, {
+                    { "ACTIVE", 1 },
+                    { "MODE_ID", videomode->id() },
+            });
+
+        add(primary, {
+                    { "FB_ID", fb->id() },
+                    { "CRTC_ID", crtc->id() },
+                    { "SRC_X", 0 << 16 },
+                    { "SRC_Y", 0 << 16 },
+                    { "SRC_W", fb->width() << 16 },
+                    { "SRC_H", fb->height() << 16 },
+                    { "CRTC_X", 0 },
+                    { "CRTC_Y", 0 },
+                    { "CRTC_W", fb->width() },
+                    { "CRTC_H", fb->height() },
+            });
+}
+
+int AtomicReq::test(bool allow_modeset)
+{
+        uint32_t flags = DRM_MODE_ATOMIC_TEST_ONLY;
+
+        if (allow_modeset)
+                flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
+
+        return drmModeAtomicCommit(m_card.fd(), m_req, flags, 0);
+}
+
+int AtomicReq::commit(void* data, bool allow_modeset)
+{
+        uint32_t flags = DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_NONBLOCK;
+
+        if (allow_modeset)
+                flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
+
+        return drmModeAtomicCommit(m_card.fd(), m_req, flags, data);
+}
+
+int AtomicReq::commit_sync(bool allow_modeset)
+{
+        uint32_t flags = 0;
+
+        if (allow_modeset)
+                flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
+
+        return drmModeAtomicCommit(m_card.fd(), m_req, flags, 0);
+}
+}
diff --git a/kms++/src/blob.cpp b/kms++/src/blob.cpp
new file mode 100644
index 0000000..e1cd1f8
--- /dev/null
+++ b/kms++/src/blob.cpp
@@ -0,0 +1,51 @@
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+Blob::Blob(Card& card, uint32_t blob_id)
+        : DrmObject(card, blob_id, DRM_MODE_OBJECT_BLOB), m_created(false)
+{
+        // XXX should we verify that the blob_id is a blob object?
+}
+
+Blob::Blob(Card& card, void* data, size_t len)
+        : DrmObject(card, DRM_MODE_OBJECT_BLOB), m_created(true)
+{
+        uint32_t id;
+
+        int r = drmModeCreatePropertyBlob(card.fd(), data, len, &id);
+        if (r)
+                throw invalid_argument("FAILED TO CREATE PROP\n");
+
+        set_id(id);
+}
+
+Blob::~Blob()
+{
+        if (m_created)
+                drmModeDestroyPropertyBlob(card().fd(), id());
+}
+
+vector<uint8_t> Blob::data()
+{
+        drmModePropertyBlobPtr blob = drmModeGetPropertyBlob(card().fd(), id());
+
+        if (!blob)
+                throw invalid_argument("Blob data not available");
+
+        uint8_t* data = (uint8_t*)blob->data;
+
+        auto v = vector<uint8_t>(data, data + blob->length);
+
+        drmModeFreePropertyBlob(blob);
+
+        return v;
+}
+
+}
diff --git a/kms++/src/card.cpp b/kms++/src/card.cpp
new file mode 100644
index 0000000..f7f1a5a
--- /dev/null
+++ b/kms++/src/card.cpp
@@ -0,0 +1,247 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <utility>
+#include <stdexcept>
+#include <string.h>
+#include <algorithm>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+Card::Card()
+        : Card("/dev/dri/card0")
+{
+}
+
+
+Card::Card(const std::string& device)
+{
+        int fd = open(device.c_str(), O_RDWR | O_CLOEXEC);
+        if (fd < 0)
+                throw invalid_argument(string(strerror(errno)) + " opening " + device);
+        m_fd = fd;
+
+        int r;
+
+        r = drmSetMaster(fd);
+        m_master = r == 0;
+
+        if (getenv("KMSXX_DISABLE_UNIVERSAL_PLANES") == 0) {
+                r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+                m_has_universal_planes = r == 0;
+        } else {
+                m_has_universal_planes = false;
+        }
+
+#ifdef DRM_CLIENT_CAP_ATOMIC
+        if (getenv("KMSXX_DISABLE_ATOMIC") == 0) {
+                r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
+                m_has_atomic = r == 0;
+        } else {
+                m_has_atomic = false;
+        }
+#else
+        m_has_atomic = false;
+#endif
+
+        uint64_t has_dumb;
+        r = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
+        if (r || !has_dumb)
+                throw invalid_argument("Dumb buffers not available");
+
+        auto res = drmModeGetResources(m_fd);
+        if (!res)
+                throw invalid_argument("Can't get card resources");
+
+        for (int i = 0; i < res->count_connectors; ++i) {
+                uint32_t id = res->connectors[i];
+                auto ob = new Connector(*this, id, i);
+                m_obmap[id] = ob;
+                m_connectors.push_back(ob);
+        }
+
+        for (int i = 0; i < res->count_crtcs; ++i) {
+                uint32_t id = res->crtcs[i];
+                auto ob = new Crtc(*this, id, i);
+                m_obmap[id] = ob;
+                m_crtcs.push_back(ob);
+        }
+
+        for (int i = 0; i < res->count_encoders; ++i) {
+                uint32_t id = res->encoders[i];
+                auto ob = new Encoder(*this, id, i);
+                m_obmap[id] = ob;
+                m_encoders.push_back(ob);
+        }
+
+        drmModeFreeResources(res);
+
+        auto planeRes = drmModeGetPlaneResources(m_fd);
+
+        for (uint i = 0; i < planeRes->count_planes; ++i) {
+                uint32_t id = planeRes->planes[i];
+                auto ob = new Plane(*this, id, i);
+                m_obmap[id] = ob;
+                m_planes.push_back(ob);
+        }
+
+        drmModeFreePlaneResources(planeRes);
+
+        // collect all possible props
+        for (auto ob : get_objects()) {
+                auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
+
+                if (props == nullptr)
+                        continue;
+
+                for (unsigned i = 0; i < props->count_props; ++i) {
+                        uint32_t prop_id = props->props[i];
+
+                        if (m_obmap.find(prop_id) == m_obmap.end()) {
+                                auto ob = new Property(*this, prop_id);
+                                m_obmap[prop_id] = ob;
+                                m_properties.push_back(ob);
+                        }
+                }
+
+                drmModeFreeObjectProperties(props);
+        }
+
+        for (auto pair : m_obmap)
+                pair.second->setup();
+}
+
+Card::~Card()
+{
+        restore_modes();
+
+        while (m_framebuffers.size() > 0)
+                delete m_framebuffers.back();
+
+        for (auto pair : m_obmap)
+                delete pair.second;
+
+        close(m_fd);
+}
+
+void Card::drop_master()
+{
+        drmDropMaster(fd());
+}
+
+void Card::restore_modes()
+{
+        for (auto conn : get_connectors())
+                conn->restore_mode();
+}
+
+Connector* Card::get_first_connected_connector() const
+{
+        for(auto c : m_connectors) {
+                if (c->connected())
+                        return c;
+        }
+
+        throw invalid_argument("no connected connectors");
+}
+
+DrmObject* Card::get_object(uint32_t id) const
+{
+        auto iter = m_obmap.find(id);
+        if (iter != m_obmap.end())
+                return iter->second;
+        return nullptr;
+}
+
+const vector<DrmObject*> Card::get_objects() const
+{
+        vector<DrmObject*> v;
+        for(auto pair : m_obmap)
+                v.push_back(pair.second);
+        return v;
+}
+
+Connector* Card::get_connector(uint32_t id) const { return dynamic_cast<Connector*>(get_object(id)); }
+Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
+Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
+Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
+Plane* Card::get_plane(uint32_t id) const { return dynamic_cast<Plane*>(get_object(id)); }
+
+std::vector<kms::Pipeline> Card::get_connected_pipelines()
+{
+        vector<Pipeline> outputs;
+
+        for (auto conn : get_connectors())
+        {
+                if (conn->connected() == false)
+                        continue;
+
+                Crtc* crtc = conn->get_current_crtc();
+
+                if (!crtc) {
+                        for (auto possible : conn->get_possible_crtcs()) {
+                                if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
+                                        crtc = possible;
+                                        break;
+                                }
+                        }
+                }
+
+                if (!crtc)
+                        throw invalid_argument(string("Connector #") +
+                                               to_string(conn->idx()) +
+                                               " has no possible crtcs");
+
+                outputs.push_back(Pipeline { crtc, conn });
+        }
+
+        return outputs;
+}
+
+static void page_flip_handler(int fd, unsigned int frame,
+                              unsigned int sec, unsigned int usec,
+                              void *data)
+{
+        auto handler = (PageFlipHandlerBase*)data;
+        double time = sec + usec / 1000000.0;
+        handler->handle_page_flip(frame, time);
+}
+
+void Card::call_page_flip_handlers()
+{
+        drmEventContext ev { };
+        ev.version = DRM_EVENT_CONTEXT_VERSION;
+        ev.page_flip_handler = page_flip_handler;
+
+        drmHandleEvent(fd(), &ev);
+}
+
+int Card::disable_all()
+{
+        AtomicReq req(*this);
+
+        for (Crtc* c : m_crtcs) {
+                req.add(c, {
+                                { "ACTIVE", 0 },
+                        });
+        }
+
+        for (Plane* p : m_planes) {
+                req.add(p, {
+                                { "FB_ID", 0 },
+                                { "CRTC_ID", 0 },
+                        });
+        }
+
+        return req.commit_sync(true);
+}
+
+}
diff --git a/kms++/src/connector.cpp b/kms++/src/connector.cpp
new file mode 100644
index 0000000..47759be
--- /dev/null
+++ b/kms++/src/connector.cpp
@@ -0,0 +1,273 @@
+#include <stdio.h>
+#include <iostream>
+#include <unistd.h>
+#include <fcntl.h>
+#include <cassert>
+#include <cmath>
+
+#include <kms++/kms++.h>
+#include "helpers.h"
+
+using namespace std;
+
+namespace kms
+{
+
+#ifndef DRM_MODE_CONNECTOR_DPI
+#define DRM_MODE_CONNECTOR_DPI 17
+#endif
+
+static const map<int, string> connector_names = {
+        { DRM_MODE_CONNECTOR_Unknown, "Unknown" },
+        { DRM_MODE_CONNECTOR_VGA, "VGA" },
+        { DRM_MODE_CONNECTOR_DVII, "DVI-I" },
+        { DRM_MODE_CONNECTOR_DVID, "DVI-D" },
+        { DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
+        { DRM_MODE_CONNECTOR_Composite, "Composite" },
+        { DRM_MODE_CONNECTOR_SVIDEO, "S-Video" },
+        { DRM_MODE_CONNECTOR_LVDS, "LVDS" },
+        { DRM_MODE_CONNECTOR_Component, "Component" },
+        { DRM_MODE_CONNECTOR_9PinDIN, "9-Pin-DIN" },
+        { DRM_MODE_CONNECTOR_DisplayPort, "DP" },
+        { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
+        { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
+        { DRM_MODE_CONNECTOR_TV, "TV" },
+        { DRM_MODE_CONNECTOR_eDP, "eDP" },
+        { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
+        { DRM_MODE_CONNECTOR_DSI, "DSI" },
+        { DRM_MODE_CONNECTOR_DPI, "DPI" },
+};
+
+static const map<int, string> connection_str = {
+        { 0, "<unknown>" },
+        { DRM_MODE_CONNECTED, "Connected" },
+        { DRM_MODE_DISCONNECTED, "Disconnected" },
+        { DRM_MODE_UNKNOWNCONNECTION, "Unknown" },
+};
+
+static const map<int, string> subpix_str = {
+#define DEF_SUBPIX(c) { DRM_MODE_SUBPIXEL_##c, #c }
+        DEF_SUBPIX(UNKNOWN),
+        DEF_SUBPIX(HORIZONTAL_RGB),
+        DEF_SUBPIX(HORIZONTAL_BGR),
+        DEF_SUBPIX(VERTICAL_RGB),
+        DEF_SUBPIX(VERTICAL_BGR),
+        DEF_SUBPIX(NONE),
+#undef DEF_SUBPIX
+};
+
+struct ConnectorPriv
+{
+        drmModeConnectorPtr drm_connector;
+};
+
+Connector::Connector(Card &card, uint32_t id, uint32_t idx)
+        :DrmPropObject(card, id, DRM_MODE_OBJECT_CONNECTOR, idx)
+{
+        m_priv = new ConnectorPriv();
+
+        m_priv->drm_connector = drmModeGetConnector(this->card().fd(), this->id());
+        assert(m_priv->drm_connector);
+
+        // XXX drmModeGetConnector() does forced probe, which seems to change (at least) EDID blob id.
+        // XXX So refresh the props again here.
+        refresh_props();
+
+        const auto& name = connector_names.at(m_priv->drm_connector->connector_type);
+        m_fullname = name + "-" + to_string(m_priv->drm_connector->connector_type_id);
+}
+
+Connector::~Connector()
+{
+        drmModeFreeConnector(m_priv->drm_connector);
+        delete m_priv;
+}
+
+void Connector::refresh()
+{
+        drmModeFreeConnector(m_priv->drm_connector);
+
+        m_priv->drm_connector = drmModeGetConnector(this->card().fd(), this->id());
+        assert(m_priv->drm_connector);
+
+        // XXX drmModeGetConnector() does forced probe, which seems to change (at least) EDID blob id.
+        // XXX So refresh the props again here.
+        refresh_props();
+
+        const auto& name = connector_names.at(m_priv->drm_connector->connector_type);
+        m_fullname = name + "-" + to_string(m_priv->drm_connector->connector_type_id);
+}
+
+void Connector::setup()
+{
+        if (m_priv->drm_connector->encoder_id != 0)
+                m_current_encoder = card().get_encoder(m_priv->drm_connector->encoder_id);
+        else
+                m_current_encoder = 0;
+
+        if (m_current_encoder)
+                m_saved_crtc = m_current_encoder->get_crtc();
+        else
+                m_saved_crtc = 0;
+}
+
+void Connector::restore_mode()
+{
+        if (m_saved_crtc)
+                m_saved_crtc->restore_mode(this);
+}
+
+Videomode Connector::get_default_mode() const
+{
+        if (m_priv->drm_connector->count_modes == 0)
+                throw invalid_argument("no modes available\n");
+        drmModeModeInfo drmmode = m_priv->drm_connector->modes[0];
+
+        return drm_mode_to_video_mode(drmmode);
+}
+
+Videomode Connector::get_mode(const string& mode) const
+{
+        auto c = m_priv->drm_connector;
+
+        size_t idx = mode.find('@');
+
+        string name = idx == string::npos ? mode : mode.substr(0, idx);
+        float vrefresh = idx == string::npos ? 0.0 : stod(mode.substr(idx + 1));
+
+        for (int i = 0; i < c->count_modes; i++) {
+                Videomode m = drm_mode_to_video_mode(c->modes[i]);
+
+                if (m.name != name)
+                        continue;
+
+                if (vrefresh && vrefresh != m.calculated_vrefresh())
+                        continue;
+
+                return m;
+        }
+
+        throw invalid_argument(mode + ": mode not found");
+}
+
+Videomode Connector::get_mode(unsigned xres, unsigned yres, float vrefresh, bool ilace) const
+{
+        auto c = m_priv->drm_connector;
+
+        for (int i = 0; i < c->count_modes; i++) {
+                Videomode m = drm_mode_to_video_mode(c->modes[i]);
+
+                if (m.hdisplay != xres || m.vdisplay != yres)
+                        continue;
+
+                if (ilace != m.interlace())
+                        continue;
+
+                if (vrefresh && vrefresh != m.calculated_vrefresh())
+                        continue;
+
+                return m;
+        }
+
+        // If not found, do another round using rounded vrefresh
+
+        for (int i = 0; i < c->count_modes; i++) {
+                Videomode m = drm_mode_to_video_mode(c->modes[i]);
+
+                if (m.hdisplay != xres || m.vdisplay != yres)
+                        continue;
+
+                if (ilace != m.interlace())
+                        continue;
+
+                if (vrefresh && vrefresh != roundf(m.calculated_vrefresh()))
+                        continue;
+
+                return m;
+        }
+
+        throw invalid_argument("mode not found");
+}
+
+bool Connector::connected() const
+{
+        return m_priv->drm_connector->connection == DRM_MODE_CONNECTED ||
+                        m_priv->drm_connector->connection == DRM_MODE_UNKNOWNCONNECTION;
+}
+
+vector<Crtc*> Connector::get_possible_crtcs() const
+{
+        vector<Crtc*> crtcs;
+
+        for (int i = 0; i < m_priv->drm_connector->count_encoders; ++i) {
+                auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
+
+                auto l = enc->get_possible_crtcs();
+
+                crtcs.insert(crtcs.end(), l.begin(), l.end());
+        }
+
+        return crtcs;
+}
+
+Crtc* Connector::get_current_crtc() const
+{
+        if (m_current_encoder)
+                return m_current_encoder->get_crtc();
+        else
+                return 0;
+}
+
+uint32_t Connector::connector_type() const
+{
+        return m_priv->drm_connector->connector_type;
+}
+
+uint32_t Connector::connector_type_id() const
+{
+        return m_priv->drm_connector->connector_type_id;
+}
+
+uint32_t Connector::mmWidth() const
+{
+        return m_priv->drm_connector->mmWidth;
+}
+
+uint32_t Connector::mmHeight() const
+{
+        return m_priv->drm_connector->mmHeight;
+}
+
+uint32_t Connector::subpixel() const
+{
+        return m_priv->drm_connector->subpixel;
+}
+
+const string& Connector::subpixel_str() const
+{
+        return subpix_str.at(subpixel());
+}
+
+std::vector<Videomode> Connector::get_modes() const
+{
+        vector<Videomode> modes;
+
+        for (int i = 0; i < m_priv->drm_connector->count_modes; i++)
+                modes.push_back(drm_mode_to_video_mode(
+                                        m_priv->drm_connector->modes[i]));
+
+        return modes;
+}
+
+std::vector<Encoder*> Connector::get_encoders() const
+{
+        vector<Encoder*> encoders;
+
+        for (int i = 0; i < m_priv->drm_connector->count_encoders; i++) {
+                auto enc = card().get_encoder(m_priv->drm_connector->encoders[i]);
+                encoders.push_back(enc);
+        }
+        return encoders;
+}
+
+}
diff --git a/kms++/src/crtc.cpp b/kms++/src/crtc.cpp
new file mode 100644
index 0000000..f94216f
--- /dev/null
+++ b/kms++/src/crtc.cpp
@@ -0,0 +1,183 @@
+#include <stdio.h>
+#include <iostream>
+#include <unistd.h>
+#include <fcntl.h>
+#include <cassert>
+
+#include <kms++/kms++.h>
+#include "helpers.h"
+
+using namespace std;
+
+namespace kms
+{
+
+struct CrtcPriv
+{
+        drmModeCrtcPtr drm_crtc;
+};
+
+Crtc::Crtc(Card &card, uint32_t id, uint32_t idx)
+        :DrmPropObject(card, id, DRM_MODE_OBJECT_CRTC, idx)
+{
+        m_priv = new CrtcPriv();
+        m_priv->drm_crtc = drmModeGetCrtc(this->card().fd(), this->id());
+        assert(m_priv->drm_crtc);
+}
+
+Crtc::~Crtc()
+{
+        drmModeFreeCrtc(m_priv->drm_crtc);
+        delete m_priv;
+}
+
+void Crtc::refresh()
+{
+        drmModeFreeCrtc(m_priv->drm_crtc);
+
+        m_priv->drm_crtc = drmModeGetCrtc(this->card().fd(), this->id());
+        assert(m_priv->drm_crtc);
+}
+
+void Crtc::setup()
+{
+        for (Plane* plane : card().get_planes()) {
+                if (plane->supports_crtc(this))
+                        m_possible_planes.push_back(plane);
+        }
+}
+
+void Crtc::restore_mode(Connector* conn)
+{
+        auto c = m_priv->drm_crtc;
+
+        uint32_t conns[] = { conn->id() };
+
+        drmModeSetCrtc(card().fd(), id(), c->buffer_id,
+                       c->x, c->y,
+                       conns, 1, &c->mode);
+}
+
+int Crtc::set_mode(Connector* conn, const Videomode& mode)
+{
+        AtomicReq req(card());
+
+        unique_ptr<Blob> blob = mode.to_blob(card());
+
+        req.add(conn, {
+                        { "CRTC_ID", this->id() },
+                });
+
+        req.add(this, {
+                        { "ACTIVE", 1 },
+                        { "MODE_ID", blob->id() },
+                });
+
+        int r = req.commit_sync(true);
+
+        refresh();
+
+        return r;
+}
+
+int Crtc::set_mode(Connector* conn, Framebuffer& fb, const Videomode& mode)
+{
+        uint32_t conns[] = { conn->id() };
+        drmModeModeInfo drmmode = video_mode_to_drm_mode(mode);
+
+        return drmModeSetCrtc(card().fd(), id(), fb.id(),
+                              0, 0,
+                              conns, 1, &drmmode);
+}
+
+int Crtc::disable_mode()
+{
+        return drmModeSetCrtc(card().fd(), id(), 0, 0, 0, 0, 0, 0);
+}
+
+static inline uint32_t conv(float x)
+{
+        // XXX fix the conversion for fractional part
+        return ((uint32_t)x) << 16;
+}
+
+int Crtc::set_plane(Plane* plane, Framebuffer& fb,
+                    int32_t dst_x, int32_t dst_y, uint32_t dst_w, uint32_t dst_h,
+                    float src_x, float src_y, float src_w, float src_h)
+{
+        return drmModeSetPlane(card().fd(), plane->id(), id(), fb.id(), 0,
+                               dst_x, dst_y, dst_w, dst_h,
+                               conv(src_x), conv(src_y), conv(src_w), conv(src_h));
+}
+
+int Crtc::disable_plane(Plane* plane)
+{
+        return drmModeSetPlane(card().fd(), plane->id(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+Plane* Crtc::get_primary_plane()
+{
+        Plane *primary = nullptr;
+
+        for (Plane* p : get_possible_planes()) {
+                if (p->plane_type() != PlaneType::Primary)
+                        continue;
+
+                if (p->crtc_id() == id())
+                        return p;
+
+                primary = p;
+        }
+
+        if (primary)
+                return primary;
+
+        throw invalid_argument(string("No primary plane for crtc ") + to_string(id()));
+}
+
+int Crtc::page_flip(Framebuffer& fb, void *data)
+{
+        return drmModePageFlip(card().fd(), id(), fb.id(), DRM_MODE_PAGE_FLIP_EVENT, data);
+}
+
+uint32_t Crtc::buffer_id() const
+{
+        return m_priv->drm_crtc->buffer_id;
+}
+
+uint32_t Crtc::x() const
+{
+        return m_priv->drm_crtc->x;
+}
+
+uint32_t Crtc::y() const
+{
+        return m_priv->drm_crtc->y;
+}
+
+uint32_t Crtc::width() const
+{
+        return m_priv->drm_crtc->width;
+}
+
+uint32_t Crtc::height() const
+{
+        return m_priv->drm_crtc->height;
+}
+
+int Crtc::mode_valid() const
+{
+        return m_priv->drm_crtc->mode_valid;
+}
+
+Videomode Crtc::mode() const
+{
+        return drm_mode_to_video_mode(m_priv->drm_crtc->mode);
+}
+
+int Crtc::gamma_size() const
+{
+        return m_priv->drm_crtc->gamma_size;
+}
+
+}
diff --git a/kms++/src/drmobject.cpp b/kms++/src/drmobject.cpp
new file mode 100644
index 0000000..f94fc5d
--- /dev/null
+++ b/kms++/src/drmobject.cpp
@@ -0,0 +1,34 @@
+#include <string.h>
+#include <iostream>
+#include <stdexcept>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+DrmObject::DrmObject(Card& card, uint32_t object_type)
+        :m_card(card), m_id(-1), m_object_type(object_type), m_idx(0)
+{
+}
+
+DrmObject::DrmObject(Card& card, uint32_t id, uint32_t object_type, uint32_t idx)
+        :m_card(card), m_id(id), m_object_type(object_type), m_idx(idx)
+{
+}
+
+DrmObject::~DrmObject()
+{
+
+}
+
+void DrmObject::set_id(uint32_t id)
+{
+        m_id = id;
+}
+}
diff --git a/kms++/src/drmpropobject.cpp b/kms++/src/drmpropobject.cpp
new file mode 100644
index 0000000..f5a3c97
--- /dev/null
+++ b/kms++/src/drmpropobject.cpp
@@ -0,0 +1,98 @@
+#include <string.h>
+#include <iostream>
+#include <stdexcept>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+DrmPropObject::DrmPropObject(Card& card, uint32_t object_type)
+        : DrmObject(card, object_type)
+{
+}
+
+DrmPropObject::DrmPropObject(Card& card, uint32_t id, uint32_t object_type, uint32_t idx)
+        : DrmObject(card, id, object_type, idx)
+{
+        refresh_props();
+}
+
+DrmPropObject::~DrmPropObject()
+{
+
+}
+
+void DrmPropObject::refresh_props()
+{
+        auto props = drmModeObjectGetProperties(card().fd(), this->id(), this->object_type());
+
+        if (props == nullptr)
+                return;
+
+        for (unsigned i = 0; i < props->count_props; ++i) {
+                uint32_t prop_id = props->props[i];
+                uint64_t prop_value = props->prop_values[i];
+
+                m_prop_values[prop_id] = prop_value;
+        }
+
+        drmModeFreeObjectProperties(props);
+}
+
+Property* DrmPropObject::get_prop(const string& name) const
+{
+        for (auto pair : m_prop_values) {
+                auto prop = card().get_prop(pair.first);
+
+                if (name == prop->name())
+                        return prop;
+        }
+
+        throw invalid_argument(string("property ") + name + " not found");
+}
+
+uint64_t DrmPropObject::get_prop_value(uint32_t id) const
+{
+        return m_prop_values.at(id);
+}
+
+uint64_t DrmPropObject::get_prop_value(const string& name) const
+{
+        for (auto pair : m_prop_values) {
+                auto prop = card().get_prop(pair.first);
+                if (name == prop->name())
+                        return m_prop_values.at(prop->id());
+        }
+
+        throw invalid_argument("property not found: " + name);
+}
+
+unique_ptr<Blob> DrmPropObject::get_prop_value_as_blob(const string& name) const
+{
+        uint32_t blob_id = (uint32_t)get_prop_value(name);
+
+        return unique_ptr<Blob>(new Blob(card(), blob_id));
+}
+
+int DrmPropObject::set_prop_value(uint32_t id, uint64_t value)
+{
+        return drmModeObjectSetProperty(card().fd(), this->id(), this->object_type(), id, value);
+}
+
+int DrmPropObject::set_prop_value(const string &name, uint64_t value)
+{
+        Property* prop = get_prop(name);
+
+        if (prop == nullptr)
+                throw invalid_argument("property not found: " + name);
+
+        return set_prop_value(prop->id(), value);
+}
+
+}
diff --git a/kms++/src/dumbframebuffer.cpp b/kms++/src/dumbframebuffer.cpp
new file mode 100644
index 0000000..b21e8ff
--- /dev/null
+++ b/kms++/src/dumbframebuffer.cpp
@@ -0,0 +1,137 @@
+
+#include <cstring>
+#include <stdexcept>
+#include <sys/mman.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <drm_fourcc.h>
+#include <drm.h>
+#include <drm_mode.h>
+
+#include <kms++/kms++.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+using namespace std;
+
+namespace kms
+{
+
+DumbFramebuffer::DumbFramebuffer(Card &card, uint32_t width, uint32_t height, const string& fourcc)
+        :DumbFramebuffer(card, width, height, FourCCToPixelFormat(fourcc))
+{
+}
+
+DumbFramebuffer::DumbFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format)
+        :Framebuffer(card, width, height), m_format(format)
+{
+        Create();
+}
+
+DumbFramebuffer::~DumbFramebuffer()
+{
+        Destroy();
+}
+
+void DumbFramebuffer::Create()
+{
+        int r;
+
+        const PixelFormatInfo& format_info = get_pixel_format_info(m_format);
+
+        m_num_planes = format_info.num_planes;
+
+        for (int i = 0; i < format_info.num_planes; ++i) {
+                const PixelFormatPlaneInfo& pi = format_info.planes[i];
+                FramebufferPlane& plane = m_planes[i];
+
+                /* create dumb buffer */
+                struct drm_mode_create_dumb creq = drm_mode_create_dumb();
+                creq.width = width();
+                creq.height = height() / pi.ysub;
+                creq.bpp = pi.bitspp;
+                r = drmIoctl(card().fd(), DRM_IOCTL_MODE_CREATE_DUMB, &creq);
+                if (r)
+                        throw invalid_argument(string("DRM_IOCTL_MODE_CREATE_DUMB failed: ") + strerror(errno));
+
+                plane.handle = creq.handle;
+                plane.stride = creq.pitch;
+                plane.size = creq.height * creq.pitch;
+                plane.offset = 0;
+                plane.map = 0;
+                plane.prime_fd = -1;
+        }
+
+        /* create framebuffer object for the dumb-buffer */
+        uint32_t bo_handles[4] = { m_planes[0].handle, m_planes[1].handle };
+        uint32_t pitches[4] = { m_planes[0].stride, m_planes[1].stride };
+        uint32_t offsets[4] = {  m_planes[0].offset, m_planes[1].offset };
+        uint32_t id;
+        r = drmModeAddFB2(card().fd(), width(), height(), (uint32_t)format(),
+                          bo_handles, pitches, offsets, &id, 0);
+        if (r)
+                throw invalid_argument(string("drmModeAddFB2 failed: ") + strerror(errno));
+
+        set_id(id);
+}
+
+void DumbFramebuffer::Destroy()
+{
+        /* delete framebuffer */
+        drmModeRmFB(card().fd(), id());
+
+        for (uint i = 0; i < m_num_planes; ++i) {
+                FramebufferPlane& plane = m_planes[i];
+
+                /* unmap buffer */
+                if (plane.map)
+                        munmap(plane.map, plane.size);
+
+                /* delete dumb buffer */
+                struct drm_mode_destroy_dumb dreq = drm_mode_destroy_dumb();
+                dreq.handle = plane.handle;
+                drmIoctl(card().fd(), DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
+                if (plane.prime_fd >= 0)
+                        ::close(plane.prime_fd);
+        }
+}
+
+uint8_t* DumbFramebuffer::map(unsigned plane)
+{
+        FramebufferPlane& p = m_planes[plane];
+
+        if (p.map)
+                return p.map;
+
+        /* prepare buffer for memory mapping */
+        struct drm_mode_map_dumb mreq = drm_mode_map_dumb();
+        mreq.handle = p.handle;
+        int r = drmIoctl(card().fd(), DRM_IOCTL_MODE_MAP_DUMB, &mreq);
+        if (r)
+                throw invalid_argument(string("DRM_IOCTL_MODE_MAP_DUMB failed: ") + strerror(errno));
+
+        /* perform actual memory mapping */
+        p.map = (uint8_t *)mmap(0, p.size, PROT_READ | PROT_WRITE, MAP_SHARED,
+                                          card().fd(), mreq.offset);
+        if (p.map == MAP_FAILED)
+                throw invalid_argument(string("mmap failed: ") + strerror(errno));
+
+        return p.map;
+}
+
+int DumbFramebuffer::prime_fd(unsigned int plane)
+{
+        if (m_planes[plane].prime_fd >= 0)
+                return m_planes[plane].prime_fd;
+
+        int r = drmPrimeHandleToFD(card().fd(), m_planes[plane].handle,
+                                   DRM_CLOEXEC | O_RDWR, &m_planes[plane].prime_fd);
+        if (r)
+                throw std::runtime_error("drmPrimeHandleToFD failed");
+
+        return m_planes[plane].prime_fd;
+}
+
+}
diff --git a/kms++/src/encoder.cpp b/kms++/src/encoder.cpp
new file mode 100644
index 0000000..9cd5304
--- /dev/null
+++ b/kms++/src/encoder.cpp
@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <iostream>
+#include <unistd.h>
+#include <fcntl.h>
+#include <cassert>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+struct EncoderPriv
+{
+        drmModeEncoderPtr drm_encoder;
+};
+
+static const map<int, string> encoder_types = {
+#define DEF_ENC(c) { DRM_MODE_ENCODER_##c, #c }
+        DEF_ENC(NONE),
+        DEF_ENC(DAC),
+        DEF_ENC(TMDS),
+        DEF_ENC(LVDS),
+        DEF_ENC(TVDAC),
+        DEF_ENC(VIRTUAL),
+        DEF_ENC(DSI),
+        { 7, "DPMST" },
+#undef DEF_ENC
+};
+
+Encoder::Encoder(Card &card, uint32_t id, uint32_t idx)
+        :DrmPropObject(card, id, DRM_MODE_OBJECT_ENCODER, idx)
+{
+        m_priv = new EncoderPriv();
+        m_priv->drm_encoder = drmModeGetEncoder(this->card().fd(), this->id());
+        assert(m_priv->drm_encoder);
+}
+
+Encoder::~Encoder()
+{
+        drmModeFreeEncoder(m_priv->drm_encoder);
+        delete m_priv;
+}
+
+void Encoder::refresh()
+{
+        drmModeFreeEncoder(m_priv->drm_encoder);
+
+        m_priv->drm_encoder = drmModeGetEncoder(this->card().fd(), this->id());
+        assert(m_priv->drm_encoder);
+}
+
+Crtc* Encoder::get_crtc() const
+{
+        if (m_priv->drm_encoder->crtc_id)
+                return card().get_crtc(m_priv->drm_encoder->crtc_id);
+        else
+                return 0;
+}
+
+vector<Crtc*> Encoder::get_possible_crtcs() const
+{
+        unsigned bits = m_priv->drm_encoder->possible_crtcs;
+        vector<Crtc*> crtcs;
+
+        for (int idx = 0; bits; idx++, bits >>= 1) {
+                if ((bits & 1) == 0)
+                        continue;
+
+                auto crtc = card().get_crtcs()[idx];
+                crtcs.push_back(crtc);
+        }
+
+        return crtcs;
+}
+
+const string& Encoder::get_encoder_type() const
+{
+        return encoder_types.at(m_priv->drm_encoder->encoder_type);
+}
+
+}
diff --git a/kms++/src/extframebuffer.cpp b/kms++/src/extframebuffer.cpp
new file mode 100644
index 0000000..c1f562e
--- /dev/null
+++ b/kms++/src/extframebuffer.cpp
@@ -0,0 +1,115 @@
+
+#include <cstring>
+#include <stdexcept>
+#include <sys/mman.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+ExtFramebuffer::ExtFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format,
+                               vector<uint32_t> handles, vector<uint32_t> pitches, vector<uint32_t> offsets)
+        : Framebuffer(card, width, height)
+{
+        m_format = format;
+
+        const PixelFormatInfo& format_info = get_pixel_format_info(format);
+
+        m_num_planes = format_info.num_planes;
+
+        for (int i = 0; i < format_info.num_planes; ++i) {
+                FramebufferPlane& plane = m_planes[i];
+
+                plane.handle = handles[i];
+                plane.prime_fd = 0;
+
+                plane.stride = pitches[i];
+                plane.offset = offsets[i];
+                plane.size = plane.stride * height;
+                plane.map = 0;
+        }
+
+        uint32_t id;
+        int r = drmModeAddFB2(card.fd(), width, height, (uint32_t)format, handles.data(), pitches.data(), offsets.data(), &id, 0);
+        if (r)
+                throw std::invalid_argument(string("Failed to create ExtFramebuffer: ") + strerror(r));
+
+        set_id(id);
+}
+
+ExtFramebuffer::ExtFramebuffer(Card& card, uint32_t width, uint32_t height, PixelFormat format,
+                               vector<int> fds, vector<uint32_t> pitches, vector<uint32_t> offsets)
+        : Framebuffer(card, width, height)
+{
+        int r;
+
+        m_format = format;
+
+        const PixelFormatInfo& format_info = get_pixel_format_info(format);
+
+        m_num_planes = format_info.num_planes;
+
+        for (int i = 0; i < format_info.num_planes; ++i) {
+                FramebufferPlane& plane = m_planes[i];
+
+                plane.prime_fd = fds[i];
+
+                r = drmPrimeFDToHandle(card.fd(), fds[i], &plane.handle);
+                if (r)
+                        throw invalid_argument(string("drmPrimeFDToHandle: ") + strerror(errno));
+
+                plane.stride = pitches[i];
+                plane.offset = offsets[i];
+                plane.size = plane.stride * height;
+                plane.map = 0;
+        }
+
+        uint32_t id;
+        uint32_t bo_handles[4] = { m_planes[0].handle, m_planes[1].handle };
+        r = drmModeAddFB2(card.fd(), width, height, (uint32_t)format,
+                          bo_handles, pitches.data(), offsets.data(), &id, 0);
+        if (r)
+                throw invalid_argument(string("drmModeAddFB2 failed: ") + strerror(errno));
+
+        set_id(id);
+}
+
+ExtFramebuffer::~ExtFramebuffer()
+{
+        drmModeRmFB(card().fd(), id());
+}
+
+uint8_t* ExtFramebuffer::map(unsigned plane)
+{
+        FramebufferPlane& p = m_planes[plane];
+
+        if (!p.prime_fd)
+                throw invalid_argument("cannot mmap non-dmabuf fb");
+
+        if (p.map)
+                return p.map;
+
+        p.map = (uint8_t *)mmap(0, p.size, PROT_READ | PROT_WRITE, MAP_SHARED,
+                                          p.prime_fd, 0);
+        if (p.map == MAP_FAILED)
+                throw invalid_argument(string("mmap failed: ") + strerror(errno));
+
+        return p.map;
+}
+
+int ExtFramebuffer::prime_fd(unsigned plane)
+{
+        FramebufferPlane& p = m_planes[plane];
+
+        if (!p.prime_fd)
+                throw invalid_argument("no primefb for non-dmabuf fb");
+
+        return p.prime_fd;
+}
+
+}
diff --git a/kms++/src/framebuffer.cpp b/kms++/src/framebuffer.cpp
new file mode 100644
index 0000000..39c4e16
--- /dev/null
+++ b/kms++/src/framebuffer.cpp
@@ -0,0 +1,56 @@
+#include <algorithm>
+#include <cstring>
+#include <stdexcept>
+#include <sys/mman.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <kms++/kms++.h>
+
+using namespace std;
+
+namespace kms
+{
+
+Framebuffer::Framebuffer(Card& card, uint32_t width, uint32_t height)
+        : DrmObject(card, DRM_MODE_OBJECT_FB), m_width(width), m_height(height)
+{
+        card.m_framebuffers.push_back(this);
+}
+
+Framebuffer::Framebuffer(Card& card, uint32_t id)
+        : DrmObject(card, id, DRM_MODE_OBJECT_FB)
+{
+        auto fb = drmModeGetFB(card.fd(), id);
+
+        if (fb) {
+                m_width = fb->width;
+                m_height = fb->height;
+
+                drmModeFreeFB(fb);
+        } else {
+                m_width = m_height = 0;
+        }
+
+        card.m_framebuffers.push_back(this);
+}
+
+void Framebuffer::flush()
+{
+        drmModeClip clip { };
+        clip.x1 = clip.y1 = 0;
+        clip.x2 = width();
+        clip.y2 = height();
+
+        drmModeDirtyFB(card().fd(), id(), &clip, 1);
+}
+
+Framebuffer::~Framebuffer()
+{
+        auto& fbs = card().m_framebuffers;
+        auto iter = find(fbs.begin(), fbs.end(), this);
+        card().m_framebuffers.erase(iter);
+}
+
+
+}
diff --git a/kms++/src/helpers.cpp b/kms++/src/helpers.cpp
new file mode 100644
index 0000000..8bd082b
--- /dev/null
+++ b/kms++/src/helpers.cpp
@@ -0,0 +1,72 @@
+
+#include <kms++/kms++.h>
+#include "helpers.h"
+#include <cstring>
+
+#define CPY(field) dst.field = src.field
+
+namespace kms
+{
+Videomode drm_mode_to_video_mode(const drmModeModeInfo& drmmode)
+{
+        Videomode mode = { };
+
+        auto& src = drmmode;
+        auto& dst = mode;
+
+        CPY(clock);
+
+        CPY(hdisplay);
+        CPY(hsync_start);
+        CPY(hsync_end);
+        CPY(htotal);
+        CPY(hskew);
+
+        CPY(vdisplay);
+        CPY(vsync_start);
+        CPY(vsync_end);
+        CPY(vtotal);
+        CPY(vscan);
+
+        CPY(vrefresh);
+
+        CPY(flags);
+        CPY(type);
+
+        mode.name = drmmode.name;
+
+        return mode;
+}
+
+drmModeModeInfo video_mode_to_drm_mode(const Videomode& mode)
+{
+        drmModeModeInfo drmmode = { };
+
+        auto& src = mode;
+        auto& dst = drmmode;
+
+        CPY(clock);
+
+        CPY(hdisplay);
+        CPY(hsync_start);
+        CPY(hsync_end);
+        CPY(htotal);
+        CPY(hskew);
+
+        CPY(vdisplay);
+        CPY(vsync_start);
+        CPY(vsync_end);
+        CPY(vtotal);
+        CPY(vscan);
+
+        CPY(vrefresh);
+
+        CPY(flags);
+        CPY(type);
+
+        strncpy(drmmode.name, mode.name.c_str(), sizeof(drmmode.name));
+        drmmode.name[sizeof(drmmode.name) - 1] = 0;
+
+        return drmmode;
+}
+}
diff --git a/kms++/src/helpers.h b/kms++/src/helpers.h
new file mode 100644
index 0000000..4eb597c
--- /dev/null
+++ b/kms++/src/helpers.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+namespace kms
+{
+struct Videomode;
+
+Videomode drm_mode_to_video_mode(const drmModeModeInfo& drmmode);
+drmModeModeInfo video_mode_to_drm_mode(const Videomode& mode);
+}
diff --git a/kms++/src/mode_cvt.cpp b/kms++/src/mode_cvt.cpp
new file mode 100644
index 0000000..41503c7
--- /dev/null
+++ b/kms++/src/mode_cvt.cpp
@@ -0,0 +1,154 @@
+// Supports CVT 1.2 reduced blanking modes v1 and v2
+
+#include <kms++/kms++.h>
+#include <cmath>
+
+using namespace std;
+
+namespace kms
+{
+
+static float CELL_GRAN = 8;
+static float CELL_GRAN_RND = round(CELL_GRAN);
+
+struct CVTConsts
+{
+        float CLOCK_STEP;
+        float MIN_V_BPORCH;
+        float RB_H_BLANK;
+        float RB_H_FPORCH;
+        float RB_H_SYNC;
+        float RB_H_BPORCH;
+        float RB_MIN_V_BLANK;
+        float RB_V_FPORCH;
+        float REFRESH_MULTIPLIER;
+};
+
+static const CVTConsts cvt_consts_v1 =
+{
+        .CLOCK_STEP = 0.25,     // Fixed
+        .MIN_V_BPORCH = 6,      // Min
+        .RB_H_BLANK = 160,      // Fixed
+        .RB_H_FPORCH = 48,      // Fixed
+        .RB_H_SYNC = 32,        // Fixed
+        .RB_H_BPORCH = 80,      // Fixed
+        .RB_MIN_V_BLANK = 460,  // Min
+        .RB_V_FPORCH = 3,       // Fixed
+        .REFRESH_MULTIPLIER = 1,// Fixed
+};
+
+static const CVTConsts cvt_consts_v2 =
+{
+        .CLOCK_STEP = 0.001,    // Fixed
+        .MIN_V_BPORCH = 6,      // Fixed
+        .RB_H_BLANK = 80,       // Fixed
+        .RB_H_FPORCH = 8,       // Fixed
+        .RB_H_SYNC = 32,        // Fixed
+        .RB_H_BPORCH = 40,      // Fixed
+        .RB_MIN_V_BLANK = 460,  // Min
+        .RB_V_FPORCH = 1,       // Min
+        .REFRESH_MULTIPLIER = 1,// or 1000/1001
+};
+
+Videomode videomode_from_cvt(uint32_t hact, uint32_t vact, uint32_t refresh, bool ilace, bool reduced_v2, bool video_optimized)
+{
+        CVTConsts c = reduced_v2 ? cvt_consts_v2 : cvt_consts_v1;
+
+        if (video_optimized)
+                c.REFRESH_MULTIPLIER = 1000.0/1001.0;
+
+        bool INT_RQD = ilace;
+
+        float H_PIXELS = hact;
+        float V_LINES = vact;
+        float IP_FREQ_RQD = refresh ? refresh : 60;
+        if (ilace)
+                IP_FREQ_RQD /= 2;
+
+        float V_SYNC_RND;
+
+        if (reduced_v2) {
+                V_SYNC_RND = 8;
+        } else {
+                if (hact * 3 == vact * 4)
+                        V_SYNC_RND = 4;
+                else if (hact * 9 == vact * 16)
+                        V_SYNC_RND = 5;
+                else if (hact * 10 == vact * 16)
+                        V_SYNC_RND = 6;
+                else if (hact == 1280 && (vact == 1024 || vact == 768))
+                        V_SYNC_RND = 7;
+                else
+                        V_SYNC_RND = 10;
+        }
+
+        // 5.2.1
+        float V_FIELD_RATE_RQD = INT_RQD ? IP_FREQ_RQD * 2 : IP_FREQ_RQD;
+
+        // 5.2.2
+        float H_PIXELS_RND = floor(H_PIXELS / CELL_GRAN_RND) * CELL_GRAN_RND;
+
+        // 5.2.3
+        float LEFT_MARGIN = 0;
+        float RIGHT_MARGIN = 0;
+
+        // 5.2.4
+        float TOTAL_ACTIVE_PIXELS = H_PIXELS_RND + LEFT_MARGIN + RIGHT_MARGIN;
+
+        // 5.2.5
+        float V_LINES_RND = INT_RQD ? floor(V_LINES / 2) : floor(V_LINES);
+
+        // 5.2.6
+        float TOP_MARGIN = 0;
+        float BOT_MARGIN = 0;
+
+        // 5.2.7
+        float INTERLACE = INT_RQD ? 0.5 : 0;
+
+        // 5.4.8
+        float H_PERIOD_EST = ((1000000 / V_FIELD_RATE_RQD) - c.RB_MIN_V_BLANK) / (V_LINES_RND + TOP_MARGIN + BOT_MARGIN);
+
+        // 5.4.9
+        float VBI_LINES = floor(c.RB_MIN_V_BLANK / H_PERIOD_EST) + 1;
+
+        // 5.4.10
+        float RB_MIN_VBI = c.RB_V_FPORCH + V_SYNC_RND + c.MIN_V_BPORCH;
+        float ACT_VBI_LINES = VBI_LINES < RB_MIN_VBI ? RB_MIN_VBI : VBI_LINES;
+
+        // 5.4.11
+        float TOTAL_V_LINES = ACT_VBI_LINES + V_LINES_RND + TOP_MARGIN + BOT_MARGIN + INTERLACE;
+
+        // 5.4.12
+        float TOTAL_PIXELS = c.RB_H_BLANK + TOTAL_ACTIVE_PIXELS;
+
+        // 5.4.13
+        float ACT_PIXEL_FREQ = c.CLOCK_STEP * floor((V_FIELD_RATE_RQD * TOTAL_V_LINES * TOTAL_PIXELS / 1000000 * c.REFRESH_MULTIPLIER) / c.CLOCK_STEP);
+
+        // 5.4.14
+        //float ACT_H_FREQ = 1000 * ACT_PIXEL_FREQ / TOTAL_PIXELS;
+
+        // 5.4.15
+        //float ACT_FIELD_RATE = 1000 * ACT_H_FREQ / TOTAL_V_LINES;
+
+        // 5.4.16
+        //float ACT_FRAME_RATE = INT_RQD ? ACT_FIELD_RATE / 2 : ACT_FIELD_RATE;
+
+        // 3.4.3.7 Adjust vfp
+        if (reduced_v2)
+                c.RB_V_FPORCH = ACT_VBI_LINES - V_SYNC_RND - c.MIN_V_BPORCH;
+
+        Videomode mode;
+
+        mode = videomode_from_timings(ACT_PIXEL_FREQ * 1000,
+                                      H_PIXELS_RND, c.RB_H_FPORCH, c.RB_H_SYNC, c.RB_H_BPORCH,
+                                      V_LINES_RND * (INT_RQD ? 2 : 1), c.RB_V_FPORCH, V_SYNC_RND, ACT_VBI_LINES - V_SYNC_RND - c.RB_V_FPORCH);
+
+        mode.set_hsync(SyncPolarity::Positive);
+        mode.set_vsync(SyncPolarity::Negative);
+
+        mode.set_interlace(INT_RQD);
+
+        return mode;
+}
+
+}
diff --git a/kms++/src/modedb.cpp b/kms++/src/modedb.cpp
new file mode 100644
index 0000000..5d5d373
--- /dev/null
+++ b/kms++/src/modedb.cpp
@@ -0,0 +1,59 @@
+#include <xf86drm.h>
+#include <stdexcept>
+#include <cmath>
+
+#include <kms++/modedb.h>
+
+using namespace std;
+
+namespace kms
+{
+
+static const Videomode& find_from_table(const Videomode* modes, uint32_t width, uint32_t height, float vrefresh, bool ilace)
+{
+        for (unsigned i = 0; modes[i].clock; ++i) {
+                const Videomode& m = modes[i];
+
+                if (m.hdisplay != width || m.vdisplay != height)
+                        continue;
+
+                if (ilace != m.interlace())
+                        continue;
+
+                if (vrefresh && vrefresh != m.calculated_vrefresh())
+                        continue;
+
+                return m;
+        }
+
+        // If not found, do another round using rounded vrefresh
+
+        for (unsigned i = 0; modes[i].clock; ++i) {
+                const Videomode& m = modes[i];
+
+                if (m.hdisplay != width || m.vdisplay != height)
+                        continue;
+
+                if (ilace != m.interlace())
+                        continue;
+
+                if (vrefresh && vrefresh != roundf(m.calculated_vrefresh()))
+                        continue;
+
+                return m;
+        }
+
+        throw invalid_argument("mode not found");
+}
+
+const Videomode& find_dmt(uint32_t width, uint32_t height, float vrefresh, bool ilace)
+{
+        return find_from_table(dmt_modes, width, height, vrefresh, ilace);
+}
+
+const Videomode& find_cea(uint32_t width, uint32_t height, float vrefresh, bool ilace)
+{
+        return find_from_table(cea_modes, width, height, vrefresh, ilace);
+}
+
+}
diff --git a/kms++/src/modedb_cea.cpp b/kms++/src/modedb_cea.cpp
new file mode 100644
index 0000000..a99a612
--- /dev/null
+++ b/kms++/src/modedb_cea.cpp
@@ -0,0 +1,402 @@
+/* From Linux kernel: drm_edid.c */
+/*
+ * Copyright (c) 2006 Luc Verhaegen (quirks list)
+ * Copyright (c) 2007-2008 Intel Corporation
+ *   Jesse Barnes <jesse.barnes@intel.com>
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from
+ * FB layer.
+ *   Copyright (C) 2006 Dennis Munsie <dmunsie@cecropia.com>
+ *
+ * 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 AUTHORS OR COPYRIGHT HOLDERS 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 <kms++/modedb.h>
+
+#include <xf86drm.h>
+
+namespace kms
+{
+
+#define DIV_ROUND(n, d) (((n) + (d) / 2) / (d))
+
+#define DRM_MODE(nm, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs, f) \
+        .name = nm, .clock = (c), \
+        .hdisplay = (hd), .hsync_start = (hss), .hsync_end = (hse), .htotal = (ht), .hskew = (hsk), \
+        .vdisplay = (vd), .vsync_start = (vss), .vsync_end = (vse), .vtotal = (vt), .vscan = (vs), \
+        .vrefresh = DIV_ROUND(c * 1000, ht * vt) * (((f) & DRM_MODE_FLAG_INTERLACE) ? 2 : 1), \
+        .flags = (f), .type = 0
+
+/*
+ * Probably taken from CEA-861 spec.
+ * This table is converted from xorg's hw/xfree86/modes/xf86EdidModes.c.
+ */
+const Videomode cea_modes[] = {
+        /* 1 - 640x480@60Hz */
+        { DRM_MODE("640x480", 25175, 640, 656,
+          752, 800, 0, 480, 490, 492, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 2 - 720x480@60Hz */
+        { DRM_MODE("720x480", 27000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 3 - 720x480@60Hz */
+        { DRM_MODE("720x480", 27000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 4 - 1280x720@60Hz */
+        { DRM_MODE("1280x720", 74250, 1280, 1390,
+          1430, 1650, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 5 - 1920x1080i@60Hz */
+        { DRM_MODE("1920x1080i", 74250, 1920, 2008,
+          2052, 2200, 0, 1080, 1084, 1094, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 6 - 720(1440)x480i@60Hz */
+        { DRM_MODE("720x480i", 13500, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 7 - 720(1440)x480i@60Hz */
+        { DRM_MODE("720x480i", 13500, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 8 - 720(1440)x240@60Hz */
+        { DRM_MODE("720x240", 13500, 720, 739,
+          801, 858, 0, 240, 244, 247, 262, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 9 - 720(1440)x240@60Hz */
+        { DRM_MODE("720x240", 13500, 720, 739,
+          801, 858, 0, 240, 244, 247, 262, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 10 - 2880x480i@60Hz */
+        { DRM_MODE("2880x480i", 54000, 2880, 2956,
+          3204, 3432, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 11 - 2880x480i@60Hz */
+        { DRM_MODE("2880x480i", 54000, 2880, 2956,
+          3204, 3432, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 12 - 2880x240@60Hz */
+        { DRM_MODE("2880x240", 54000, 2880, 2956,
+          3204, 3432, 0, 240, 244, 247, 262, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 13 - 2880x240@60Hz */
+        { DRM_MODE("2880x240", 54000, 2880, 2956,
+          3204, 3432, 0, 240, 244, 247, 262, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 14 - 1440x480@60Hz */
+        { DRM_MODE("1440x480", 54000, 1440, 1472,
+          1596, 1716, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 15 - 1440x480@60Hz */
+        { DRM_MODE("1440x480", 54000, 1440, 1472,
+          1596, 1716, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 16 - 1920x1080@60Hz */
+        { DRM_MODE("1920x1080", 148500, 1920, 2008,
+          2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 17 - 720x576@50Hz */
+        { DRM_MODE("720x576", 27000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 18 - 720x576@50Hz */
+        { DRM_MODE("720x576", 27000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 19 - 1280x720@50Hz */
+        { DRM_MODE("1280x720", 74250, 1280, 1720,
+          1760, 1980, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 20 - 1920x1080i@50Hz */
+        { DRM_MODE("1920x1080i", 74250, 1920, 2448,
+          2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 21 - 720(1440)x576i@50Hz */
+        { DRM_MODE("720x576i", 13500, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 22 - 720(1440)x576i@50Hz */
+        { DRM_MODE("720x576i", 13500, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 23 - 720(1440)x288@50Hz */
+        { DRM_MODE("720x288", 13500, 720, 732,
+          795, 864, 0, 288, 290, 293, 312, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 24 - 720(1440)x288@50Hz */
+        { DRM_MODE("720x288", 13500, 720, 732,
+          795, 864, 0, 288, 290, 293, 312, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 25 - 2880x576i@50Hz */
+        { DRM_MODE("2880x576i", 54000, 2880, 2928,
+          3180, 3456, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 26 - 2880x576i@50Hz */
+        { DRM_MODE("2880x576i", 54000, 2880, 2928,
+          3180, 3456, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 27 - 2880x288@50Hz */
+        { DRM_MODE("2880x288", 54000, 2880, 2928,
+          3180, 3456, 0, 288, 290, 293, 312, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 28 - 2880x288@50Hz */
+        { DRM_MODE("2880x288", 54000, 2880, 2928,
+          3180, 3456, 0, 288, 290, 293, 312, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 29 - 1440x576@50Hz */
+        { DRM_MODE("1440x576", 54000, 1440, 1464,
+          1592, 1728, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 30 - 1440x576@50Hz */
+        { DRM_MODE("1440x576", 54000, 1440, 1464,
+          1592, 1728, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 31 - 1920x1080@50Hz */
+        { DRM_MODE("1920x1080", 148500, 1920, 2448,
+          2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 32 - 1920x1080@24Hz */
+        { DRM_MODE("1920x1080", 74250, 1920, 2558,
+          2602, 2750, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 33 - 1920x1080@25Hz */
+        { DRM_MODE("1920x1080", 74250, 1920, 2448,
+          2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 34 - 1920x1080@30Hz */
+        { DRM_MODE("1920x1080", 74250, 1920, 2008,
+          2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 35 - 2880x480@60Hz */
+        { DRM_MODE("2880x480", 108000, 2880, 2944,
+          3192, 3432, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 36 - 2880x480@60Hz */
+        { DRM_MODE("2880x480", 108000, 2880, 2944,
+          3192, 3432, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 37 - 2880x576@50Hz */
+        { DRM_MODE("2880x576", 108000, 2880, 2928,
+          3184, 3456, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 38 - 2880x576@50Hz */
+        { DRM_MODE("2880x576", 108000, 2880, 2928,
+          3184, 3456, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 39 - 1920x1080i@50Hz */
+        { DRM_MODE("1920x1080i", 72000, 1920, 1952,
+          2120, 2304, 0, 1080, 1126, 1136, 1250, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 40 - 1920x1080i@100Hz */
+        { DRM_MODE("1920x1080i", 148500, 1920, 2448,
+          2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 41 - 1280x720@100Hz */
+        { DRM_MODE("1280x720", 148500, 1280, 1720,
+          1760, 1980, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 42 - 720x576@100Hz */
+        { DRM_MODE("720x576", 54000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 43 - 720x576@100Hz */
+        { DRM_MODE("720x576", 54000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 44 - 720(1440)x576i@100Hz */
+        { DRM_MODE("720x576i", 27000, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 45 - 720(1440)x576i@100Hz */
+        { DRM_MODE("720x576i", 27000, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 46 - 1920x1080i@120Hz */
+        { DRM_MODE("1920x1080i", 148500, 1920, 2008,
+          2052, 2200, 0, 1080, 1084, 1094, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
+          DRM_MODE_FLAG_INTERLACE),
+        },
+        /* 47 - 1280x720@120Hz */
+        { DRM_MODE("1280x720", 148500, 1280, 1390,
+          1430, 1650, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 48 - 720x480@120Hz */
+        { DRM_MODE("720x480", 54000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 49 - 720x480@120Hz */
+        { DRM_MODE("720x480", 54000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 50 - 720(1440)x480i@120Hz */
+        { DRM_MODE("720x480i", 27000, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 51 - 720(1440)x480i@120Hz */
+        { DRM_MODE("720x480i", 27000, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 52 - 720x576@200Hz */
+        { DRM_MODE("720x576", 108000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 53 - 720x576@200Hz */
+        { DRM_MODE("720x576", 108000, 720, 732,
+          796, 864, 0, 576, 581, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 54 - 720(1440)x576i@200Hz */
+        { DRM_MODE("720x576i", 54000, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 55 - 720(1440)x576i@200Hz */
+        { DRM_MODE("720x576i", 54000, 720, 732,
+          795, 864, 0, 576, 580, 586, 625, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 56 - 720x480@240Hz */
+        { DRM_MODE("720x480", 108000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 57 - 720x480@240Hz */
+        { DRM_MODE("720x480", 108000, 720, 736,
+          798, 858, 0, 480, 489, 495, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
+        },
+        /* 58 - 720(1440)x480i@240 */
+        { DRM_MODE("720x480i", 54000, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 59 - 720(1440)x480i@240 */
+        { DRM_MODE("720x480i", 54000, 720, 739,
+          801, 858, 0, 480, 488, 494, 525, 0,
+          DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
+          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
+        },
+        /* 60 - 1280x720@24Hz */
+        { DRM_MODE("1280x720", 59400, 1280, 3040,
+          3080, 3300, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 61 - 1280x720@25Hz */
+        { DRM_MODE("1280x720", 74250, 1280, 3700,
+          3740, 3960, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 62 - 1280x720@30Hz */
+        { DRM_MODE("1280x720", 74250, 1280, 3040,
+          3080, 3300, 0, 720, 725, 730, 750, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 63 - 1920x1080@120Hz */
+        { DRM_MODE("1920x1080", 297000, 1920, 2008,
+          2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* 64 - 1920x1080@100Hz */
+        { DRM_MODE("1920x1080", 297000, 1920, 2448,
+          2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
+          DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
+        },
+        /* TERMINATOR */
+        { },
+};
+
+}
diff --git a/kms++/src/modedb_dmt.cpp b/kms++/src/modedb_dmt.cpp
new file mode 100644
index 0000000..7dee6b1
--- /dev/null
+++ b/kms++/src/modedb_dmt.cpp
@@ -0,0 +1,204 @@
+/* Generated from DMTr1 v13.pdf */
+
+#include <kms++/modedb.h>
+
+#include <xf86drm.h>
+
+namespace kms
+{
+
+#define DIV_ROUND(n, d) (((n) + (d) / 2) / (d))
+
+// hd, hss, hse, ht, vd, vss, vse, vt
+
+#define DRM_MODE(nm, c, hact, hfp, hsw, hbp, vact, vfp, vsw, vbp, f) \
+        { \
+        .name = nm, .clock = c, \
+        .hdisplay = (hact), .hsync_start = (hact) + (hfp), .hsync_end = (hact) + (hfp) + (hsw), .htotal = (hact) + (hfp) + (hsw) + (hbp), .hskew = 0, \
+        .vdisplay = (vact), .vsync_start = (vact) + (vfp), .vsync_end = (vact) + (vfp) + (vsw), .vtotal = (vact) + (vfp) + (vsw) + (vbp), .vscan = 0, \
+        .vrefresh = DIV_ROUND(c * 1000, ((hact) + (hfp) + (hsw) + (hbp)) * ((vact) + (vfp) + (vsw) + (vbp))) * (((f) & DRM_MODE_FLAG_INTERLACE) ? 2 : 1), \
+        .flags = (f), .type = 0 \
+        }
+
+const Videomode dmt_modes[] = {
+        // 0x1 - 640 x 350 @ 85Hz
+        DRM_MODE("640 x 350 @ 85Hz", 31500, 640, 32, 64, 96, 350, 32, 3, 60, DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC),
+        // 0x2 - 640 x 400 @ 85Hz
+        DRM_MODE("640 x 400 @ 85Hz", 31500, 640, 32, 64, 96, 400, 1, 3, 41, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC),
+        // 0x3 - 720 x 400 @ 85Hz
+        DRM_MODE("720 x 400 @ 85Hz", 35500, 720, 36, 72, 108, 400, 1, 3, 42, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC),