diff --git a/autotests/libkwineffects/data/glplatform/llvmpipe-5.0 b/autotests/libkwineffects/data/glplatform/llvmpipe-5.0
new file mode 100644
index 000000000..56aa352f2
--- /dev/null
+++ b/autotests/libkwineffects/data/glplatform/llvmpipe-5.0
@@ -0,0 +1,22 @@
+[Driver]
+Vendor=VMware, Inc.
+Renderer=llvmpipe (LLVM 5.0, 256 bits)
+Version=3.0 Mesa 17.2.6
+ShadingLanguageVersion=1.30
+
+[Settings]
+LooseBinding=true
+GLSL=true
+TextureNPOT=true
+Mesa=true
+Gallium=true
+SoftwareEmulation=true
+GLVersion=3,0
+GLSLVersion=1,30
+MesaVersion=17,2,6
+GalliumVersion=0,4
+DriverVersion=17,2,6
+Driver=12
+ChipClass=99999
+Compositor=9
+
diff --git a/libkwineffects/kwinglplatform.cpp b/libkwineffects/kwinglplatform.cpp
index 2b7b9a4c4..f5febc05b 100644
--- a/libkwineffects/kwinglplatform.cpp
+++ b/libkwineffects/kwinglplatform.cpp
@@ -1,1153 +1,1159 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2010 Fredrik Höglund <fredrik@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "kwinglplatform.h"
 #include <epoxy/gl.h>
 
 #include <QRegExp>
 #include <QStringList>
 #include <QDebug>
 #include <QOpenGLContext>
 
 #include <sys/utsname.h>
 
 #include <iostream>
 #include <iomanip>
 #include <ios>
 
 namespace KWin
 {
 
 GLPlatform *GLPlatform::s_platform = 0;
 
 static qint64 parseVersionString(const QByteArray &version)
 {
     // Skip any leading non digit
     int start = 0;
     while (start < version.length() && !QChar::fromLatin1(version[start]).isDigit())
         start++;
 
     // Strip any non digit, non '.' characters from the end
     int end = start;
     while (end < version.length() && (version[end] == '.' || QChar::fromLatin1(version[end]).isDigit()))
         end++;
 
     const QByteArray result = version.mid(start, end-start);
     const QList<QByteArray> tokens = result.split('.');
     const qint64 major = tokens.at(0).toInt();
     const qint64 minor = tokens.count() > 1 ? tokens.at(1).toInt() : 0;
     const qint64 patch = tokens.count() > 2 ? tokens.at(2).toInt() : 0;
 
     return kVersionNumber(major, minor, patch);
 }
 
 static qint64 getXServerVersion()
 {
     qint64 major, minor, patch;
     major = 0;
     minor = 0;
     patch = 0;
 
     if (xcb_connection_t *c = connection()) {
         auto setup = xcb_get_setup(c);
         const QByteArray vendorName(xcb_setup_vendor(setup), xcb_setup_vendor_length(setup));
         if (vendorName.contains("X.Org")) {
             const int release = setup->release_number;
             major = (release / 10000000);
             minor = (release /   100000) % 100;
             patch = (release /     1000) % 100;
         }
     }
 
     return kVersionNumber(major, minor, patch);
 }
 
 static qint64 getKernelVersion()
 {
     struct utsname name;
     uname(&name);
 
     if (qstrcmp(name.sysname, "Linux") == 0)
         return parseVersionString(name.release);
 
     return 0;
 }
 
 // Extracts the portion of a string that matches a regular expression
 static QString extract(const QString &string, const QString &match, int offset = 0)
 {
     QString result;
     QRegExp rx(match);
     int pos = rx.indexIn(string, offset);
     if (pos != -1)
         result = string.mid(pos, rx.matchedLength());
     return result;
 }
 
 static ChipClass detectRadeonClass(const QByteArray &chipset)
 {
     if (chipset.isEmpty())
         return UnknownRadeon;
 
     if (chipset.contains("R100")  ||
         chipset.contains("RV100") ||
         chipset.contains("RS100"))
         return R100;
 
     if (chipset.contains("RV200") ||
         chipset.contains("RS200") ||
         chipset.contains("R200")  ||
         chipset.contains("RV250") ||
         chipset.contains("RS300") ||
         chipset.contains("RV280"))
         return R200;
 
     if (chipset.contains("R300")  ||
         chipset.contains("R350")  ||
         chipset.contains("R360")  ||
         chipset.contains("RV350") ||
         chipset.contains("RV370") ||
         chipset.contains("RV380"))
         return R300;
 
     if (chipset.contains("R420")  ||
         chipset.contains("R423")  ||
         chipset.contains("R430")  ||
         chipset.contains("R480")  ||
         chipset.contains("R481")  ||
         chipset.contains("RV410") ||
         chipset.contains("RS400") ||
         chipset.contains("RC410") ||
         chipset.contains("RS480") ||
         chipset.contains("RS482") ||
         chipset.contains("RS600") ||
         chipset.contains("RS690") ||
         chipset.contains("RS740"))
         return R400;
 
     if (chipset.contains("RV515") ||
         chipset.contains("R520")  ||
         chipset.contains("RV530") ||
         chipset.contains("R580")  ||
         chipset.contains("RV560") ||
         chipset.contains("RV570"))
         return R500;
 
     if (chipset.contains("R600")  ||
         chipset.contains("RV610") ||
         chipset.contains("RV630") ||
         chipset.contains("RV670") ||
         chipset.contains("RV620") ||
         chipset.contains("RV635") ||
         chipset.contains("RS780") ||
         chipset.contains("RS880"))
         return R600;
 
     if (chipset.contains("R700")  ||
         chipset.contains("RV770") ||
         chipset.contains("RV730") ||
         chipset.contains("RV710") ||
         chipset.contains("RV740"))
         return R700;
 
     if (chipset.contains("EVERGREEN") ||  // Not an actual chipset, but returned by R600G in 7.9
         chipset.contains("CEDAR")     ||
         chipset.contains("REDWOOD")   ||
         chipset.contains("JUNIPER")   ||
         chipset.contains("CYPRESS")   ||
         chipset.contains("HEMLOCK")   ||
         chipset.contains("PALM"))
         return Evergreen;
 
     if (chipset.contains("SUMO")   ||
         chipset.contains("SUMO2")  ||
         chipset.contains("BARTS")  ||
         chipset.contains("TURKS")  ||
         chipset.contains("CAICOS") ||
         chipset.contains("CAYMAN"))
         return NorthernIslands;
 
     const QString chipset16 = QString::fromLatin1(chipset);
     QString name = extract(chipset16, QStringLiteral("HD [0-9]{4}")); // HD followed by a space and 4 digits
     if (!name.isEmpty()) {
         const int id = name.rightRef(4).toInt();
         if (id == 6250 || id == 6310)   // Palm
             return Evergreen;
 
         if (id >= 6000 && id < 7000)
             return NorthernIslands;    // HD 6xxx
 
         if (id >= 5000 && id < 6000)
             return Evergreen;          // HD 5xxx
 
         if (id >= 4000 && id < 5000)
             return R700;               // HD 4xxx
 
         if (id >= 2000 && id < 4000)    // HD 2xxx/3xxx
             return R600;
 
         return UnknownRadeon;
     }
 
     name = extract(chipset16, QStringLiteral("X[0-9]{3,4}")); // X followed by 3-4 digits
     if (!name.isEmpty()) {
         const int id = name.midRef(1, -1).toInt();
 
         // X1xxx
         if (id >= 1300)
             return R500;
 
         // X7xx, X8xx, X12xx, 2100
         if ((id >= 700 && id < 1000) || id >= 1200)
             return R400;
 
         // X200, X3xx, X5xx, X6xx, X10xx, X11xx
         if ((id >= 300 && id < 700) || (id >= 1000 && id < 1200))
             return R300;
 
         return UnknownRadeon;
     }
 
     name = extract(chipset16, QStringLiteral("\\b[0-9]{4}\\b")); // A group of 4 digits
     if (!name.isEmpty()) {
         const int id = name.toInt();
 
         // 7xxx
         if (id >= 7000 && id < 8000)
             return R100;
 
         // 8xxx, 9xxx
         if (id >= 8000 && id < 9500)
             return R200;
 
         // 9xxx
         if (id >= 9500)
             return R300;
 
         if (id == 2100)
             return R400;
     }
 
     return UnknownRadeon;
 }
 
 static ChipClass detectNVidiaClass(const QString &chipset)
 {
     QString name = extract(chipset, QStringLiteral("\\bNV[0-9,A-F]{2}\\b")); // NV followed by two hexadecimal digits
     if (!name.isEmpty()) {
         const int id = chipset.midRef(2, -1).toInt(0, 16); // Strip the 'NV' from the id
 
         switch(id & 0xf0) {
         case 0x00:
         case 0x10:
             return NV10;
 
         case 0x20:
             return NV20;
 
         case 0x30:
             return NV30;
 
         case 0x40:
         case 0x60:
             return NV40;
 
         case 0x50:
         case 0x80:
         case 0x90:
         case 0xA0:
             return G80;
 
         default:
             return UnknownNVidia;
         }
     }
 
     if (chipset.contains(QLatin1String("GeForce2")) || chipset.contains(QLatin1String("GeForce 256")))
         return NV10;
 
     if (chipset.contains(QLatin1String("GeForce3")))
         return NV20;
 
     if (chipset.contains(QLatin1String("GeForce4"))) {
         if (chipset.contains(QLatin1String("MX 420"))  ||
                 chipset.contains(QLatin1String("MX 440"))  || // including MX 440SE
                 chipset.contains(QLatin1String("MX 460"))  ||
                 chipset.contains(QLatin1String("MX 4000")) ||
                 chipset.contains(QLatin1String("PCX 4300")))
             return NV10;
 
         return NV20;
     }
 
     // GeForce 5,6,7,8,9
     name = extract(chipset, QStringLiteral("GeForce (FX |PCX |Go )?\\d{4}(M|\\b)")).trimmed();
     if (!name.isEmpty()) {
         if (!name[name.length() - 1].isDigit())
             name.chop(1);
 
         const int id = name.rightRef(4).toInt();
         if (id < 6000)
             return NV30;
 
         if (id >= 6000 && id < 8000)
             return NV40;
 
         if (id >= 8000)
             return G80;
 
         return UnknownNVidia;
     }
 
     // GeForce 100/200/300/400/500
     name = extract(chipset, QStringLiteral("GeForce (G |GT |GTX |GTS )?\\d{3}(M|\\b)")).trimmed();
     if (!name.isEmpty()) {
         if (!name[name.length() - 1].isDigit())
             name.chop(1);
 
         const int id = name.rightRef(3).toInt();
         if (id >= 100 && id < 600) {
             if (id >= 400)
                 return GF100;
 
             return G80;
         }
         return UnknownNVidia;
     }
 
     return UnknownNVidia;
 }
 static inline ChipClass detectNVidiaClass(const QByteArray &chipset)
 {
     return detectNVidiaClass(QString::fromLatin1(chipset));
 }
 
 static ChipClass detectIntelClass(const QByteArray &chipset)
 {
     // see mesa repository: src/mesa/drivers/dri/intel/intel_context.c
     // GL 1.3, DX8? SM ?
     if (chipset.contains("845G")        ||
             chipset.contains("830M")        ||
             chipset.contains("852GM/855GM") ||
             chipset.contains("865G"))
         return I8XX;
 
     // GL 1.4, DX 9.0, SM 2.0
     if (chipset.contains("915G")   ||
             chipset.contains("E7221G") ||
             chipset.contains("915GM")  ||
             chipset.contains("945G")   ||   // DX 9.0c
             chipset.contains("945GM")  ||
             chipset.contains("945GME") ||
             chipset.contains("Q33")    ||   // GL1.5
             chipset.contains("Q35")    ||
             chipset.contains("G33")    ||
             chipset.contains("965Q")   ||   // GMA 3000, but apparently considered gen 4 by the driver
             chipset.contains("946GZ")  ||   // GMA 3000, but apparently considered gen 4 by the driver
             chipset.contains("IGD"))
         return I915;
 
     // GL 2.0, DX 9.0c, SM 3.0
     if (chipset.contains("965G")       ||
             chipset.contains("G45/G43")    || // SM 4.0
             chipset.contains("965GM")      || // GL 2.1
             chipset.contains("965GME/GLE") ||
             chipset.contains("GM45")       ||
             chipset.contains("Q45/Q43")    ||
             chipset.contains("G41")        ||
             chipset.contains("B43")        ||
             chipset.contains("Ironlake"))
         return I965;
 
     // GL 3.1, CL 1.1, DX 10.1
     if (chipset.contains("Sandybridge")) {
         return SandyBridge;
     }
 
     // GL4.0, CL1.1, DX11, SM 5.0
     if (chipset.contains("Ivybridge")) {
         return IvyBridge;
     }
 
     // GL4.0, CL1.2, DX11.1, SM 5.0
     if (chipset.contains("Haswell")) {
         return Haswell;
     }
 
     return UnknownIntel;
 }
 
 static ChipClass detectQualcommClass(const QByteArray &chipClass)
 {
     if (!chipClass.contains("Adreno")) {
         return UnknownChipClass;
     }
     const auto parts = chipClass.split(' ');
     if (parts.count() < 3) {
         return UnknownAdreno;
     }
     bool ok = false;
     const int value = parts.at(2).toInt(&ok);
     if (ok) {
         if (value >= 100 && value < 200) {
             return Adreno1XX;
         }
         if (value >= 200 && value < 300) {
             return Adreno2XX;
         }
         if (value >= 300 && value < 400) {
             return Adreno3XX;
         }
         if (value >= 400 && value < 500) {
             return Adreno4XX;
         }
         if (value >= 500 && value < 600) {
             return Adreno5XX;
         }
     }
     return UnknownAdreno;
 }
 
 QString GLPlatform::versionToString(qint64 version)
 {
     return QString::fromLatin1(versionToString8(version));
 }
 QByteArray GLPlatform::versionToString8(qint64 version)
 {
     int major = (version >> 32);
     int minor = (version >> 16) & 0xffff;
     int patch = version & 0xffff;
 
     QByteArray string = QByteArray::number(major) + '.' + QByteArray::number(minor);
     if (patch != 0)
         string += '.' + QByteArray::number(patch);
 
     return string;
 }
 
 QString GLPlatform::driverToString(Driver driver)
 {
     return QString::fromLatin1(driverToString8(driver));
 }
 QByteArray GLPlatform::driverToString8(Driver driver)
 {
     switch(driver) {
     case Driver_R100:
         return QByteArrayLiteral("Radeon");
     case Driver_R200:
         return QByteArrayLiteral("R200");
     case Driver_R300C:
         return QByteArrayLiteral("R300C");
     case Driver_R300G:
         return QByteArrayLiteral("R300G");
     case Driver_R600C:
         return QByteArrayLiteral("R600C");
     case Driver_R600G:
         return QByteArrayLiteral("R600G");
     case Driver_Nouveau:
         return QByteArrayLiteral("Nouveau");
     case Driver_Intel:
         return QByteArrayLiteral("Intel");
     case Driver_NVidia:
         return QByteArrayLiteral("NVIDIA");
     case Driver_Catalyst:
         return QByteArrayLiteral("Catalyst");
     case Driver_Swrast:
         return QByteArrayLiteral("Software rasterizer");
     case Driver_Softpipe:
         return QByteArrayLiteral("softpipe");
     case Driver_Llvmpipe:
         return QByteArrayLiteral("LLVMpipe");
     case Driver_VirtualBox:
         return QByteArrayLiteral("VirtualBox (Chromium)");
     case Driver_VMware:
         return QByteArrayLiteral("VMware (SVGA3D)");
     case Driver_Qualcomm:
         return QByteArrayLiteral("Qualcomm");
 
     default:
         return QByteArrayLiteral("Unknown");
     }
 }
 
 QString GLPlatform::chipClassToString(ChipClass chipClass)
 {
     return QString::fromLatin1(chipClassToString8(chipClass));
 }
 QByteArray GLPlatform::chipClassToString8(ChipClass chipClass)
 {
     switch(chipClass) {
     case R100:
         return QByteArrayLiteral("R100");
     case R200:
         return QByteArrayLiteral("R200");
     case R300:
         return QByteArrayLiteral("R300");
     case R400:
         return QByteArrayLiteral("R400");
     case R500:
         return QByteArrayLiteral("R500");
     case R600:
         return QByteArrayLiteral("R600");
     case R700:
         return QByteArrayLiteral("R700");
     case Evergreen:
         return QByteArrayLiteral("EVERGREEN");
     case NorthernIslands:
         return QByteArrayLiteral("NI");
 
     case NV10:
         return QByteArrayLiteral("NV10");
     case NV20:
         return QByteArrayLiteral("NV20");
     case NV30:
         return QByteArrayLiteral("NV30");
     case NV40:
         return QByteArrayLiteral("NV40/G70");
     case G80:
         return QByteArrayLiteral("G80/G90");
     case GF100:
         return QByteArrayLiteral("GF100");
 
     case I8XX:
         return QByteArrayLiteral("i830/i835");
     case I915:
         return QByteArrayLiteral("i915/i945");
     case I965:
         return QByteArrayLiteral("i965");
     case SandyBridge:
         return QByteArrayLiteral("SandyBridge");
     case IvyBridge:
         return QByteArrayLiteral("IvyBridge");
     case Haswell:
         return QByteArrayLiteral("Haswell");
 
     case Adreno1XX:
         return QByteArrayLiteral("Adreno 1xx series");
     case Adreno2XX:
         return QByteArrayLiteral("Adreno 2xx series");
     case Adreno3XX:
         return QByteArrayLiteral("Adreno 3xx series");
     case Adreno4XX:
         return QByteArrayLiteral("Adreno 4xx series");
     case Adreno5XX:
         return QByteArrayLiteral("Adreno 5xx series");
 
     default:
         return QByteArrayLiteral("Unknown");
     }
 }
 
 
 
 // -------
 
 
 
 GLPlatform::GLPlatform()
     : m_driver(Driver_Unknown),
       m_chipClass(UnknownChipClass),
       m_recommendedCompositor(XRenderCompositing),
       m_glVersion(0),
       m_glslVersion(0),
       m_mesaVersion(0),
       m_driverVersion(0),
       m_galliumVersion(0),
       m_serverVersion(0),
       m_kernelVersion(0),
       m_looseBinding(false),
       m_supportsGLSL(false),
       m_limitedGLSL(false),
       m_textureNPOT(false),
       m_limitedNPOT(false),
       m_virtualMachine(false),
       m_preferBufferSubData(false),
       m_platformInterface(NoOpenGLPlatformInterface),
       m_gles(false)
 {
 }
 
 GLPlatform::~GLPlatform()
 {
 }
 
 void GLPlatform::detect(OpenGLPlatformInterface platformInterface)
 {
     m_platformInterface = platformInterface;
 
     m_vendor       = (const char*)glGetString(GL_VENDOR);
     m_renderer     = (const char*)glGetString(GL_RENDERER);
     m_version      = (const char*)glGetString(GL_VERSION);
 
     // Parse the OpenGL version
     const QList<QByteArray> versionTokens = m_version.split(' ');
     if (versionTokens.count() > 0) {
         const QByteArray version = QByteArray(m_version);
         m_glVersion = parseVersionString(version);
         if (platformInterface == EglPlatformInterface) {
             // only EGL can have OpenGLES, GLX is OpenGL only
             if (version.startsWith("OpenGL ES")) {
                 // from GLES 2: "Returns a version or release number of the form OpenGL<space>ES<space><version number><space><vendor-specific information>."
                 // from GLES 3: "Returns a version or release number." and "The version number uses one of these forms: major_number.minor_number major_number.minor_number.release_number"
                 m_gles = true;
             }
         }
     }
 
     if (!isGLES() && m_glVersion >= kVersionNumber(3, 0)) {
         int count;
         glGetIntegerv(GL_NUM_EXTENSIONS, &count);
 
         for (int i = 0; i < count; i++) {
             const char *name = (const char *) glGetStringi(GL_EXTENSIONS, i);
             m_extensions.insert(name);
         }
     } else {
         const QByteArray extensions = (const char *) glGetString(GL_EXTENSIONS);
         m_extensions = QSet<QByteArray>::fromList(extensions.split(' '));
     }
 
     // Parse the Mesa version
     const int mesaIndex = versionTokens.indexOf("Mesa");
     if (mesaIndex != -1) {
         const QByteArray version = versionTokens.at(mesaIndex + 1);
         m_mesaVersion = parseVersionString(version);
     }
 
     if (isGLES()) {
         m_supportsGLSL = true;
         m_textureNPOT = true;
     } else {
         m_supportsGLSL = m_extensions.contains("GL_ARB_shader_objects") &&
                          m_extensions.contains("GL_ARB_fragment_shader") &&
                          m_extensions.contains("GL_ARB_vertex_shader");
 
         m_textureNPOT = m_extensions.contains("GL_ARB_texture_non_power_of_two");
     }
 
     m_serverVersion = getXServerVersion();
     m_kernelVersion = getKernelVersion();
 
     m_glslVersion = 0;
     m_glsl_version.clear();
 
     if (m_supportsGLSL) {
         // Parse the GLSL version
         m_glsl_version = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
         m_glslVersion = parseVersionString(m_glsl_version);
     }
 
     m_chipset = QByteArrayLiteral("Unknown");
     m_preferBufferSubData = false;
 
 
     // Mesa classic drivers
     // ====================================================
 
     // Radeon
     if (m_renderer.startsWith("Mesa DRI R")) {
         // Sample renderer string: Mesa DRI R600 (RV740 94B3) 20090101 x86/MMX/SSE2 TCL DRI2
         const QList<QByteArray> tokens = m_renderer.split(' ');
         const QByteArray chipClass = tokens.at(2);
         m_chipset = tokens.at(3).mid(1, -1); // Strip the leading '('
 
         if (chipClass == "R100")
             // Vendor: Tungsten Graphics, Inc.
             m_driver = Driver_R100;
 
         else if (chipClass == "R200")
             // Vendor: Tungsten Graphics, Inc.
             m_driver = Driver_R200;
 
         else if (chipClass == "R300")
             // Vendor: DRI R300 Project
             m_driver = Driver_R300C;
 
         else if (chipClass == "R600")
             // Vendor: Advanced Micro Devices, Inc.
             m_driver = Driver_R600C;
 
         m_chipClass = detectRadeonClass(m_chipset);
     }
 
     // Intel
     else if (m_renderer.contains("Intel")) {
         // Vendor: Tungsten Graphics, Inc.
         // Sample renderer string: Mesa DRI Mobile Intel® GM45 Express Chipset GEM 20100328 2010Q1
 
         QByteArray chipset;
         if (m_renderer.startsWith("Intel(R) Integrated Graphics Device"))
             chipset = "IGD";
         else
             chipset = m_renderer;
 
         m_driver = Driver_Intel;
         m_chipClass = detectIntelClass(chipset);
     }
 
+    // Properietary drivers
+    // ====================================================
+    else if (m_vendor == "ATI Technologies Inc.") {
+        m_chipClass = detectRadeonClass(m_renderer);
+        m_driver = Driver_Catalyst;
+
+        if (versionTokens.count() > 1 && versionTokens.at(2)[0] == '(')
+            m_driverVersion = parseVersionString(versionTokens.at(1));
+        else if (versionTokens.count() > 0)
+            m_driverVersion = parseVersionString(versionTokens.at(0));
+        else
+            m_driverVersion = 0;
+    }
+
+    else if (m_vendor == "NVIDIA Corporation") {
+        m_chipClass = detectNVidiaClass(m_renderer);
+        m_driver = Driver_NVidia;
+
+        int index = versionTokens.indexOf("NVIDIA");
+        if (versionTokens.count() > index)
+            m_driverVersion = parseVersionString(versionTokens.at(index + 1));
+        else
+            m_driverVersion = 0;
+    }
+
+    else if (m_vendor == "Qualcomm") {
+        m_driver = Driver_Qualcomm;
+        m_chipClass = detectQualcommClass(m_renderer);
+    }
+
+    else if (m_renderer == "Software Rasterizer") {
+        m_driver = Driver_Swrast;
+    }
+
+    // Virtual Hardware
+    // ====================================================
+    else if (m_vendor == "Humper" && m_renderer == "Chromium") {
+        // Virtual Box
+        m_driver = Driver_VirtualBox;
+
+        const int index = versionTokens.indexOf("Chromium");
+        if (versionTokens.count() > index)
+            m_driverVersion = parseVersionString(versionTokens.at(index + 1));
+        else
+            m_driverVersion = 0;
+    }
+
     // Gallium drivers
     // ====================================================
-    else if (m_renderer.contains("Gallium")) {
-        // Sample renderer string: Gallium 0.4 on AMD RV740
+    else {
         const QList<QByteArray> tokens = m_renderer.split(' ');
-        m_galliumVersion = parseVersionString(tokens.at(1));
-        m_chipset = (tokens.at(3) == "AMD" || tokens.at(3) == "ATI") ?
-                    tokens.at(4) : tokens.at(3);
+        if (m_renderer.contains("Gallium")) {
+            // Sample renderer string: Gallium 0.4 on AMD RV740
+            m_galliumVersion = parseVersionString(tokens.at(1));
+            m_chipset = (tokens.at(3) == "AMD" || tokens.at(3) == "ATI") ?
+                        tokens.at(4) : tokens.at(3);
+        }
+        else {
+            // The renderer string does not contain "Gallium" anymore.
+            m_chipset = tokens.at(0);
+            // We don't know the actual version anymore, but it's at least 0.4.
+            m_galliumVersion = kVersionNumber(0, 4, 0);
+        }
 
         // R300G
         if (m_vendor == QByteArrayLiteral("X.Org R300 Project")) {
             m_chipClass = detectRadeonClass(m_chipset);
             m_driver = Driver_R300G;
         }
 
         // R600G
         else if (m_vendor == "X.Org" &&
                 (m_renderer.contains("R6")        ||
                  m_renderer.contains("R7")        ||
                  m_renderer.contains("RV6")       ||
                  m_renderer.contains("RV7")       ||
                  m_renderer.contains("RS780")     ||
                  m_renderer.contains("RS880")     ||
                  m_renderer.contains("CEDAR")     ||
                  m_renderer.contains("REDWOOD")   ||
                  m_renderer.contains("JUNIPER")   ||
                  m_renderer.contains("CYPRESS")   ||
                  m_renderer.contains("HEMLOCK")   ||
                  m_renderer.contains("PALM")      ||
                  m_renderer.contains("EVERGREEN") ||
                  m_renderer.contains("SUMO")      ||
                  m_renderer.contains("SUMO2")     ||
                  m_renderer.contains("BARTS")     ||
                  m_renderer.contains("TURKS")     ||
                  m_renderer.contains("CAICOS")    ||
                  m_renderer.contains("CAYMAN"))) {
             m_chipClass = detectRadeonClass(m_chipset);
             m_driver = Driver_R600G;
         }
 
         // Nouveau
         else if (m_vendor == "nouveau") {
             m_chipClass = detectNVidiaClass(m_chipset);
             m_driver = Driver_Nouveau;
         }
 
         // softpipe
         else if (m_vendor == "VMware, Inc." && m_chipset == "softpipe" ) {
             m_driver = Driver_Softpipe;
         }
 
         // llvmpipe
         else if (m_vendor == "VMware, Inc." && m_chipset == "llvmpipe") {
             m_driver = Driver_Llvmpipe;
         }
 
         // SVGA3D
         else if (m_vendor == "VMware, Inc." && m_chipset.contains("SVGA3D")) {
             m_driver = Driver_VMware;
         }
     }
 
-
-    // Properietary drivers
-    // ====================================================
-    else if (m_vendor == "ATI Technologies Inc.") {
-        m_chipClass = detectRadeonClass(m_renderer);
-        m_driver = Driver_Catalyst;
-
-        if (versionTokens.count() > 1 && versionTokens.at(2)[0] == '(')
-            m_driverVersion = parseVersionString(versionTokens.at(1));
-        else if (versionTokens.count() > 0)
-            m_driverVersion = parseVersionString(versionTokens.at(0));
-        else
-            m_driverVersion = 0;
-    }
-
-    else if (m_vendor == "NVIDIA Corporation") {
-        m_chipClass = detectNVidiaClass(m_renderer);
-        m_driver = Driver_NVidia;
-
-        int index = versionTokens.indexOf("NVIDIA");
-        if (versionTokens.count() > index)
-            m_driverVersion = parseVersionString(versionTokens.at(index + 1));
-        else
-            m_driverVersion = 0;
-    }
-
-    else if (m_vendor == "Qualcomm") {
-        m_driver = Driver_Qualcomm;
-        m_chipClass = detectQualcommClass(m_renderer);
-    }
-
-    else if (m_renderer == "Software Rasterizer") {
-        m_driver = Driver_Swrast;
-    }
-
-    // Virtual Hardware
-    // ====================================================
-    else if (m_vendor == "Humper" && m_renderer == "Chromium") {
-        // Virtual Box
-        m_driver = Driver_VirtualBox;
-
-        const int index = versionTokens.indexOf("Chromium");
-        if (versionTokens.count() > index)
-            m_driverVersion = parseVersionString(versionTokens.at(index + 1));
-        else
-            m_driverVersion = 0;
-    }
-
-
     // Driver/GPU specific features
     // ====================================================
     if (isRadeon()) {
         // R200 technically has a programmable pipeline, but since it's SM 1.4,
         // it's too limited to to be of any practical value to us.
         if (m_chipClass < R300)
             m_supportsGLSL = false;
 
         m_limitedGLSL = false;
         m_limitedNPOT = false;
 
         if (m_chipClass < R600) {
             if (driver() == Driver_Catalyst)
                 m_textureNPOT = m_limitedNPOT = false; // Software fallback
             else if (driver() == Driver_R300G)
                 m_limitedNPOT = m_textureNPOT;
 
             m_limitedGLSL = m_supportsGLSL;
         }
 
         if (m_chipClass < R300) {
             // fallback to XRender for R100 and R200
             m_recommendedCompositor = XRenderCompositing;
         } else if (m_chipClass < R600) {
             // XRender due to NPOT limitations not supported by KWin's shaders
             m_recommendedCompositor = XRenderCompositing;
         } else {
             m_recommendedCompositor = OpenGL2Compositing;
         }
 
         if (driver() == Driver_R600G ||
                 (driver() == Driver_R600C && m_renderer.contains("DRI2"))) {
             m_looseBinding = true;
         }
     }
 
     if (isNvidia()) {
         if (m_driver == Driver_NVidia && m_chipClass < NV40)
             m_supportsGLSL = false; // High likelihood of software emulation
 
         if (m_driver == Driver_NVidia) {
             m_looseBinding = true;
             m_preferBufferSubData = true;
         }
 
         if (m_chipClass < NV40) {
             m_recommendedCompositor = XRenderCompositing;
         } else {
             m_recommendedCompositor = OpenGL2Compositing;
         }
 
         m_limitedNPOT = m_textureNPOT && m_chipClass < NV40;
         m_limitedGLSL = m_supportsGLSL && m_chipClass < G80;
     }
 
     if (isIntel()) {
         if (m_chipClass < I915)
             m_supportsGLSL = false;
 
         m_limitedGLSL = m_supportsGLSL && m_chipClass < I965;
         // see https://bugs.freedesktop.org/show_bug.cgi?id=80349#c1
         m_looseBinding = false;
 
         if (m_chipClass < I915) {
             m_recommendedCompositor = XRenderCompositing;
         } else {
             m_recommendedCompositor = OpenGL2Compositing;
         }
     }
 
     if (isMesaDriver() && platformInterface == EglPlatformInterface) {
         // According to the reference implementation in
         // mesa/demos/src/egl/opengles1/texture_from_pixmap
         // the mesa egl implementation does not require a strict binding (so far).
         m_looseBinding = true;
     }
 
     if (isSoftwareEmulation()) {
         if (m_driver < Driver_Llvmpipe) {
             // we recommend XRender
             m_recommendedCompositor = XRenderCompositing;
             // Software emulation does not provide GLSL
             m_limitedGLSL = m_supportsGLSL = false;
         } else {
             // llvmpipe does support GLSL
             m_recommendedCompositor = OpenGL2Compositing;
             m_limitedGLSL = false;
             m_supportsGLSL = true;
         }
     }
 
     if (m_driver == Driver_Qualcomm) {
         if (m_chipClass == Adreno1XX) {
             m_recommendedCompositor = NoCompositing;
         } else {
             // all other drivers support at least GLES 2
             m_recommendedCompositor = OpenGL2Compositing;
         }
     }
 
     if (m_chipClass == UnknownChipClass && m_driver == Driver_Unknown) {
         // we don't know the hardware. Let's be optimistic and assume OpenGL compatible hardware
         m_recommendedCompositor = OpenGL2Compositing;
         m_supportsGLSL = true;
     }
 
     if (isVirtualBox()) {
         m_virtualMachine = true;
         m_recommendedCompositor = OpenGL2Compositing;
     }
 
     if (isVMware()) {
         m_virtualMachine = true;
         m_recommendedCompositor = OpenGL2Compositing;
     }
 
     // and force back to shader supported on gles, we wouldn't have got a context if not supported
     if (isGLES()) {
         m_supportsGLSL = true;
         m_limitedGLSL = false;
     }
 }
 
 static void print(const QByteArray &label, const QByteArray &setting)
 {
     std::cout << std::setw(40) << std::left
               << label.data() << setting.data() << std::endl;
 }
 
 void GLPlatform::printResults() const
 {
     print(QByteArrayLiteral("OpenGL vendor string:"),   m_vendor);
     print(QByteArrayLiteral("OpenGL renderer string:"), m_renderer);
     print(QByteArrayLiteral("OpenGL version string:"),  m_version);
 
     if (m_supportsGLSL)
         print(QByteArrayLiteral("OpenGL shading language version string:"), m_glsl_version);
 
     print(QByteArrayLiteral("Driver:"), driverToString8(m_driver));
     if (!isMesaDriver())
         print(QByteArrayLiteral("Driver version:"), versionToString8(m_driverVersion));
 
     print(QByteArrayLiteral("GPU class:"), chipClassToString8(m_chipClass));
 
     print(QByteArrayLiteral("OpenGL version:"), versionToString8(m_glVersion));
 
     if (m_supportsGLSL)
         print(QByteArrayLiteral("GLSL version:"), versionToString8(m_glslVersion));
 
     if (isMesaDriver())
         print(QByteArrayLiteral("Mesa version:"), versionToString8(mesaVersion()));
     //if (galliumVersion() > 0)
     //    print("Gallium version:", versionToString(m_galliumVersion));
     if (serverVersion() > 0)
         print(QByteArrayLiteral("X server version:"), versionToString8(m_serverVersion));
     if (kernelVersion() > 0)
         print(QByteArrayLiteral("Linux kernel version:"), versionToString8(m_kernelVersion));
 
     print(QByteArrayLiteral("Requires strict binding:"), !m_looseBinding ? QByteArrayLiteral("yes") : QByteArrayLiteral("no"));
     print(QByteArrayLiteral("GLSL shaders:"), m_supportsGLSL ? (m_limitedGLSL ? QByteArrayLiteral("limited") : QByteArrayLiteral("yes")) : QByteArrayLiteral("no"));
     print(QByteArrayLiteral("Texture NPOT support:"), m_textureNPOT ? (m_limitedNPOT ? QByteArrayLiteral("limited") : QByteArrayLiteral("yes")) : QByteArrayLiteral("no"));
     print(QByteArrayLiteral("Virtual Machine:"), m_virtualMachine ? QByteArrayLiteral("yes") : QByteArrayLiteral("no"));
 }
 
 bool GLPlatform::supports(GLFeature feature) const
 {
     switch(feature) {
     case LooseBinding:
         return m_looseBinding;
 
     case GLSL:
         return m_supportsGLSL;
 
     case LimitedGLSL:
         return m_limitedGLSL;
 
     case TextureNPOT:
         return m_textureNPOT;
 
     case LimitedNPOT:
         return m_limitedNPOT;
 
     default:
         return false;
     }
 }
 
 qint64 GLPlatform::glVersion() const
 {
     return m_glVersion;
 }
 
 qint64 GLPlatform::glslVersion() const
 {
     return m_glslVersion;
 }
 
 qint64 GLPlatform::mesaVersion() const
 {
     return m_mesaVersion;
 }
 
 qint64 GLPlatform::galliumVersion() const
 {
     return m_galliumVersion;
 }
 
 qint64 GLPlatform::serverVersion() const
 {
     return m_serverVersion;
 }
 
 qint64 GLPlatform::kernelVersion() const
 {
     return m_kernelVersion;
 }
 
 qint64 GLPlatform::driverVersion() const
 {
     if (isMesaDriver())
         return mesaVersion();
 
     return m_driverVersion;
 }
 
 Driver GLPlatform::driver() const
 {
     return m_driver;
 }
 
 ChipClass GLPlatform::chipClass() const
 {
     return m_chipClass;
 }
 
 bool GLPlatform::isMesaDriver() const
 {
     return mesaVersion() > 0;
 }
 
 bool GLPlatform::isGalliumDriver() const
 {
     return galliumVersion() > 0;
 }
 
 bool GLPlatform::isRadeon() const
 {
     return m_chipClass >= R100 && m_chipClass <= UnknownRadeon;
 }
 
 bool GLPlatform::isNvidia() const
 {
     return m_chipClass >= NV10 && m_chipClass <= UnknownNVidia;
 }
 
 bool GLPlatform::isIntel() const
 {
     return m_chipClass >= I8XX && m_chipClass <= UnknownIntel;
 }
 
 bool GLPlatform::isVirtualBox() const
 {
     return m_driver == Driver_VirtualBox;
 }
 
 bool GLPlatform::isVMware() const
 {
     return m_driver == Driver_VMware;
 }
 
 bool GLPlatform::isSoftwareEmulation() const
 {
     return m_driver == Driver_Softpipe || m_driver == Driver_Swrast || m_driver == Driver_Llvmpipe;
 }
 
 bool GLPlatform::isAdreno() const
 {
     return m_chipClass >= Adreno1XX && m_chipClass <= UnknownAdreno;
 }
 
 const QByteArray &GLPlatform::glRendererString() const
 {
     return m_renderer;
 }
 
 const QByteArray &GLPlatform::glVendorString() const
 {
     return m_vendor;
 }
 
 const QByteArray &GLPlatform::glVersionString() const
 {
     return m_version;
 }
 
 const QByteArray &GLPlatform::glShadingLanguageVersionString() const
 {
     return m_glsl_version;
 }
 
 bool GLPlatform::isLooseBinding() const
 {
     return m_looseBinding;
 }
 
 bool GLPlatform::isVirtualMachine() const
 {
     return m_virtualMachine;
 }
 
 CompositingType GLPlatform::recommendedCompositor() const
 {
     return m_recommendedCompositor;
 }
 
 bool GLPlatform::preferBufferSubData() const
 {
     return m_preferBufferSubData;
 }
 
 OpenGLPlatformInterface GLPlatform::platformInterface() const
 {
     return m_platformInterface;
 }
 
 bool GLPlatform::isGLES() const
 {
     return m_gles;
 }
 
 void GLPlatform::cleanup()
 {
     delete s_platform;
     s_platform = nullptr;
 }
 
 } // namespace KWin