1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "gpu/config/gpu_info_collector.h"
9 #include "base/debug/trace_event.h"
10 #include "base/logging.h"
11 #include "base/mac/mac_util.h"
12 #include "base/mac/scoped_cftyperef.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/string_piece.h"
16 #include "base/strings/string_util.h"
17 #include "base/strings/sys_string_conversions.h"
18 #include "ui/gl/gl_bindings.h"
19 #include "ui/gl/gl_context.h"
20 #include "ui/gl/gl_implementation.h"
22 #import <Cocoa/Cocoa.h>
23 #import <Foundation/Foundation.h>
24 #import <IOKit/IOKitLib.h>
30 const UInt32 kVendorIDIntel = 0x8086;
31 const UInt32 kVendorIDNVidia = 0x10de;
32 const UInt32 kVendorIDAMD = 0x1002;
34 // Return 0 if we couldn't find the property.
35 // The property values we use should not be 0, so it's OK to use 0 as failure.
36 UInt32 GetEntryProperty(io_registry_entry_t entry, CFStringRef property_name) {
37 base::ScopedCFTypeRef<CFDataRef> data_ref(
38 static_cast<CFDataRef>(IORegistryEntrySearchCFProperty(
43 kIORegistryIterateRecursively | kIORegistryIterateParents)));
48 const UInt32* value_pointer =
49 reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data_ref));
50 if (value_pointer != NULL)
51 value = *value_pointer;
55 // Find the info of the current GPU.
56 GPUInfo::GPUDevice GetActiveGPU() {
57 GPUInfo::GPUDevice gpu;
58 io_registry_entry_t dsp_port = CGDisplayIOServicePort(kCGDirectMainDisplay);
59 gpu.vendor_id = GetEntryProperty(dsp_port, CFSTR("vendor-id"));
60 gpu.device_id = GetEntryProperty(dsp_port, CFSTR("device-id"));
64 // Scan IO registry for PCI video cards.
65 bool CollectPCIVideoCardInfo(GPUInfo* gpu_info) {
68 // Collect all GPUs' info.
69 // match_dictionary will be consumed by IOServiceGetMatchingServices, no need
71 CFMutableDictionaryRef match_dictionary = IOServiceMatching("IOPCIDevice");
72 io_iterator_t entry_iterator;
73 std::vector<GPUInfo::GPUDevice> gpu_list;
74 if (IOServiceGetMatchingServices(kIOMasterPortDefault,
76 &entry_iterator) == kIOReturnSuccess) {
77 io_registry_entry_t entry;
78 while ((entry = IOIteratorNext(entry_iterator))) {
79 GPUInfo::GPUDevice gpu;
80 if (GetEntryProperty(entry, CFSTR("class-code")) != 0x30000) {
81 // 0x30000 : DISPLAY_VGA
84 gpu.vendor_id = GetEntryProperty(entry, CFSTR("vendor-id"));
85 gpu.device_id = GetEntryProperty(entry, CFSTR("device-id"));
86 if (gpu.vendor_id && gpu.device_id)
87 gpu_list.push_back(gpu);
89 IOObjectRelease(entry_iterator);
92 switch (gpu_list.size()) {
96 gpu_info->gpu = gpu_list[0];
102 if (gpu_list[0].vendor_id == kVendorIDIntel)
104 else if (gpu_list[1].vendor_id == kVendorIDIntel)
106 if (integrated >= 0) {
107 switch (gpu_list[1 - integrated].vendor_id) {
109 gpu_info->amd_switchable = true;
110 discrete = 1 - integrated;
112 case kVendorIDNVidia:
113 gpu_info->optimus = true;
114 discrete = 1 - integrated;
120 if (integrated >= 0 && discrete >= 0) {
121 // We always put discrete GPU as primary for blacklisting purpose.
122 gpu_info->gpu = gpu_list[discrete];
123 gpu_info->secondary_gpus.push_back(gpu_list[integrated]);
126 // If it's not optimus or amd_switchable, we put the current GPU as
127 // primary. Fall through to default.
131 GPUInfo::GPUDevice active_gpu = GetActiveGPU();
132 size_t current = gpu_list.size();
133 if (active_gpu.vendor_id && active_gpu.device_id) {
134 for (size_t i = 0; i < gpu_list.size(); ++i) {
135 if (gpu_list[i].vendor_id == active_gpu.vendor_id &&
136 gpu_list[i].device_id == active_gpu.device_id) {
142 if (current == gpu_list.size()) {
143 // If we fail to identify the current GPU, select any one as primary.
146 for (size_t i = 0; i < gpu_list.size(); ++i) {
148 gpu_info->gpu = gpu_list[i];
150 gpu_info->secondary_gpus.push_back(gpu_list[i]);
155 return (gpu_info->gpu.vendor_id && gpu_info->gpu.device_id);
158 } // namespace anonymous
160 CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
163 TRACE_EVENT0("gpu", "gpu_info_collector::CollectGraphicsInfo");
165 gpu_info->can_lose_context =
166 (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2);
167 gpu_info->finalized = true;
168 return CollectGraphicsInfoGL(gpu_info);
171 GpuIDResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
172 DCHECK(vendor_id && device_id);
177 if (CollectPCIVideoCardInfo(&gpu_info)) {
178 *vendor_id = gpu_info.gpu.vendor_id;
179 *device_id = gpu_info.gpu.device_id;
180 return kGpuIDSuccess;
182 return kGpuIDFailure;
185 CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
188 std::string model_name;
189 int32 model_major = 0, model_minor = 0;
190 base::mac::ParseModelIdentifier(base::mac::GetModelIdentifier(),
191 &model_name, &model_major, &model_minor);
192 base::ReplaceChars(model_name, " ", "_", &gpu_info->machine_model);
193 gpu_info->machine_model += " " + base::IntToString(model_major) +
194 "." + base::IntToString(model_minor);
196 bool result = CollectPCIVideoCardInfo(gpu_info);
197 return result ? kCollectInfoSuccess : kCollectInfoNonFatalFailure;
200 CollectInfoResult CollectDriverInfoGL(GPUInfo* gpu_info) {
203 // Extract the OpenGL driver version string from the GL_VERSION string.
204 // Mac OpenGL drivers have the driver version
205 // at the end of the gl version string preceded by a dash.
206 // Use some jiggery-pokery to turn that utf8 string into a std::wstring.
207 std::string gl_version_string = gpu_info->gl_version_string;
208 size_t pos = gl_version_string.find_last_of('-');
209 if (pos == std::string::npos)
210 return kCollectInfoNonFatalFailure;
211 gpu_info->driver_version = gl_version_string.substr(pos + 1);
212 return kCollectInfoSuccess;
215 void MergeGPUInfo(GPUInfo* basic_gpu_info,
216 const GPUInfo& context_gpu_info) {
217 MergeGPUInfoGL(basic_gpu_info, context_gpu_info);