summaryrefslogtreecommitdiffstats
path: root/widget/GfxDriverInfo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/GfxDriverInfo.cpp')
-rw-r--r--widget/GfxDriverInfo.cpp777
1 files changed, 777 insertions, 0 deletions
diff --git a/widget/GfxDriverInfo.cpp b/widget/GfxDriverInfo.cpp
new file mode 100644
index 0000000000..d60b023ddc
--- /dev/null
+++ b/widget/GfxDriverInfo.cpp
@@ -0,0 +1,777 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "GfxDriverInfo.h"
+
+#include "nsIGfxInfo.h"
+#include "nsTArray.h"
+#include "nsUnicharUtils.h"
+
+using namespace mozilla::widget;
+
+GfxDeviceFamily*
+ GfxDriverInfo::sDeviceFamilies[static_cast<size_t>(DeviceFamily::Max)];
+nsString*
+ GfxDriverInfo::sWindowProtocol[static_cast<size_t>(WindowProtocol::Max)];
+nsString* GfxDriverInfo::sDeviceVendors[static_cast<size_t>(DeviceVendor::Max)];
+nsString* GfxDriverInfo::sDriverVendors[static_cast<size_t>(DriverVendor::Max)];
+
+GfxDriverInfo::GfxDriverInfo()
+ : mOperatingSystem(OperatingSystem::Unknown),
+ mOperatingSystemVersion(0),
+ mScreen(ScreenSizeStatus::All),
+ mBattery(BatteryStatus::All),
+ mWindowProtocol(GfxDriverInfo::GetWindowProtocol(WindowProtocol::All)),
+ mAdapterVendor(GfxDriverInfo::GetDeviceVendor(DeviceFamily::All)),
+ mDriverVendor(GfxDriverInfo::GetDriverVendor(DriverVendor::All)),
+ mDevices(GfxDriverInfo::GetDeviceFamily(DeviceFamily::All)),
+ mDeleteDevices(false),
+ mFeature(optionalFeatures),
+ mFeatureStatus(nsIGfxInfo::FEATURE_STATUS_OK),
+ mComparisonOp(DRIVER_COMPARISON_IGNORED),
+ mDriverVersion(0),
+ mDriverVersionMax(0),
+ mSuggestedVersion(nullptr),
+ mRuleId(nullptr),
+ mGpu2(false) {}
+
+GfxDriverInfo::GfxDriverInfo(
+ OperatingSystem os, ScreenSizeStatus screen, BatteryStatus battery,
+ const nsAString& windowProtocol, const nsAString& vendor,
+ const nsAString& driverVendor, GfxDeviceFamily* devices, int32_t feature,
+ int32_t featureStatus, VersionComparisonOp op, uint64_t driverVersion,
+ const char* ruleId, const char* suggestedVersion /* = nullptr */,
+ bool ownDevices /* = false */, bool gpu2 /* = false */)
+ : mOperatingSystem(os),
+ mOperatingSystemVersion(0),
+ mScreen(screen),
+ mBattery(battery),
+ mWindowProtocol(windowProtocol),
+ mAdapterVendor(vendor),
+ mDriverVendor(driverVendor),
+ mDevices(devices),
+ mDeleteDevices(ownDevices),
+ mFeature(feature),
+ mFeatureStatus(featureStatus),
+ mComparisonOp(op),
+ mDriverVersion(driverVersion),
+ mDriverVersionMax(0),
+ mSuggestedVersion(suggestedVersion),
+ mRuleId(ruleId),
+ mGpu2(gpu2) {}
+
+GfxDriverInfo::GfxDriverInfo(const GfxDriverInfo& aOrig)
+ : mOperatingSystem(aOrig.mOperatingSystem),
+ mOperatingSystemVersion(aOrig.mOperatingSystemVersion),
+ mScreen(aOrig.mScreen),
+ mBattery(aOrig.mBattery),
+ mWindowProtocol(aOrig.mWindowProtocol),
+ mAdapterVendor(aOrig.mAdapterVendor),
+ mDriverVendor(aOrig.mDriverVendor),
+ mFeature(aOrig.mFeature),
+ mFeatureStatus(aOrig.mFeatureStatus),
+ mComparisonOp(aOrig.mComparisonOp),
+ mDriverVersion(aOrig.mDriverVersion),
+ mDriverVersionMax(aOrig.mDriverVersionMax),
+ mSuggestedVersion(aOrig.mSuggestedVersion),
+ mRuleId(aOrig.mRuleId),
+ mGpu2(aOrig.mGpu2) {
+ // If we're managing the lifetime of the device family, we have to make a
+ // copy of the original's device family.
+ if (aOrig.mDeleteDevices && aOrig.mDevices) {
+ GfxDeviceFamily* devices = new GfxDeviceFamily;
+ *devices = *aOrig.mDevices;
+ mDevices = devices;
+ } else {
+ mDevices = aOrig.mDevices;
+ }
+
+ mDeleteDevices = aOrig.mDeleteDevices;
+}
+
+GfxDriverInfo::~GfxDriverInfo() {
+ if (mDeleteDevices) {
+ delete mDevices;
+ }
+}
+
+void GfxDeviceFamily::Append(const nsAString& aDeviceId) {
+ mIds.AppendElement(aDeviceId);
+}
+
+void GfxDeviceFamily::AppendRange(int32_t aBeginDeviceId,
+ int32_t aEndDeviceId) {
+ mRanges.AppendElement(
+ GfxDeviceFamily::DeviceRange{aBeginDeviceId, aEndDeviceId});
+}
+
+nsresult GfxDeviceFamily::Contains(nsAString& aDeviceId) const {
+ for (const auto& id : mIds) {
+ if (id.Equals(aDeviceId, nsCaseInsensitiveStringComparator)) {
+ return NS_OK;
+ }
+ }
+
+ if (mRanges.IsEmpty()) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ nsresult valid = NS_OK;
+ int32_t deviceId = aDeviceId.ToInteger(&valid, 16);
+ if (valid != NS_OK) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (const auto& range : mRanges) {
+ if (deviceId >= range.mBegin && deviceId <= range.mEnd) {
+ return NS_OK;
+ }
+ }
+
+ return NS_ERROR_NOT_AVAILABLE;
+}
+
+// Macros for appending a device to the DeviceFamily.
+#define APPEND_DEVICE(device) APPEND_DEVICE2(#device)
+#define APPEND_DEVICE2(device) \
+ deviceFamily->Append(NS_LITERAL_STRING_FROM_CSTRING(device))
+#define APPEND_RANGE(start, end) deviceFamily->AppendRange(start, end)
+
+const GfxDeviceFamily* GfxDriverInfo::GetDeviceFamily(DeviceFamily id) {
+ if (id >= DeviceFamily::Max) {
+ MOZ_ASSERT_UNREACHABLE("DeviceFamily id is out of range");
+ return nullptr;
+ }
+
+ // All of these have no specific device ID filtering.
+ switch (id) {
+ case DeviceFamily::All:
+ case DeviceFamily::IntelAll:
+ case DeviceFamily::NvidiaAll:
+ case DeviceFamily::AtiAll:
+ case DeviceFamily::MicrosoftAll:
+ case DeviceFamily::ParallelsAll:
+ case DeviceFamily::QualcommAll:
+ case DeviceFamily::AppleAll:
+ case DeviceFamily::AmazonAll:
+ return nullptr;
+ default:
+ break;
+ }
+
+ // If it already exists, we must have processed it once, so return it now.
+ auto idx = static_cast<size_t>(id);
+ if (sDeviceFamilies[idx]) {
+ return sDeviceFamilies[idx];
+ }
+
+ sDeviceFamilies[idx] = new GfxDeviceFamily;
+ GfxDeviceFamily* deviceFamily = sDeviceFamilies[idx];
+
+ switch (id) {
+ case DeviceFamily::IntelGMA500:
+ APPEND_DEVICE(0x8108); /* IntelGMA500_1 */
+ APPEND_DEVICE(0x8109); /* IntelGMA500_2 */
+ break;
+ case DeviceFamily::IntelGMA900:
+ APPEND_DEVICE(0x2582); /* IntelGMA900_1 */
+ APPEND_DEVICE(0x2782); /* IntelGMA900_2 */
+ APPEND_DEVICE(0x2592); /* IntelGMA900_3 */
+ APPEND_DEVICE(0x2792); /* IntelGMA900_4 */
+ break;
+ case DeviceFamily::IntelGMA950:
+ APPEND_DEVICE(0x2772); /* Intel945G_1 */
+ APPEND_DEVICE(0x2776); /* Intel945G_2 */
+ APPEND_DEVICE(0x27a2); /* Intel945_1 */
+ APPEND_DEVICE(0x27a6); /* Intel945_2 */
+ APPEND_DEVICE(0x27ae); /* Intel945_3 */
+ break;
+ case DeviceFamily::IntelGMA3150:
+ APPEND_DEVICE(0xa001); /* IntelGMA3150_Nettop_1 */
+ APPEND_DEVICE(0xa002); /* IntelGMA3150_Nettop_2 */
+ APPEND_DEVICE(0xa011); /* IntelGMA3150_Netbook_1 */
+ APPEND_DEVICE(0xa012); /* IntelGMA3150_Netbook_2 */
+ break;
+ case DeviceFamily::IntelGMAX3000:
+ APPEND_DEVICE(0x2972); /* Intel946GZ_1 */
+ APPEND_DEVICE(0x2973); /* Intel946GZ_2 */
+ APPEND_DEVICE(0x2982); /* IntelG35_1 */
+ APPEND_DEVICE(0x2983); /* IntelG35_2 */
+ APPEND_DEVICE(0x2992); /* IntelQ965_1 */
+ APPEND_DEVICE(0x2993); /* IntelQ965_2 */
+ APPEND_DEVICE(0x29a2); /* IntelG965_1 */
+ APPEND_DEVICE(0x29a3); /* IntelG965_2 */
+ APPEND_DEVICE(0x29b2); /* IntelQ35_1 */
+ APPEND_DEVICE(0x29b3); /* IntelQ35_2 */
+ APPEND_DEVICE(0x29c2); /* IntelG33_1 */
+ APPEND_DEVICE(0x29c3); /* IntelG33_2 */
+ APPEND_DEVICE(0x29d2); /* IntelQ33_1 */
+ APPEND_DEVICE(0x29d3); /* IntelQ33_2 */
+ APPEND_DEVICE(0x2a02); /* IntelGL960_1 */
+ APPEND_DEVICE(0x2a03); /* IntelGL960_2 */
+ APPEND_DEVICE(0x2a12); /* IntelGM965_1 */
+ APPEND_DEVICE(0x2a13); /* IntelGM965_2 */
+ break;
+ case DeviceFamily::IntelGMAX4500HD:
+ APPEND_DEVICE(0x2a42); /* IntelGMA4500MHD_1 */
+ APPEND_DEVICE(0x2a43); /* IntelGMA4500MHD_2 */
+ APPEND_DEVICE(0x2e42); /* IntelB43_1 */
+ APPEND_DEVICE(0x2e43); /* IntelB43_2 */
+ APPEND_DEVICE(0x2e92); /* IntelB43_3 */
+ APPEND_DEVICE(0x2e93); /* IntelB43_4 */
+ APPEND_DEVICE(0x2e32); /* IntelG41_1 */
+ APPEND_DEVICE(0x2e33); /* IntelG41_2 */
+ APPEND_DEVICE(0x2e22); /* IntelG45_1 */
+ APPEND_DEVICE(0x2e23); /* IntelG45_2 */
+ APPEND_DEVICE(0x2e12); /* IntelQ45_1 */
+ APPEND_DEVICE(0x2e13); /* IntelQ45_2 */
+ break;
+ case DeviceFamily::IntelHDGraphicsToIvyBridge:
+ APPEND_DEVICE(0x015A); /* IntelIvyBridge_GT1_1 (HD Graphics) */
+ // clang-format off
+ APPEND_DEVICE(0x0152); /* IntelIvyBridge_GT1_2 (HD Graphics 2500, desktop) */
+ APPEND_DEVICE(0x0162); /* IntelIvyBridge_GT2_1 (HD Graphics 4000, desktop) */
+ APPEND_DEVICE(0x0166); /* IntelIvyBridge_GT2_2 (HD Graphics 4000, mobile) */
+ APPEND_DEVICE(0x016A); /* IntelIvyBridge_GT2_3 (HD Graphics P4000, workstation) */
+ // clang-format on
+ [[fallthrough]];
+ case DeviceFamily::IntelHDGraphicsToSandyBridge:
+ APPEND_DEVICE(0x0042); /* IntelHDGraphics */
+ APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */
+ APPEND_DEVICE(0x0102); /* IntelSandyBridge_1 */
+ APPEND_DEVICE(0x0106); /* IntelSandyBridge_2 */
+ APPEND_DEVICE(0x0112); /* IntelSandyBridge_3 */
+ APPEND_DEVICE(0x0116); /* IntelSandyBridge_4 */
+ APPEND_DEVICE(0x0122); /* IntelSandyBridge_5 */
+ APPEND_DEVICE(0x0126); /* IntelSandyBridge_6 */
+ APPEND_DEVICE(0x010a); /* IntelSandyBridge_7 */
+ break;
+ case DeviceFamily::IntelHaswell:
+ APPEND_DEVICE(0x0402); /* IntelHaswell_GT1_1 */
+ APPEND_DEVICE(0x0406); /* IntelHaswell_GT1_2 */
+ APPEND_DEVICE(0x040A); /* IntelHaswell_GT1_3 */
+ APPEND_DEVICE(0x040B); /* IntelHaswell_GT1_4 */
+ APPEND_DEVICE(0x040E); /* IntelHaswell_GT1_5 */
+ APPEND_DEVICE(0x0A02); /* IntelHaswell_GT1_6 */
+ APPEND_DEVICE(0x0A06); /* IntelHaswell_GT1_7 */
+ APPEND_DEVICE(0x0A0A); /* IntelHaswell_GT1_8 */
+ APPEND_DEVICE(0x0A0B); /* IntelHaswell_GT1_9 */
+ APPEND_DEVICE(0x0A0E); /* IntelHaswell_GT1_10 */
+ APPEND_DEVICE(0x0412); /* IntelHaswell_GT2_1 */
+ APPEND_DEVICE(0x0416); /* IntelHaswell_GT2_2 */
+ APPEND_DEVICE(0x041A); /* IntelHaswell_GT2_3 */
+ APPEND_DEVICE(0x041B); /* IntelHaswell_GT2_4 */
+ APPEND_DEVICE(0x041E); /* IntelHaswell_GT2_5 */
+ APPEND_DEVICE(0x0A12); /* IntelHaswell_GT2_6 */
+ APPEND_DEVICE(0x0A16); /* IntelHaswell_GT2_7 */
+ APPEND_DEVICE(0x0A1A); /* IntelHaswell_GT2_8 */
+ APPEND_DEVICE(0x0A1B); /* IntelHaswell_GT2_9 */
+ APPEND_DEVICE(0x0A1E); /* IntelHaswell_GT2_10 */
+ APPEND_DEVICE(0x0422); /* IntelHaswell_GT3_1 */
+ APPEND_DEVICE(0x0426); /* IntelHaswell_GT3_2 */
+ APPEND_DEVICE(0x042A); /* IntelHaswell_GT3_3 */
+ APPEND_DEVICE(0x042B); /* IntelHaswell_GT3_4 */
+ APPEND_DEVICE(0x042E); /* IntelHaswell_GT3_5 */
+ APPEND_DEVICE(0x0A22); /* IntelHaswell_GT3_6 */
+ APPEND_DEVICE(0x0A26); /* IntelHaswell_GT3_7 */
+ APPEND_DEVICE(0x0A2A); /* IntelHaswell_GT3_8 */
+ APPEND_DEVICE(0x0A2B); /* IntelHaswell_GT3_9 */
+ APPEND_DEVICE(0x0A2E); /* IntelHaswell_GT3_10 */
+ APPEND_DEVICE(0x0D22); /* IntelHaswell_GT3e_1 */
+ APPEND_DEVICE(0x0D26); /* IntelHaswell_GT3e_2 */
+ APPEND_DEVICE(0x0D2A); /* IntelHaswell_GT3e_3 */
+ APPEND_DEVICE(0x0D2B); /* IntelHaswell_GT3e_4 */
+ APPEND_DEVICE(0x0D2E); /* IntelHaswell_GT3e_5 */
+ break;
+ case DeviceFamily::IntelSandyBridge:
+ APPEND_DEVICE(0x0102);
+ APPEND_DEVICE(0x0106);
+ APPEND_DEVICE(0x010a);
+ APPEND_DEVICE(0x0112);
+ APPEND_DEVICE(0x0116);
+ APPEND_DEVICE(0x0122);
+ APPEND_DEVICE(0x0126);
+ break;
+ case DeviceFamily::IntelGen7Baytrail:
+ APPEND_DEVICE(0x0f30);
+ APPEND_DEVICE(0x0f31);
+ APPEND_DEVICE(0x0f33);
+ APPEND_DEVICE(0x0155);
+ APPEND_DEVICE(0x0157);
+ break;
+ case DeviceFamily::IntelSkylake:
+ APPEND_DEVICE(0x1902);
+ APPEND_DEVICE(0x1906);
+ APPEND_DEVICE(0x190a);
+ APPEND_DEVICE(0x190B);
+ APPEND_DEVICE(0x190e);
+ APPEND_DEVICE(0x1912);
+ APPEND_DEVICE(0x1913);
+ APPEND_DEVICE(0x1915);
+ APPEND_DEVICE(0x1916);
+ APPEND_DEVICE(0x1917);
+ APPEND_DEVICE(0x191a);
+ APPEND_DEVICE(0x191b);
+ APPEND_DEVICE(0x191d);
+ APPEND_DEVICE(0x191e);
+ APPEND_DEVICE(0x1921);
+ APPEND_DEVICE(0x1923);
+ APPEND_DEVICE(0x1926);
+ APPEND_DEVICE(0x1927);
+ APPEND_DEVICE(0x192a);
+ APPEND_DEVICE(0x192b);
+ APPEND_DEVICE(0x192d);
+ APPEND_DEVICE(0x1932);
+ APPEND_DEVICE(0x193a);
+ APPEND_DEVICE(0x193b);
+ APPEND_DEVICE(0x193d);
+ break;
+ case DeviceFamily::IntelKabyLake:
+ APPEND_DEVICE(0x5902);
+ APPEND_DEVICE(0x5906);
+ APPEND_DEVICE(0x5908);
+ APPEND_DEVICE(0x590A);
+ APPEND_DEVICE(0x590B);
+ APPEND_DEVICE(0x590E);
+ APPEND_DEVICE(0x5913);
+ APPEND_DEVICE(0x5915);
+ APPEND_DEVICE(0x5912);
+ APPEND_DEVICE(0x5916);
+ APPEND_DEVICE(0x5917);
+ APPEND_DEVICE(0x591A);
+ APPEND_DEVICE(0x591B);
+ APPEND_DEVICE(0x591D);
+ APPEND_DEVICE(0x591E);
+ APPEND_DEVICE(0x5921);
+ APPEND_DEVICE(0x5923);
+ APPEND_DEVICE(0x5926);
+ APPEND_DEVICE(0x5927);
+ APPEND_DEVICE(0x593B);
+ APPEND_DEVICE(0x591C);
+ APPEND_DEVICE(0x87C0);
+ break;
+ case DeviceFamily::IntelHD520:
+ APPEND_DEVICE(0x1916);
+ break;
+ case DeviceFamily::IntelMobileHDGraphics:
+ APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */
+ break;
+ case DeviceFamily::NvidiaBlockD3D9Layers:
+ // Glitches whilst scrolling (see bugs 612007, 644787, 645872)
+ APPEND_DEVICE(0x00f3); /* NV43 [GeForce 6200 (TM)] */
+ APPEND_DEVICE(0x0146); /* NV43 [Geforce Go 6600TE/6200TE (TM)] */
+ APPEND_DEVICE(0x014f); /* NV43 [GeForce 6200 (TM)] */
+ APPEND_DEVICE(0x0161); /* NV44 [GeForce 6200 TurboCache (TM)] */
+ APPEND_DEVICE(0x0162); /* NV44 [GeForce 6200SE TurboCache (TM)] */
+ APPEND_DEVICE(0x0163); /* NV44 [GeForce 6200 LE (TM)] */
+ APPEND_DEVICE(0x0164); /* NV44 [GeForce Go 6200 (TM)] */
+ APPEND_DEVICE(0x0167); /* NV43 [GeForce Go 6200/6400 (TM)] */
+ APPEND_DEVICE(0x0168); /* NV43 [GeForce Go 6200/6400 (TM)] */
+ APPEND_DEVICE(0x0169); /* NV44 [GeForce 6250 (TM)] */
+ APPEND_DEVICE(0x0222); /* NV44 [GeForce 6200 A-LE (TM)] */
+ APPEND_DEVICE(0x0240); /* C51PV [GeForce 6150 (TM)] */
+ APPEND_DEVICE(0x0241); /* C51 [GeForce 6150 LE (TM)] */
+ APPEND_DEVICE(0x0244); /* C51 [Geforce Go 6150 (TM)] */
+ APPEND_DEVICE(0x0245); /* C51 [Quadro NVS 210S/GeForce 6150LE (TM)] */
+ APPEND_DEVICE(0x0247); /* C51 [GeForce Go 6100 (TM)] */
+ APPEND_DEVICE(0x03d0); /* C61 [GeForce 6150SE nForce 430 (TM)] */
+ APPEND_DEVICE(0x03d1); /* C61 [GeForce 6100 nForce 405 (TM)] */
+ APPEND_DEVICE(0x03d2); /* C61 [GeForce 6100 nForce 400 (TM)] */
+ APPEND_DEVICE(0x03d5); /* C61 [GeForce 6100 nForce 420 (TM)] */
+ break;
+ case DeviceFamily::RadeonX1000:
+ // This list is from the ATIRadeonX1000.kext Info.plist
+ APPEND_DEVICE(0x7187);
+ APPEND_DEVICE(0x7210);
+ APPEND_DEVICE(0x71de);
+ APPEND_DEVICE(0x7146);
+ APPEND_DEVICE(0x7142);
+ APPEND_DEVICE(0x7109);
+ APPEND_DEVICE(0x71c5);
+ APPEND_DEVICE(0x71c0);
+ APPEND_DEVICE(0x7240);
+ APPEND_DEVICE(0x7249);
+ APPEND_DEVICE(0x7291);
+ break;
+ case DeviceFamily::RadeonCaicos:
+ APPEND_DEVICE(0x6766);
+ APPEND_DEVICE(0x6767);
+ APPEND_DEVICE(0x6768);
+ APPEND_DEVICE(0x6770);
+ APPEND_DEVICE(0x6771);
+ APPEND_DEVICE(0x6772);
+ APPEND_DEVICE(0x6778);
+ APPEND_DEVICE(0x6779);
+ APPEND_DEVICE(0x677b);
+ break;
+ case DeviceFamily::RadeonBlockZeroVideoCopy:
+ // Stoney
+ APPEND_DEVICE(0x98e4);
+ // Carrizo
+ APPEND_RANGE(0x9870, 0x9877);
+ break;
+ case DeviceFamily::Geforce7300GT:
+ APPEND_DEVICE(0x0393);
+ break;
+ case DeviceFamily::Nvidia310M:
+ APPEND_DEVICE(0x0A70);
+ break;
+ case DeviceFamily::Nvidia8800GTS:
+ APPEND_DEVICE(0x0193);
+ break;
+ case DeviceFamily::Bug1137716:
+ APPEND_DEVICE(0x0a29);
+ APPEND_DEVICE(0x0a2b);
+ APPEND_DEVICE(0x0a2d);
+ APPEND_DEVICE(0x0a35);
+ APPEND_DEVICE(0x0a6c);
+ APPEND_DEVICE(0x0a70);
+ APPEND_DEVICE(0x0a72);
+ APPEND_DEVICE(0x0a7a);
+ APPEND_DEVICE(0x0caf);
+ APPEND_DEVICE(0x0dd2);
+ APPEND_DEVICE(0x0dd3);
+ // GF180M ids
+ APPEND_DEVICE(0x0de3);
+ APPEND_DEVICE(0x0de8);
+ APPEND_DEVICE(0x0de9);
+ APPEND_DEVICE(0x0dea);
+ APPEND_DEVICE(0x0deb);
+ APPEND_DEVICE(0x0dec);
+ APPEND_DEVICE(0x0ded);
+ APPEND_DEVICE(0x0dee);
+ APPEND_DEVICE(0x0def);
+ APPEND_DEVICE(0x0df0);
+ APPEND_DEVICE(0x0df1);
+ APPEND_DEVICE(0x0df2);
+ APPEND_DEVICE(0x0df3);
+ APPEND_DEVICE(0x0df4);
+ APPEND_DEVICE(0x0df5);
+ APPEND_DEVICE(0x0df6);
+ APPEND_DEVICE(0x0df7);
+ APPEND_DEVICE(0x1050);
+ APPEND_DEVICE(0x1051);
+ APPEND_DEVICE(0x1052);
+ APPEND_DEVICE(0x1054);
+ APPEND_DEVICE(0x1055);
+ break;
+ case DeviceFamily::Bug1116812:
+ APPEND_DEVICE(0x2e32);
+ APPEND_DEVICE(0x2a02);
+ break;
+ case DeviceFamily::Bug1155608:
+ APPEND_DEVICE(0x2e22); /* IntelG45_1 */
+ break;
+ case DeviceFamily::Bug1447141:
+ APPEND_DEVICE(0x9991);
+ APPEND_DEVICE(0x9993);
+ APPEND_DEVICE(0x9996);
+ APPEND_DEVICE(0x9998);
+ APPEND_DEVICE(0x9901);
+ APPEND_DEVICE(0x990b);
+ break;
+ case DeviceFamily::Bug1207665:
+ APPEND_DEVICE(0xa001); /* Intel Media Accelerator 3150 */
+ APPEND_DEVICE(0xa002);
+ APPEND_DEVICE(0xa011);
+ APPEND_DEVICE(0xa012);
+ break;
+ case DeviceFamily::AmdR600:
+ // AMD R600 generation GPUs
+ // R600
+ APPEND_RANGE(0x9400, 0x9403);
+ APPEND_DEVICE(0x9405);
+ APPEND_RANGE(0x940a, 0x940b);
+ APPEND_DEVICE(0x940f);
+ // RV610
+ APPEND_RANGE(0x94c0, 0x94c1);
+ APPEND_RANGE(0x94c3, 0x94c9);
+ APPEND_RANGE(0x94cb, 0x94cd);
+ // RV630
+ APPEND_RANGE(0x9580, 0x9581);
+ APPEND_DEVICE(0x9583);
+ APPEND_RANGE(0x9586, 0x958f);
+ // RV670
+ APPEND_RANGE(0x9500, 0x9501);
+ APPEND_RANGE(0x9504, 0x9509);
+ APPEND_DEVICE(0x950f);
+ APPEND_DEVICE(0x9511);
+ APPEND_DEVICE(0x9515);
+ APPEND_DEVICE(0x9517);
+ APPEND_DEVICE(0x9519);
+ // RV620
+ APPEND_DEVICE(0x95c0);
+ APPEND_DEVICE(0x95c2);
+ APPEND_RANGE(0x95c4, 0x95c7);
+ APPEND_DEVICE(0x95c9);
+ APPEND_RANGE(0x95cc, 0x95cf);
+ // RV635
+ APPEND_RANGE(0x9590, 0x9591);
+ APPEND_DEVICE(0x9593);
+ APPEND_RANGE(0x9595, 0x9599);
+ APPEND_DEVICE(0x959b);
+ // RS780
+ APPEND_RANGE(0x9610, 0x9616);
+ // RS880
+ APPEND_RANGE(0x9710, 0x9715);
+ break;
+ case DeviceFamily::NvidiaWebRenderBlocked:
+ APPEND_RANGE(0x0190, 0x019e); // early tesla
+ APPEND_RANGE(0x0500, 0x05df); // C67-C68
+ break;
+ case DeviceFamily::IntelWebRenderBlocked:
+ // powervr
+ // sgx535
+ APPEND_DEVICE(0x2e5b);
+ APPEND_DEVICE(0x8108);
+ APPEND_DEVICE(0x8109);
+ APPEND_DEVICE(0x4102);
+ // sgx545
+ APPEND_DEVICE(0x0be0);
+ APPEND_DEVICE(0x0be1);
+ APPEND_DEVICE(0x0be3);
+ APPEND_RANGE(0x08c7, 0x08cf);
+
+ // gen4
+ APPEND_DEVICE(0x2972);
+ APPEND_DEVICE(0x2973);
+ APPEND_DEVICE(0x2992);
+ APPEND_DEVICE(0x2993);
+ APPEND_DEVICE(0x29a2);
+ APPEND_DEVICE(0x29a3);
+
+ APPEND_DEVICE(0x2982);
+ APPEND_DEVICE(0x2983);
+
+ APPEND_DEVICE(0x2a02);
+ APPEND_DEVICE(0x2a03);
+ APPEND_DEVICE(0x2a12);
+ APPEND_DEVICE(0x2a13);
+
+ // gen4.5
+ APPEND_DEVICE(0x2e02);
+ APPEND_DEVICE(0x2e42); /* IntelB43_1 */
+ APPEND_DEVICE(0x2e43); /* IntelB43_2 */
+ APPEND_DEVICE(0x2e92); /* IntelB43_3 */
+ APPEND_DEVICE(0x2e93); /* IntelB43_4 */
+ APPEND_DEVICE(0x2e12); /* IntelQ45_1 */
+ APPEND_DEVICE(0x2e13); /* IntelQ45_2 */
+ APPEND_DEVICE(0x2e32); /* IntelG41_1 */
+ APPEND_DEVICE(0x2e33); /* IntelG41_2 */
+ APPEND_DEVICE(0x2e22); /* IntelG45_1 */
+
+ APPEND_DEVICE(0x2e23); /* IntelG45_2 */
+ APPEND_DEVICE(0x2a42); /* IntelGMA4500MHD_1 */
+ APPEND_DEVICE(0x2a43); /* IntelGMA4500MHD_2 */
+
+ // gen5 (ironlake)
+ APPEND_DEVICE(0x0042);
+ APPEND_DEVICE(0x0046);
+ break;
+ // This should never happen, but we get a warning if we don't handle this.
+ case DeviceFamily::Max:
+ case DeviceFamily::All:
+ case DeviceFamily::IntelAll:
+ case DeviceFamily::NvidiaAll:
+ case DeviceFamily::AtiAll:
+ case DeviceFamily::MicrosoftAll:
+ case DeviceFamily::ParallelsAll:
+ case DeviceFamily::QualcommAll:
+ case DeviceFamily::AppleAll:
+ case DeviceFamily::AmazonAll:
+ NS_WARNING("Invalid DeviceFamily id");
+ break;
+ }
+
+ return deviceFamily;
+}
+
+// Macro for assigning a window protocol id to a string.
+#define DECLARE_WINDOW_PROTOCOL_ID(name, windowProtocolId) \
+ case WindowProtocol::name: \
+ sWindowProtocol[idx]->AssignLiteral(windowProtocolId); \
+ break;
+
+const nsAString& GfxDriverInfo::GetWindowProtocol(WindowProtocol id) {
+ if (id >= WindowProtocol::Max) {
+ MOZ_ASSERT_UNREACHABLE("WindowProtocol id is out of range");
+ id = WindowProtocol::All;
+ }
+
+ auto idx = static_cast<size_t>(id);
+ if (sWindowProtocol[idx]) {
+ return *sWindowProtocol[idx];
+ }
+
+ sWindowProtocol[idx] = new nsString();
+
+ switch (id) {
+ DECLARE_WINDOW_PROTOCOL_ID(X11, "x11");
+ DECLARE_WINDOW_PROTOCOL_ID(XWayland, "xwayland");
+ DECLARE_WINDOW_PROTOCOL_ID(Wayland, "wayland");
+ DECLARE_WINDOW_PROTOCOL_ID(WaylandDRM, "wayland/drm");
+ DECLARE_WINDOW_PROTOCOL_ID(WaylandAll, "wayland/all");
+ DECLARE_WINDOW_PROTOCOL_ID(X11All, "x11/all");
+ case WindowProtocol::Max: // Suppress a warning.
+ DECLARE_WINDOW_PROTOCOL_ID(All, "");
+ }
+
+ return *sWindowProtocol[idx];
+}
+
+// Macro for assigning a device vendor id to a string.
+#define DECLARE_VENDOR_ID(name, deviceId) \
+ case DeviceVendor::name: \
+ sDeviceVendors[idx]->AssignLiteral(deviceId); \
+ break;
+
+const nsAString& GfxDriverInfo::GetDeviceVendor(DeviceFamily id) {
+ if (id >= DeviceFamily::Max) {
+ MOZ_ASSERT_UNREACHABLE("DeviceVendor id is out of range");
+ id = DeviceFamily::All;
+ }
+
+ DeviceVendor vendor = DeviceVendor::All;
+ switch (id) {
+ case DeviceFamily::IntelAll:
+ case DeviceFamily::IntelGMA500:
+ case DeviceFamily::IntelGMA900:
+ case DeviceFamily::IntelGMA950:
+ case DeviceFamily::IntelGMA3150:
+ case DeviceFamily::IntelGMAX3000:
+ case DeviceFamily::IntelGMAX4500HD:
+ case DeviceFamily::IntelHDGraphicsToIvyBridge:
+ case DeviceFamily::IntelHDGraphicsToSandyBridge:
+ case DeviceFamily::IntelHaswell:
+ case DeviceFamily::IntelSandyBridge:
+ case DeviceFamily::IntelGen7Baytrail:
+ case DeviceFamily::IntelSkylake:
+ case DeviceFamily::IntelKabyLake:
+ case DeviceFamily::IntelHD520:
+ case DeviceFamily::IntelMobileHDGraphics:
+ case DeviceFamily::IntelWebRenderBlocked:
+ case DeviceFamily::Bug1116812:
+ case DeviceFamily::Bug1155608:
+ case DeviceFamily::Bug1207665:
+ vendor = DeviceVendor::Intel;
+ break;
+ case DeviceFamily::NvidiaAll:
+ case DeviceFamily::NvidiaBlockD3D9Layers:
+ case DeviceFamily::NvidiaWebRenderBlocked:
+ case DeviceFamily::Geforce7300GT:
+ case DeviceFamily::Nvidia310M:
+ case DeviceFamily::Nvidia8800GTS:
+ case DeviceFamily::Bug1137716:
+ vendor = DeviceVendor::NVIDIA;
+ break;
+ case DeviceFamily::AtiAll:
+ case DeviceFamily::RadeonBlockZeroVideoCopy:
+ case DeviceFamily::RadeonCaicos:
+ case DeviceFamily::RadeonX1000:
+ case DeviceFamily::Bug1447141:
+ case DeviceFamily::AmdR600:
+ vendor = DeviceVendor::ATI;
+ break;
+ case DeviceFamily::MicrosoftAll:
+ vendor = DeviceVendor::Microsoft;
+ break;
+ case DeviceFamily::ParallelsAll:
+ vendor = DeviceVendor::Parallels;
+ break;
+ case DeviceFamily::AppleAll:
+ vendor = DeviceVendor::Apple;
+ break;
+ case DeviceFamily::AmazonAll:
+ vendor = DeviceVendor::Amazon;
+ break;
+ case DeviceFamily::QualcommAll:
+ // Choose an arbitrary Qualcomm PCI VENdor ID for now.
+ // TODO: This should be "QCOM" when Windows device ID parsing is reworked.
+ vendor = DeviceVendor::Qualcomm;
+ break;
+ case DeviceFamily::All:
+ case DeviceFamily::Max:
+ break;
+ }
+
+ return GetDeviceVendor(vendor);
+}
+
+const nsAString& GfxDriverInfo::GetDeviceVendor(DeviceVendor id) {
+ if (id >= DeviceVendor::Max) {
+ MOZ_ASSERT_UNREACHABLE("DeviceVendor id is out of range");
+ id = DeviceVendor::All;
+ }
+
+ auto idx = static_cast<size_t>(id);
+ if (sDeviceVendors[idx]) {
+ return *sDeviceVendors[idx];
+ }
+
+ sDeviceVendors[idx] = new nsString();
+
+ switch (id) {
+ DECLARE_VENDOR_ID(Intel, "0x8086");
+ DECLARE_VENDOR_ID(NVIDIA, "0x10de");
+ DECLARE_VENDOR_ID(ATI, "0x1002");
+ // AMD has 0x1022 but continues to release GPU hardware under ATI.
+ DECLARE_VENDOR_ID(Microsoft, "0x1414");
+ DECLARE_VENDOR_ID(MicrosoftBasic, "0x00ba");
+ DECLARE_VENDOR_ID(MicrosoftHyperV, "0x000b");
+ DECLARE_VENDOR_ID(Parallels, "0x1ab8");
+ DECLARE_VENDOR_ID(VMWare, "0x15ad");
+ DECLARE_VENDOR_ID(VirtualBox, "0x80ee");
+ DECLARE_VENDOR_ID(Apple, "0x106b");
+ DECLARE_VENDOR_ID(Amazon, "0x1d0f");
+ // Choose an arbitrary Qualcomm PCI VENdor ID for now.
+ // TODO: This should be "QCOM" when Windows device ID parsing is reworked.
+ DECLARE_VENDOR_ID(Qualcomm, "0x5143");
+ case DeviceVendor::Max: // Suppress a warning.
+ DECLARE_VENDOR_ID(All, "");
+ }
+
+ return *sDeviceVendors[idx];
+}
+
+// Macro for assigning a driver vendor id to a string.
+#define DECLARE_DRIVER_VENDOR_ID(name, driverVendorId) \
+ case DriverVendor::name: \
+ sDriverVendors[idx]->AssignLiteral(driverVendorId); \
+ break;
+
+const nsAString& GfxDriverInfo::GetDriverVendor(DriverVendor id) {
+ if (id >= DriverVendor::Max) {
+ MOZ_ASSERT_UNREACHABLE("DriverVendor id is out of range");
+ id = DriverVendor::All;
+ }
+
+ auto idx = static_cast<size_t>(id);
+ if (sDriverVendors[idx]) {
+ return *sDriverVendors[idx];
+ }
+
+ sDriverVendors[idx] = new nsString();
+
+ switch (id) {
+ DECLARE_DRIVER_VENDOR_ID(MesaAll, "mesa/all");
+ DECLARE_DRIVER_VENDOR_ID(MesaLLVMPipe, "mesa/llvmpipe");
+ DECLARE_DRIVER_VENDOR_ID(MesaSoftPipe, "mesa/softpipe");
+ DECLARE_DRIVER_VENDOR_ID(MesaSWRast, "mesa/swrast");
+ DECLARE_DRIVER_VENDOR_ID(MesaSWUnknown, "mesa/software-unknown");
+ DECLARE_DRIVER_VENDOR_ID(MesaUnknown, "mesa/unknown");
+ DECLARE_DRIVER_VENDOR_ID(MesaR600, "mesa/r600");
+ DECLARE_DRIVER_VENDOR_ID(MesaNouveau, "mesa/nouveau");
+ DECLARE_DRIVER_VENDOR_ID(NonMesaAll, "non-mesa/all");
+ DECLARE_DRIVER_VENDOR_ID(HardwareMesaAll, "mesa/hw-all");
+ DECLARE_DRIVER_VENDOR_ID(SoftwareMesaAll, "mesa/sw-all");
+ DECLARE_DRIVER_VENDOR_ID(MesaNonIntelNvidiaAtiAll,
+ "mesa/non-intel-nvidia-ati-all");
+ DECLARE_DRIVER_VENDOR_ID(MesaVM, "mesa/vmwgfx");
+ case DriverVendor::Max: // Suppress a warning.
+ DECLARE_DRIVER_VENDOR_ID(All, "");
+ }
+
+ return *sDriverVendors[idx];
+}