Chameleon

View nVidia-SubsID.patch

1diff -xrevision -x.svn -x.DS_Store -Naur a/i386/libsaio/nvidia.c b/i386/libsaio/nvidia.c␊
2--- a/i386/libsaio/nvidia.c␉2012-05-08 19:52:09.000000000 +0100␊
3+++ b/i386/libsaio/nvidia.c␉2012-05-29 13:35:52.000000000 +0100␊
4@@ -3,6 +3,9 @@␊
5 *␊
6 *␉Copyright (C) 2009␉Jasmin Fazlic, iNDi␊
7 *␊
8+ *␉NVidia injector modified by Fabio (ErmaC) on May 2012,␊
9+ *␉for allow the cosmetics injection also based on SubVendorID and SubDeviceID.␊
10+ *␊
11 *␉NVidia injector is free software: you can redistribute it and/or modify␊
12 *␉it under the terms of the GNU General Public License as published by␊
13 *␉the Free Software Foundation, either version 3 of the License, or␊
14@@ -15,37 +18,33 @@␊
15 *␊
16 *␉You should have received a copy of the GNU General Public License␊
17 *␉along with NVidia injector.␉ If not, see <http://www.gnu.org/licenses/>.␊
18- */ ␊
19-/*␊
20- * Alternatively you can choose to comply with APSL␊
21- */␊
22- ␊
23- ␊
24-/*␊
25- * DCB-Table parsing is based on software (nouveau driver) originally distributed under following license:␊
26+ *␊
27+ *␉Alternatively you can choose to comply with APSL␊
28+ *␊
29+ *␉DCB-Table parsing is based on software (nouveau driver) originally distributed under following license:␊
30 *␊
31 *␊
32- * Copyright 2005-2006 Erik Waling␊
33- * Copyright 2006 Stephane Marchesin␊
34- * Copyright 2007-2009 Stuart Bennett␊
35+ *␉Copyright 2005-2006 Erik Waling␊
36+ *␉Copyright 2006 Stephane Marchesin␊
37+ *␉Copyright 2007-2009 Stuart Bennett␊
38 *␊
39- * Permission is hereby granted, free of charge, to any person obtaining a␊
40- * copy of this software and associated documentation files (the "Software"),␊
41- * to deal in the Software without restriction, including without limitation␊
42- * the rights to use, copy, modify, merge, publish, distribute, sublicense,␊
43- * and/or sell copies of the Software, and to permit persons to whom the␊
44- * Software is furnished to do so, subject to the following conditions:␊
45+ *␉Permission is hereby granted, free of charge, to any person obtaining a␊
46+ *␉copy of this software and associated documentation files (the "Software"),␊
47+ *␉to deal in the Software without restriction, including without limitation␊
48+ *␉the rights to use, copy, modify, merge, publish, distribute, sublicense,␊
49+ *␉and/or sell copies of the Software, and to permit persons to whom the␊
50+ *␉Software is furnished to do so, subject to the following conditions:␊
51 *␊
52- * The above copyright notice and this permission notice shall be included in␊
53- * all copies or substantial portions of the Software.␊
54+ *␉The above copyright notice and this permission notice shall be included in␊
55+ *␉all copies or substantial portions of the Software.␊
56 *␊
57- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR␊
58- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,␊
59- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL␊
60- * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,␊
61- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF␊
62- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE␊
63- * SOFTWARE.␊
64+ *␉THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR␊
65+ *␉IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,␊
66+ *␉FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL␊
67+ *␉THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,␊
68+ *␉WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF␊
69+ *␉OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE␊
70+ *␉SOFTWARE.␊
71 */␊
72 ␊
73 #include "boot.h"␊
74@@ -79,15 +78,15 @@␊
75 ␊
76 extern uint32_t devices_number;␊
77 ␊
78-const char *nvidia_compatible_0[]␉=␉{ "@0,compatible",␉"NVDA,NVMac"␉ };␊
79-const char *nvidia_compatible_1[]␉=␉{ "@1,compatible",␉"NVDA,NVMac"␉ };␊
80-const char *nvidia_device_type_0[]␉=␉{ "@0,device_type", "display"␉␉ };␊
81-const char *nvidia_device_type_1[]␉=␉{ "@1,device_type", "display"␉␉ };␊
82-const char *nvidia_device_type[]␉=␉{ "device_type",␉"NVDA,Parent"␉ };␊
83+const char *nvidia_compatible_0[] =␉{ "@0,compatible",␉"NVDA,NVMac"␉ };␊
84+const char *nvidia_compatible_1[] =␉{ "@1,compatible",␉"NVDA,NVMac"␉ };␊
85+const char *nvidia_device_type_0[] =␉{ "@0,device_type",␉"display"␉ };␊
86+const char *nvidia_device_type_1[] =␉{ "@1,device_type",␉"display"␉ };␊
87+const char *nvidia_device_type[] =␉{ "device_type",␉"NVDA,Parent"␉ };␊
88 const char *nvidia_device_type_child[]␉=␉{ "device_type",␉"NVDA,Child"␉ };␊
89-const char *nvidia_name_0[]␉␉␉=␉{ "@0,name",␉␉"NVDA,Display-A" };␊
90-const char *nvidia_name_1[]␉␉␉=␉{ "@1,name",␉␉"NVDA,Display-B" };␊
91-const char *nvidia_slot_name[]␉␉=␉{ "AAPL,slot-name", "Slot-1"␉␉ };␊
92+const char *nvidia_name_0[] =␉{ "@0,name",␉␉"NVDA,Display-A" };␊
93+const char *nvidia_name_1[] =␉{ "@1,name",␉␉"NVDA,Display-B" };␊
94+const char *nvidia_slot_name[] =␉{ "AAPL,slot-name", "Slot-1"␉␉ };␊
95 ␊
96 static uint8_t default_NVCAP[]= {␊
97 ␉0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00,␊
98@@ -97,8 +96,10 @@␊
99 ␊
100 #define NVCAP_LEN ( sizeof(default_NVCAP) / sizeof(uint8_t) )␊
101 ␊
102-static uint8_t default_dcfg_0[]␉␉=␉{0xff, 0xff, 0xff, 0xff};␊
103-static uint8_t default_dcfg_1[]␉␉=␉{0xff, 0xff, 0xff, 0xff};␊
104+static uint8_t default_dcfg_0[]␉␉=␉{0x03, 0x01, 0x03, 0x00};␊
105+static uint8_t default_dcfg_1[]␉␉=␉{0xff, 0xff, 0x00, 0x01};␊
106+␊
107+// uint8_t connector_type_1[]␉␉=␉{0x00, 0x08, 0x00, 0x00};␊
108 ␊
109 #define DCFG0_LEN ( sizeof(default_dcfg_0) / sizeof(uint8_t) )␊
110 #define DCFG1_LEN ( sizeof(default_dcfg_1) / sizeof(uint8_t) )␊
111@@ -112,278 +113,1032 @@␊
112 ␊
113 #define NVPM_LEN ( sizeof(default_NVPM) / sizeof(uint8_t) )␊
114 ␊
115-static struct nv_chipsets_t NVKnownChipsets[] = {␊
116-␉{ 0x00000000, "Unknown" },␊
117-//========================================␊
118+static nvidia_card_info_t nvidia_cards[] = {␊
119+ /* ========================================================================================␊
120+ * Layout is device(VendorId + DeviceId), subdev (SubvendorId + SubdeviceId), display name.␊
121+ * ========================================================================================␊
122+ */␊
123+␉/*Unknown*/␉{ 0x10DE0000,␉NV_SUB_IDS,␉"Unknown" },␊
124+ /* ------ Specific DeviceID and SubDevID. ------ */␊
125+␉// 0000 - 0040␊
126+␉// 0040 - 004F␊
127+␉// 0050 - 005F␊
128+␉// 0060 - 006F␊
129+␉// 0070 - 007F␊
130+␉// 0080 - 008F␊
131+␉// 0090 - 009F␊
132+␉// 00A0 - 00AF␊
133+␉// 00B0 - 00BF␊
134+␉// 00C0 - 00CF␊
135+␉// 00D0 - 00DF␊
136+␉// 00E0 - 00EF␊
137+␉// 00F0 - 00FF␊
138+␉// 0100 - 010F␊
139+␉// 0110 - 011F␊
140+␉// 0120 - 012F␊
141+␉// 0130 - 013F␊
142+␉// 0140 - 014F␊
143+␉// 0150 - 015F␊
144+␉// 0160 - 016F␊
145+␉// 0170 - 017F␊
146+␉// 0180 - 018F␊
147+␉// 0190 - 019F␊
148+␉{ 0x10DE0193,␉0x10438234,␉"Asus GeForce 8800 GTS" },␊
149+␉{ 0x10DE0193,␉0x1043823C,␉"Asus GeForce 8800 GTS" },␊
150+␉{ 0x10DE0193,␉0x1043825F,␉"Asus GeForce 8800 GTS" },␊
151+␉{ 0x10DE0193,␉0x10DE0420,␉"Asus GeForce 8800 GTS" },␊
152+␉{ 0x10DE0193,␉0x10DE0421,␉"Albatron GeForce 8800 GTS" },␊
153+␉{ 0x10DE0193,␉0x19F104A6,␉"BFG GeForce 8800 GTS" },␊
154+␉{ 0x10DE019D,␉0x107D2A72,␉"Leadtek Quadro FX 5600" },␊
155+␉{ 0x10DE019D,␉0x10DE0409,␉"nVidia Quadro FX 5600" },␊
156+␉{ 0x10DE019E,␉0x107D2A72,␉"Leadtek Quadro FX 4600" },␊
157+␉{ 0x10DE019E,␉0x10DE0408,␉"nVidia Quadro FX 4600" }, // fwood␊
158+␉// 01A0 - 01AF␊
159+␉// 01B0 - 01BF␊
160+␉// 01C0 - 01CF␊
161+␉// 01D0 - 01DF␊
162+␉{ 0x10DE01D8,␉0x10250090,␉"Acer GeForce Go 7400" },␊
163+␉{ 0x10DE01D8,␉0x102801C8,␉"Dell GeForce Go 7400" },␊
164+␉{ 0x10DE01D8,␉0x102801CC,␉"Dell Quadro NVS 120M" },␊
165+␉{ 0x10DE01D8,␉0x102801D7,␉"Dell GeForce Go 7400" },␊
166+␉{ 0x10DE01D8,␉0x102801F3,␉"Dell GeForce Go 7400" },␊
167+␉{ 0x10DE01D8,␉0x102801F9,␉"Dell GeForce Go 7400" },␊
168+␉{ 0x10DE01D8,␉0x102801FE,␉"Dell GeForce Go 7400" },␊
169+␉{ 0x10DE01D8,␉0x10280209,␉"Dell GeForce Go 7400" },␊
170+␉{ 0x10DE01D8,␉0x10282003,␉"Dell Quadro NVS 120M" },␊
171+␉{ 0x10DE01D8,␉0x103C30A5,␉"HP GeForce Go 7400" },␊
172+␉{ 0x10DE01D8,␉0x103C30B6,␉"HP GeForce Go 7400" },␊
173+␉{ 0x10DE01D8,␉0x103C30B7,␉"HP GeForce Go 7400" },␊
174+␉{ 0x10DE01D8,␉0x103C30BB,␉"HP GeForce Go 7400" },␊
175+␉{ 0x10DE01D8,␉0x10431211,␉"Asus GeForce Go 7400" },␊
176+␉{ 0x10DE01D8,␉0x10431214,␉"Asus GeForce Go 7400" },␊
177+␉{ 0x10DE01D8,␉0x104D81E6,␉"Sony GeForce Go 7400" },␊
178+␉{ 0x10DE01D8,␉0x104D81EF,␉"Sony GeForce Go 7400" },␊
179+␉{ 0x10DE01D8,␉0x104D81FD,␉"Sony GeForce Go 7400" },␊
180+␉{ 0x10DE01D8,␉0x104D8205,␉"Sony GeForce Go 7400" },␊
181+␉{ 0x10DE01D8,␉0x104D820F,␉"Sony GeForce Go 7400" },␊
182+␉{ 0x10DE01D8,␉0x109F319C,␉"Trigem GeForce Go 7400" },␊
183+␉{ 0x10DE01D8,␉0x109F319D,␉"Trigem GeForce Go 7400" },␊
184+␉{ 0x10DE01D8,␉0x109F3C01,␉"Trigem GeForce Go 7400" },␊
185+␉{ 0x10DE01D8,␉0x11790001,␉"Toshiba GeForce Go 7400" },␊
186+␉{ 0x10DE01D8,␉0x1179FF00,␉"Toshiba GeForce Go 7400" },␊
187+␉{ 0x10DE01D8,␉0x1179FF10,␉"Toshiba GeForce Go 7400" },␊
188+␉{ 0x10DE01D8,␉0x1179FF31,␉"Toshiba GeForce Go 7400" },␊
189+␉{ 0x10DE01D8,␉0x144D8062,␉"Samsung GeForce Go 7400" },␊
190+␉{ 0x10DE01D8,␉0x144DB03C,␉"Samsung GeForce Go 7400" },␊
191+␉{ 0x10DE01D8,␉0x144DC024,␉"Samsung GeForce Go 7400" },␊
192+␉{ 0x10DE01D8,␉0x144DC026,␉"Samsung GeForce Go 7400" },␊
193+␉{ 0x10DE01D8,␉0x14620511,␉"MSi GeForce Go 7400" },␊
194+␉{ 0x10DE01D8,␉0x14623FCC,␉"MSi GeForce Go 7400" },␊
195+␉{ 0x10DE01D8,␉0x14623FDF,␉"MSi GeForce Go 7400" },␊
196+␉{ 0x10DE01D8,␉0x14624327,␉"MSi GeForce Go 7400" },␊
197+ ␉{ 0x10DE01D8,␉0x15092A30,␉"GeForce Go 7400" }, // First International Computer Inc␊
198+␉{ 0x10DE01D8,␉0x152D0753,␉"Quanta GeForce Go 7400" },␊
199+␉{ 0x10DE01D8,␉0x152D0763,␉"Quante GeForce Go 7400" },␊
200+␉{ 0x10DE01D8,␉0x161F203D,␉"Arima GeForce Go 7400" },␊
201+␉{ 0x10DE01D8,␉0x161F2052,␉"Arima GeForce Go 7400" },␊
202+␉{ 0x10DE01D8,␉0x161F2054,␉"Arima GeForce Go 7400" },␊
203+␉{ 0x10DE01D8,␉0x161F205D,␉"Arima GeForce Go 7400" },␊
204+ ␉{ 0x10DE01D8,␉0x1631C022,␉"NEC GeForce Go 7400" },␊
205+␉{ 0x10DE01D8,␉0x173410D3,␉"Fujitsu GeForce Go 7400" },␊
206+␉{ 0x10DE01D8,␉0x17AA2075,␉"Lenovo GeForce Go 7400" },␊
207+␉{ 0x10DE01D8,␉0x17AA3833,␉"Lenovo GeForce Go 7400" },␊
208+␉{ 0x10DE01D8,␉0x17AA39F5,␉"Lenovo GeForce Go 7400" },␊
209+␉{ 0x10DE01D8,␉0x17AA6666,␉"Lenovo GeForce Go 7400" },␊
210+␉{ 0x10DE01D8,␉0x17C0207F,␉"Wistron GeForce Go 7400" },␊
211+ ␉{ 0x10DE01D8,␉0x17C02083,␉"Wistron GeForce Go 7400" },␊
212+␉{ 0x10DE01D8,␉0x17FF500E,␉"Benq GeForce Go 7400" },␊
213+␉{ 0x10DE01D8,␉0x18940040,␉"LG GeForce Go 7400" },␊
214+␉{ 0x10DE01D8,␉0x18640041,␉"LG GeForce Go 7400" },␊
215+␉{ 0x10DE01D8,␉0x18640042,␉"LG GeForce Go 7400" },␊
216+␉{ 0x10DE01D8,␉0x18640043,␉"LG GeForce Go 7400" },␊
217+␉{ 0x10DE01D8,␉0x18640044,␉"LG GeForce Go 7400" },␊
218+ ␉{ 0x10DE01D8,␉0x18640045,␉"LG GeForce Go 7400" },␊
219+␉{ 0x10DE01D8,␉0x18640046,␉"LG GeForce Go 7400" },␊
220+␉{ 0x10DE01D8,␉0x18640047,␉"LG GeForce Go 7400" },␊
221+␉{ 0x10DE01D8,␉0x1864007A,␉"LG GeForce Go 7400" },␊
222+␉{ 0x10DE01D8,␉0x19614605,␉"ESS GeForce Go 7400" },␊
223+␉{ 0x10DE01D8,␉0x19615607,␉"ESS GeForce Go 7400" },␊
224+␉{ 0x10DE01D8,␉0x19915532,␉"GeForce Go 7400" }, // Topstar Digital Technologies Co., Ltd.␊
225+ ␉{ 0x10DE01D8,␉0x19DB2174,␉"GeForce Go 7400" }, // ??␊
226+␉{ 0x10DE01D8,␉0xC0181631,␉"GeForce Go 7400" }, // ??␊
227+␉{ 0x10DE01DA,␉0x1028017D,␉"Dell Quadro NVS 110M" },␊
228+␉{ 0x10DE01DA,␉0x10280407,␉"Dell GeForce 7300 LE" },␊
229+␉{ 0x10DE01DA,␉0x11790001,␉"Toshiba Quadro NVS 110M" },␊
230+␉{ 0x10DE01DA,␉0x11790002,␉"Toshiba Quadro NVS 110M" },␊
231+␉{ 0x10DE01DA,␉0x11790010,␉"Toshiba Quadro NVS 110M" },␊
232+␉{ 0x10DE01DA,␉0x1179FF00,␉"Toshiba Quadro NVS 110M" },␊
233+␉{ 0x10DE01DA,␉0x1179FF10,␉"Toshiba Quadro NVS 110M" },␊
234+␉// 01E0 - 01EF␊
235+␉// 01F0 - 01FF␊
236+␉// 0200 - 020F␊
237+␉// 0210 - 021F␊
238+␉// 0220 - 022F␊
239+␉// 0230 - 023F␊
240+␉// 0240 - 024F␊
241+␉// 0250 - 025F␊
242+␉// 0260 - 026F␊
243+␉// 0270 - 027F␊
244+␉// 0280 - 028F␊
245+␉// 0290 - 029F␊
246+␉// 02A0 - 02AF␊
247+␉// 02B0 - 02BF␊
248+␉// 02C0 - 02CF␊
249+␉// 02D0 - 02DF␊
250+␉// 02E0 - 02EF␊
251+␉// 02F0 - 02FF␊
252+␉// 0300 - 030F␊
253+␉// 0310 - 031F␊
254+␉// 0320 - 032F␊
255+␉// 0330 - 033F␊
256+␉// 0340 - 034F␊
257+␉// 0350 - 035F␊
258+␉// 0360 - 036F␊
259+␉// 0370 - 037F␊
260+␉// 0380 - 038F␊
261+␉// 0390 - 039F␊
262+␉// 03A0 - 03AF␊
263+␉// 03B0 - 03BF␊
264+␉// 03C0 - 03CF␊
265+␉// 03D0 - 03DF␊
266+␉// 03E0 - 03EF␊
267+␉// 03F0 - 03FF␊
268+␉// 0400 - 040F␊
269+␉{ 0x10DE0402,␉0x10DE0439,␉"Galaxy 8600GT" }, // pianman␊
270+␉{ 0x10DE0407,␉0x101922D4,␉"Elitegroup GeForce 8600M GT" },␊
271+␉{ 0x10DE0407,␉0x1025011D,␉"Acer GeForce 8600M GT" },␊
272+␉{ 0x10DE0407,␉0x1025011E,␉"Acer GeForce 8600M GT" },␊
273+␉{ 0x10DE0407,␉0x10250121,␉"Acer GeForce 8600M GT" },␊
274+␉{ 0x10DE0407,␉0x10250125,␉"Acer GeForce 8600M GT" },␊
275+␉{ 0x10DE0407,␉0x10250126,␉"Acer GeForce 8600M GT" },␊
276+␉{ 0x10DE0407,␉0x10250127,␉"Acer GeForce 8600M GT" },␊
277+␉{ 0x10DE0407,␉0x10250129,␉"Acer GeForce 8600M GT" },␊
278+␉{ 0x10DE0407,␉0x1025012B,␉"Acer GeForce 8600M GT" },␊
279+␉{ 0x10DE0407,␉0x10250136,␉"Acer GeForce 8600M GT" },␊
280+␉{ 0x10DE0407,␉0x1025013D,␉"Acer GeForce 8600M GT" },␊
281+␉{ 0x10DE0407,␉0x1025013F,␉"Acer GeForce 8600M GT" },␊
282+␉{ 0x10DE0407,␉0x10250142,␉"Acer GeForce 8600M GT" },␊
283+␉{ 0x10DE0407,␉0x10250143,␉"Acer GeForce 8600M GT" },␊
284+␉{ 0x10DE0407,␉0x10250145,␉"Acer GeForce 8600M GT" },␊
285+␉{ 0x10DE0407,␉0x10250146,␉"Acer GeForce 8600M GT" },␊
286+␉{ 0x10DE0407,␉0x1025015E,␉"Acer GeForce 8600M GT" },␊
287+␉{ 0x10DE0407,␉0x1028019C,␉"Dell GeForce 8600M GT" },␊
288+␉{ 0x10DE0407,␉0x102801F1,␉"Dell GeForce 8600M GT" }, // LatinMcG␊
289+␉{ 0x10DE0407,␉0x102801F2,␉"Dell GeForce 8600M GT" },␊
290+␉{ 0x10DE0407,␉0x10280228,␉"Dell GeForce 8600M GT" },␊
291+␉{ 0x10DE0407,␉0x10280229,␉"Dell GeForce 8600M GT" },␊
292+␉{ 0x10DE0407,␉0x1028022E,␉"Dell GeForce 8600M GT" }, // DarwinX␊
293+␉{ 0x10DE0407,␉0x10431515,␉"Asus GeForce 8600M GT" },␊
294+␉{ 0x10DE0407,␉0x10431588,␉"Asus GeForce 8600M GT" },␊
295+␉{ 0x10DE0407,␉0x10431618,␉"Asus GeForce 8600M GT" },␊
296+␉{ 0x10DE0407,␉0x10431632,␉"Asus GeForce 8600M GT" },␊
297+␉{ 0x10DE0407,␉0x104314A2,␉"Asus GeForce 8600M GT" },␊
298+␉{ 0x10DE0407,␉0x104381F7,␉"Asus GeForce 8600M GT" },␊
299+␉{ 0x10DE0407,␉0x104D9005,␉"Sony GeForce 8600M GT" },␊
300+␉{ 0x10DE0407,␉0x104D9016,␉"Sony GeForce 8600M GT" },␊
301+␉{ 0x10DE0407,␉0x104D9018,␉"Sony GeForce 8600M GT" },␊
302+␉{ 0x10DE0407,␉0x106B00A0,␉"Apple GeForce 8600M GT" },␊
303+␉{ 0x10DE0407,␉0x106B00A3,␉"Apple GeForce 8600M GT" },␊
304+␉{ 0x10DE0407,␉0x106B00A4,␉"Apple GeForce 8600M GT" },␊
305+␉// 0410 - 041F␊
306+␉// 0420 - 042F␊
307+␉// 0430 - 043F␊
308+␉// 0440 - 044F␊
309+␉// 0450 - 045F␊
310+␉// 0460 - 046F␊
311+␉// 0470 - 047F␊
312+␉// 0480 - 048F␊
313+␉// 0490 - 049F␊
314+␉// 04A0 - 04AF␊
315+␉// 04B0 - 04BF␊
316+␉// 04C0 - 04CF␊
317+␉// 04D0 - 04DF␊
318+␉// 04E0 - 04EF␊
319+␉// 04F0 - 04FF␊
320+␉// 0500 - 050F␊
321+␉// 0510 - 051F␊
322+␉// 0520 - 052F␊
323+␉// 0530 - 053F␊
324+␉// 0540 - 054F␊
325+␉// 0550 - 055F␊
326+␉// 0560 - 056F␊
327+␉// 0570 - 057F␊
328+␉// 0580 - 058F␊
329+␉// 0590 - 059F␊
330+␉// 05A0 - 05AF␊
331+␉// 05B0 - 05BF␊
332+␉// 05C0 - 05CF␊
333+␉// 05D0 - 05DF␊
334+␉// 05E0 - 05EF␊
335+␉{ 0x10DE05E0,␉0x10DE064E,␉"nVidia GeForce GTX 295" },␊
336+␉{ 0x10DE05E0,␉0x38421291,␉"EVGA GeForce GTX 295" },␊
337+␉{ 0x10DE05E2,␉0x10438291,␉"Asus GTX 260" },␊
338+␉{ 0x10DE05E2,␉0x10438298,␉"Asus GTX 260" },␊
339+␉{ 0x10DE05E2,␉0x104382C4,␉"Asus GTX 260" },␊
340+␉{ 0x10DE05E2,␉0x104382CF,␉"Asus GTX 260" },␊
341+␉{ 0x10DE05E2,␉0x104382E3,␉"Asus GTX 260" },␊
342+␉{ 0x10DE05E2,␉0x10B00801,␉"Gainward GTX 260" },␊
343+␉{ 0x10DE05E2,␉0x10DE0585,␉"nVidia GTX 260" },␊
344+␉{ 0x10DE05E2,␉0x10DE0617,␉"nVidia GTX 260" },␊
345+␉{ 0x10DE05E2,␉0x16822390,␉"HFX GTX 260" },␊
346+␉{ 0x10DE05E2,␉0x17870000,␉"HIS GTX 260" },␊
347+␉{ 0x10DE05E2,␉0x34421260,␉"Bihl GTX 260" },␊
348+␉{ 0x10DE05E2,␉0x34421262,␉"Bihl GTX 260" },␊
349+␉{ 0x10DE05E2,␉0x73770000,␉"Colorful GTX 260" },␊
350+␉{ 0x10DE05E3,␉0x10438320,␉"Asus GeForce GTX 285" }, // mauriziopasotti␊
351+␉{ 0x10DE05E3,␉0x106B0000,␉"Apple GeForce GTX 285" },␊
352+␉{ 0x10DE05E3,␉0x10DE065B,␉"nVidia GeForce GTX 285" },␊
353+␉{ 0x10DE05E3,␉0x38421080,␉"EVGA GeForce GTX 285" },␊
354+␉{ 0x10DE05E3,␉0x38421187,␉"EVGA GeForce GTX 285" },␊
355+␉{ 0x10DE05E7,␉0x10DE0595,␉"nVidia Tesla T10 Processor" },␊
356+␉{ 0x10DE05E7,␉0x10DE066A,␉"nVidia Tesla C1060" },␊
357+␉{ 0x10DE05E7,␉0x10DE068F,␉"nVidia Tesla T10 Processor" },␊
358+␉{ 0x10DE05E7,␉0x10DE0697,␉"nVidia Tesla M1060" },␊
359+␉{ 0x10DE05E7,␉0x10DE0714,␉"nVidia Tesla M1060" },␊
360+␉{ 0x10DE05E7,␉0x10DE0743,␉"nVidia Tesla M1060" },␊
361+␉{ 0x10DE05EB,␉0x10DE0705,␉"nVidia GeForce GTX 295" },␊
362+␉{ 0x10DE05EB,␉0x19F110C2,␉"BFG GeForce GTX 295" },␊
363+␉// 05F0 - 05FF␊
364+␉// 0600 - 060F␊
365+␉{ 0x10DE0600,␉0x10438268,␉"Asus GeForce 8800 GTS" },␊
366+␉{ 0x10DE0600,␉0x1043826C,␉"Asus GeForce 8800 GTS" },␊
367+␉{ 0x10DE0600,␉0x10DE0000,␉"Abit GeForce 8800 GTS" },␊
368+␉{ 0x10DE0600,␉0x10DE0502,␉"nVidia GeForce 8800 GTS" },␊
369+␉{ 0x10DE0600,␉0x19F10719,␉"BFG GeForce 8800 GTS" },␊
370+␉// 0610 - 061F␊
371+␉{ 0x10DE0611,␉0x104381F7,␉"Asus GeForce 8800 GT" },␊
372+␉{ 0x10DE0611,␉0x10DE053C,␉"nVidia GeForce 8800 GT" },␊
373+␉{ 0x10DE0611,␉0x14621171,␉"MSi GeForce 8800 GT" },␊
374+␉{ 0x10DE0611,␉0x14621172,␉"MSi GeForce 8800 GT" },␊
375+␉{ 0x10DE0611,␉0x174B9210,␉"PC Partner GeForce 8800 GT" },␊
376+␉{ 0x10DE0611,␉0x1ACC8582,␉"Point of View GeForce 8800 GT" }, // Alex//3oo1␊
377+␉{ 0x10DE0611,␉0x3842C802,␉"EVGA GeForce 8800 GT" },␊
378+␉{ 0x10DE0618,␉0x1025028E,␉"Acer GeForce GTX 260M" },␊
379+␉{ 0x10DE0618,␉0x102802A1,␉"Dell GeForce GTX 260M" },␊
380+␉{ 0x10DE0618,␉0x102802A2,␉"Dell GeForce GTX 260M" },␊
381+␉{ 0x10DE0618,␉0x10431A52,␉"Asus GeForce GTX 260M" },␊
382+␉{ 0x10DE0618,␉0x10432028,␉"Asus GeForce GTX 170M" },␊
383+␉{ 0x10DE0618,␉0x1043202B,␉"Asus GTX 680" },␊
384+␉{ 0x10DE0618,␉0x10432033,␉"Asus GeForce GTX 260M" },␊
385+␉{ 0x10DE0618,␉0x15580481,␉"Clevo/Kapok GeForce GTX 260M" },␊
386+␉{ 0x10DE0618,␉0x15580577,␉"Clevo/Kapok GeForce GTX 260M" },␊
387+␉{ 0x10DE0618,␉0x15580860,␉"Clevo/Kapok GeForce GTX 260M" },␊
388+␉// 0620 - 062F␊
389+␉{ 0x10DE0622,␉0x104382AC,␉"Asus EN9600GT Magic" }, // Fabio71␊
390+␉// 0630 - 063F␊
391+␉// 0640 - 064F␊
392+␉{ 0x10DE0640,␉0x106B00AD,␉"Apple GeForge 9500 GT" },␊
393+␉{ 0x10DE0640,␉0x106B00B3,␉"Apple GeForge 9500 GT" },␊
394+␉{ 0x10DE0640,␉0x106B061B,␉"Apple GeForge 9500 GT" },␊
395+␉{ 0x10DE0640,␉0x10DE077F,␉"Inno3D GeForge 9500GT HDMI" }, // Fabio71␊
396+␉{ 0x10DE0640,␉0x14621290,␉"MSi GeForge 9500 GT" },␊
397+␉{ 0x10DE0640,␉0x14621291,␉"MSi GeForge 9500 GT" },␊
398+␉{ 0x10DE0640,␉0x16423796,␉"Bitland GeForge 9500 GT" },␊
399+␉// 0650 - 065F␊
400+␉// 0660 - 066F␊
401+␉// 0670 - 067F␊
402+␉// 0680 - 068F␊
403+␉// 0690 - 069F␊
404+␉// 06A0 - 06AF␊
405+␉// 06B0 - 06BF␊
406+␉// 06C0 - 06CF␊
407+␉{ 0x10DE06C0,␉0x10DE075F,␉"nVidia GeForce GTX 480" },␊
408+␉// { 0x10DE06C0,␉0x19DA0010,␉"Zotac GTX 480 AMP" },␊
409+␉{ 0x10DE06C0,␉0x38421482,␉"EVGA GTX 480" },␊
410+␉{ 0x10DE06CD,␉0x10DE079F,␉"Point of View GeForce GTX 470" }, // Alex//3oo1␊
411+␉{ 0x10DE06CD,␉0x10DE979F,␉"nVidia GeForce GTX 470" },␊
412+␉{ 0x10DE06CD,␉0x19DA0010,␉"Zotac GTX 470" },␊
413+␉{ 0x10DE06CD,␉0x19DA1153,␉"Zotac GeForce GTX 470" }, // magnifico10 and Fabio71 TODO: AMP???␊
414+␉// 06D0 - 06DF␊
415+␉{ 0x10DE06D1,␉0x10DE0771,␉"nVidia Tesla C2050" },␊
416+␉{ 0x10DE06D1,␉0x10DE0772,␉"nVidia Tesla C2070" },␊
417+␉{ 0x10DE06D2,␉0x10DE0774,␉"nVidia Tesla M2070" },␊
418+␉{ 0x10DE06D2,␉0x10DE0830,␉"nVidia Tesla M2070" },␊
419+␉{ 0x10DE06D2,␉0x10DE0842,␉"nVidia Tesla M2070" },␊
420+␉{ 0x10DE06D2,␉0x10DE088F,␉"nVidia Tesla X2070" },␊
421+␉{ 0x10DE06D2,␉0x10DE0908,␉"nVidia Tesla M2070" },␊
422+␉{ 0x10DE06DD,␉0x103C076F,␉"HP Quadro 6000" },␊
423+␉{ 0x10DE06DD,␉0x10DE076F,␉"nVidia Quadro 6000" },␊
424+␉{ 0x10DE06D9,␉0x103C0770,␉"HP Quadro 5000" },␊
425+␉{ 0x10DE06D9,␉0x10DE0770,␉"nVidia Quadro 5000" },␊
426+␉{ 0x10DE06DD,␉0x1028081A,␉"Dell Quadro 5000M" },␊
427+␉{ 0x10DE06DD,␉0x103C1520,␉"HP Quadro 5000M" },␊
428+␉{ 0x10DE06DD,␉0x103C0780,␉"HP Quadro 4000" },␊
429+␉{ 0x10DE06DD,␉0x10DE0780,␉"nVidia Quadro 4000" },␊
430+␉{ 0x10DE06DE,␉0x10DE0773,␉"nVidia Tesla S2050" },␊
431+␉{ 0x10DE06DE,␉0x10DE077A,␉"nVidia Tesla M2050" },␊
432+␉{ 0x10DE06DE,␉0x10DE082F,␉"nVidia Tesla M2050" },␊
433+␉{ 0x10DE06DE,␉0x10DE0830,␉"nVidia Tesla M2070" },␊
434+␉{ 0x10DE06DE,␉0x10DE0831,␉"nVidia Tesla M2070" },␊
435+␉{ 0x10DE06DE,␉0x10DE0832,␉"nVidia Tesla M2070" },␊
436+␉{ 0x10DE06DE,␉0x10DE0840,␉"nVidia Tesla X2070" },␊
437+␉{ 0x10DE06DE,␉0x10DE0842,␉"nVidia Tesla M2050" },␊
438+␉{ 0x10DE06DE,␉0x10DE0843,␉"nVidia Tesla M2050" },␊
439+␉{ 0x10DE06DE,␉0x10DE0846,␉"nVidia Tesla M2050" },␊
440+␉{ 0x10DE06DE,␉0x10DE0866,␉"nVidia Tesla M2050" },␊
441+␉{ 0x10DE06DE,␉0x10DE0907,␉"nVidia Tesla M2050" },␊
442+␉{ 0x10DE06DE,␉0x10DE091E,␉"nVidia Tesla M2050" },␊
443+␉{ 0x10DE06DF,␉0x10DE0842,␉"nVidia Tesla M2070-Q" },␊
444+␉{ 0x10DE06DF,␉0x10DE084D,␉"nVidia Tesla M2070-Q" },␊
445+␉{ 0x10DE06DF,␉0x10DE087F,␉"nVidia Tesla M2070-Q" },␊
446+␉// 06E0 - 06EF␊
447+␉{ 0x10DE06E4,␉0x10438322,␉"Asus EN8400GS" }, // Fabio71␊
448+␉{ 0x10DE06E4,␉0x14583475,␉"GV-NX84S256HE [GeForce 8400 GS]" },␊
449+␉{ 0x10DE06E8,␉0x10280262,␉"Dell GeForce 9200M GS" },␊
450+␉{ 0x10DE06E8,␉0x10280271,␉"Dell GeForce 9200M GS" },␊
451+␉{ 0x10DE06E8,␉0x10280272,␉"Dell GeForce 9200M GS" },␊
452+␉{ 0x10DE06E8,␉0x103C30F4,␉"HP GeForce 9200M GS" },␊
453+␉{ 0x10DE06E8,␉0x103C30F7,␉"HP GeForce 9200M GS" },␊
454+␉{ 0x10DE06E8,␉0x103C3603,␉"HP GeForce 9200M GS" },␊
455+␉{ 0x10DE06E8,␉0x103C360B,␉"HP GeForce 9200M GE" },␊
456+␉{ 0x10DE06E8,␉0x103C3621,␉"HP GeForce 9200M GE" },␊
457+␉{ 0x10DE06E8,␉0x103C3629,␉"HP GeForce 9200M GE" },␊
458+␉{ 0x10DE06E8,␉0x10432008,␉"Asus GeForce 9200M GE" },␊
459+␉{ 0x10DE06E8,␉0x107B0900,␉"Gateway GeForce 9200M GE" },␊
460+␉{ 0x10DE06E8,␉0x11790001,␉"Toshiba GeForce 9200M GE" },␊
461+␉{ 0x10DE06E8,␉0x144DC041,␉"Samsung GeForce 9200M GE" },␊
462+␉{ 0x10DE06E8,␉0x144DC042,␉"Samsung GeForce 9200M GE" },␊
463+␉{ 0x10DE06E8,␉0x144DC048,␉"Samsung GeForce 9200M GE" },␊
464+␉{ 0x10DE06E8,␉0x144DC04A,␉"Samsung GeForce 9200M GE" },␊
465+␉{ 0x10DE06E8,␉0x144DC521,␉"Samsung GeForce 9200M GE" },␊
466+␉{ 0x10DE06E8,␉0x144DC524,␉"Samsung GeForce 9200M GE" },␊
467+␉{ 0x10DE06E8,␉0x152D0772,␉"Quanta GeForce 9200M GE" },␊
468+␉{ 0x10DE06E8,␉0x152D0773,␉"Quanta GeForce 9200M GE" },␊
469+␉{ 0x10DE06E8,␉0x152D0774,␉"Quanta GeForce 9200M GE" },␊
470+␉{ 0x10DE06E8,␉0x152D0775,␉"Quanta GeForce 9200M GE" },␊
471+␉{ 0x10DE06E8,␉0x17341146,␉"Fujitsu GeForce 9200M GE" },␊
472+␉{ 0x10DE06E8,␉0x18541772,␉"LG GeForce 9200M GE" },␊
473+␉{ 0x10DE06E8,␉0x18541773,␉"LG GeForce 9200M GE" },␊
474+␉{ 0x10DE06E8,␉0x18541774,␉"LG GeForce 9200M GE" },␊
475+␉{ 0x10DE06E8,␉0x18541775,␉"LG GeForce 9200M GE" },␊
476+␉{ 0x10DE06E8,␉0x19614605,␉"ESS GeForce 9200M GE" },␊
477+␉{ 0x10DE06E8,␉0x19615584,␉"ESS GeForce 9200M GE" },␊
478+␉{ 0x10DE06E8,␉0x1B0A000E,␉"Pegatron GeForce 9200M GE" },␊
479+␉// 06F0 - 06FF␊
480+␉// 0700 - 070F␊
481+␉// 0710 - 071F␊
482+␉// 0720 - 072F␊
483+␉// 0730 - 073F␊
484+␉// 0740 - 074F␊
485+␉// 0750 - 075F␊
486+␉// 0760 - 076F␊
487+␉// 0770 - 077F␊
488+␉// 0780 - 078F␊
489+␉// 0790 - 079F␊
490+␉// 07A0 - 07AF␊
491+␉// 07B0 - 07BF␊
492+␉// 07C0 - 07CF␊
493+␉// 07D0 - 07DF␊
494+␉// 07E0 - 07EF␊
495+␉// 07F0 - 07FF␊
496+␉// 0800 - 080F␊
497+␉// 0810 - 081F␊
498+␉// 0820 - 082F␊
499+␉// 0830 - 083F␊
500+␉// 0840 - 084F␊
501+␉// 0850 - 085F␊
502+␉// 0860 - 086F␊
503+␉// 0870 - 087F␊
504+␉{ 0x10DE0876,␉0x103C3651,␉"HP ION" },␊
505+␉{ 0x10DE0876,␉0x10438402,␉"Asus ION" },␊
506+␉// 0880 - 088F␊
507+␉// 0890 - 089F␊
508+␉// 08A0 - 08AF␊
509+␉// 08B0 - 08BF␊
510+␉// 08C0 - 08CF␊
511+␉// 08D0 - 08DF␊
512+␉// 08E0 - 08EF␊
513+␉// 08F0 - 08FF␊
514+␉// 0900 - 090F␊
515+␉// 0910 - 091F␊
516+␉// 0920 - 092F␊
517+␉// 0930 - 093F␊
518+␉// 0940 - 094F␊
519+␉// 0950 - 095F␊
520+␉// 0960 - 096F␊
521+␉// 0970 - 097F␊
522+␉// 0980 - 098F␊
523+␉// 0990 - 099F␊
524+␉// 09A0 - 09AF␊
525+␉// 09B0 - 09BF␊
526+␉// 09C0 - 09CF␊
527+␉// 09D0 - 09DF␊
528+␉// 09E0 - 09EF␊
529+␉// 09F0 - 09FF␊
530+␉// 0A00 - 0A0F␊
531+␉// 0A10 - 0A1F␊
532+␉// 0A20 - 0A2F␊
533+␉{ 0x10DE0A20,␉0x10438311,␉"Asus GeForce GT 220" },␊
534+␉// 0A30 - 0A3F␊
535+␉// 0A40 - 0A4F␊
536+␉// 0A50 - 0A5F␊
537+␉// 0A60 - 0A6F␊
538+␉{ 0x10DE0A64,␉0x1025063C,␉"Acer ION" },␊
539+␉{ 0x10DE0A64,␉0x103C2AAD,␉"HP ION" },␊
540+␉{ 0x10DE0A64,␉0x10430010,␉"Asus ION2" }, // buoo␊
541+␉{ 0x10DE0A64,␉0x1043841F,␉"Asus ION" },␊
542+␉{ 0x10DE0A64,␉0x1043842F,␉"Asus ION" },␊
543+␉{ 0x10DE0A64,␉0x10438455,␉"Asus ION" },␊
544+␉{ 0x10DE0A64,␉0x1043845B,␉"Asus ION" },␊
545+␉{ 0x10DE0A64,␉0x1043845E,␉"Asus ION" },␊
546+␉{ 0x10DE0A64,␉0x17AA3605,␉"Lenovo ION" },␊
547+␉{ 0x10DE0A64,␉0x18490A64,␉"ASRock ION" },␊
548+␉{ 0x10DE0A64,␉0x1B0A00CE,␉"Pegatron ION" },␊
549+ ␉{ 0x10DE0A64,␉0x1B0A00D7,␉"Pegatron ION" },␊
550+␉{ 0x10DE0A65,␉0x10438334,␉"Asus GeForce 210" },␊
551+␉{ 0x10DE0A65,␉0x10438353,␉"Asus GeForce 210" },␊
552+␉{ 0x10DE0A65,␉0x10438354,␉"Asus GeForce 210" },␊
553+␉{ 0x10DE0A65,␉0x10DE0794,␉"nVidia GeForce 210" },␊
554+␉{ 0x10DE0A65,␉0x10DE0847,␉"nVidia GeForce 210" },␊
555+␉{ 0x10DE0A65,␉0x145834D5,␉"GigaByte GeForce 210" },␊
556+␉{ 0x10DE0A65,␉0x145834EF,␉"GigaByte GeForce 210" },␊
557+␉{ 0x10DE0A65,␉0x16822941,␉"XFX GeForce 210" },␊
558+␉{ 0x10DE0A6C,␉0x1028040B,␉"Dell NVS 3100M" },␊
559+␉{ 0x10DE0A6C,␉0x17AA2142,␉"Lenovo NVS 3100M" },␊
560+␉// 0A70 - 0A7F␊
561+␉// 0A80 - 0A8F␊
562+␉// 0A90 - 0A9F␊
563+␉// 0AA0 - 0AAF␊
564+␉// 0AB0 - 0ABF␊
565+␉// 0AC0 - 0ACF␊
566+␉// 0AD0 - 0ADF␊
567+␉// 0AE0 - 0AEF␊
568+␉// 0AF0 - 0AFF␊
569+␉// 0B00 - 0B0F␊
570+␉// 0B10 - 0B1F␊
571+␉// 0B20 - 0B2F␊
572+␉// 0B30 - 0B3F␊
573+␉// 0B40 - 0B4F␊
574+␉// 0B50 - 0B5F␊
575+␉// 0B60 - 0B6F␊
576+␉// 0B70 - 0B7F␊
577+␉// 0B80 - 0B8F␊
578+␉// 0B90 - 0B9F␊
579+␉// 0BA0 - 0BAF␊
580+␉// 0BB0 - 0BBF␊
581+␉// 0BC0 - 0BCF␊
582+␉// 0BD0 - 0BDF␊
583+␉// 0BE0 - 0BEF␊
584+␉// 0BF0 - 0BFF␊
585+␉// 0C00 - 0C0F␊
586+␉// 0C10 - 0C1F␊
587+␉// 0C20 - 0C2F␊
588+␉// 0C30 - 0C3F␊
589+␉// 0C40 - 0C4F␊
590+␉// 0C50 - 0C5F␊
591+␉// 0C60 - 0C6F␊
592+␉// 0C70 - 0C7F␊
593+␉// 0C80 - 0C8F␊
594+␉// 0C90 - 0C9F␊
595+␉// 0CA0 - 0CAF␊
596+␉{ 0x10DE0CA3,␉0x10438326,␉"Asus GeForce GT 240" },␊
597+␉{ 0x10DE0CA3,␉0x10438328,␉"Asus GeForce GT 240" },␊
598+␉{ 0x10DE0CA3,␉0x1043832A,␉"Asus GeForce GT 240" },␊
599+␉{ 0x10DE0CA3,␉0x1043832E,␉"Asus GeForce GT 240" },␊
600+␉{ 0x10DE0CA3,␉0x10438335,␉"Asus GeForce GT 240" },␊
601+␉{ 0x10DE0CA3,␉0x145834E2,␉"GigaByte GeForce GT 240" },␊
602+␉{ 0x10DE0CA3,␉0x145834E5,␉"GigaByte GeForce GT 240" },␊
603+␉{ 0x10DE0CA3,␉0x145834E6,␉"GigaByte GeForce GT 240" },␊
604+␉{ 0x10DE0CA3,␉0x14621900,␉"MSi GeForce GT 230" },␊
605+␉{ 0x10DE0CA3,␉0x14621913,␉"MSi GeForce GT 230" },␊
606+␉{ 0x10DE0CA3,␉0x14622070,␉"MSi GeForce GT 240" },␊
607+␉{ 0x10DE0CA3,␉0x14622072,␉"MSi GeForce GT 240" },␊
608+␉{ 0x10DE0CA3,␉0x14622073,␉"MSi GeForce GT 240" },␊
609+␉{ 0x10DE0CA3,␉0x14628010,␉"MSi GeForce GT 240" },␊
610+␉{ 0x10DE0CA3,␉0x14628041,␉"MSi VN240GT-MD1G" }, //Fabio71␊
611+␉{ 0x10DE0CA3,␉0x16423926,␉"Bitland GeForce GT 230" },␊
612+␉{ 0x10DE0CA3,␉0x196E0010,␉"PNY GeForce GT 240" },␊
613+␉{ 0x10DE0CA3,␉0x196E069D,␉"PNY GeForce GT 240" }, // ErmaC␊
614+␉{ 0x10DE0CA3,␉0x196E075B,␉"PNY GeForce GT 240" },␊
615+␉{ 0x10DE0CA3,␉0x19DA1142,␉"Zotac GeForce GT 240" },␊
616+␉{ 0x10DE0CA3,␉0x19DA1143,␉"Zotac GeForce GT 240" },␊
617+␉{ 0x10DE0CA3,␉0x19DA1144,␉"Zotac GeForce GT 240" },␊
618+␉{ 0x10DE0CA3,␉0x19DA2130,␉"Zotac GeForce GT 240" },␊
619+␉{ 0x10DE0CA3,␉0x19DA2134,␉"Zotac GeForce GT 240" },␊
620+␉// 0CB0 - 0CBF␊
621+␉// 0CC0 - 0CCF␊
622+␉// 0CD0 - 0CDF␊
623+␉// 0CE0 - 0CEF␊
624+␉// 0CF0 - 0CFF␊
625+␉// 0D00 - 0D0F␊
626+␉// 0D10 - 0D1F␊
627+␉// 0D20 - 0D2F␊
628+␉// 0D30 - 0D3F␊
629+␉// 0D40 - 0D4F␊
630+␉// 0D50 - 0D5F␊
631+␉// 0D60 - 0D6F␊
632+␉// 0D70 - 0D7F␊
633+␉// 0D80 - 0D8F␊
634+␉// 0D90 - 0D9F␊
635+␉// 0DA0 - 0DAF␊
636+␉// 0DB0 - 0DBF␊
637+␉// 0DC0 - 0DCF␊
638+␉{ 0x10DE0DD1,␉0x102802A2,␉"Dell GeForce GTX 460M" },␊
639+␉{ 0x10DE0DD1,␉0x1028048F,␉"Dell GeForce GTX 460M" },␊
640+␉{ 0x10DE0DD1,␉0x10280490,␉"Dell GeForce GTX 460M" },␊
641+␉{ 0x10DE0DD1,␉0x10280491,␉"Dell GeForce GTX 460M" },␊
642+␉{ 0x10DE0DD1,␉0x102804BA,␉"Dell GeForce GTX 460M" },␊
643+␉{ 0x10DE0DD1,␉0x1043203D,␉"Asus GeForce GTX 460M" },␊
644+␉{ 0x10DE0DD1,␉0x1043203E,␉"Asus GeForce GTX 460M" },␊
645+␉{ 0x10DE0DD1,␉0x10432040,␉"Asus GeForce GTX 460M" },␊
646+␉{ 0x10DE0DD1,␉0x10432041,␉"Asus GeForce GTX 460M" },␊
647+␉{ 0x10DE0DD1,␉0x10432042,␉"Asus GeForce GTX 460M" },␊
648+␉{ 0x10DE0DD1,␉0x10432043,␉"Asus GeForce GTX 460M" },␊
649+␉{ 0x10DE0DD1,␉0x10432044,␉"Asus GeForce GTX 460M" },␊
650+␉{ 0x10DE0DD1,␉0x10432045,␉"Asus GeForce GTX 460M" },␊
651+␉{ 0x10DE0DD1,␉0x10432046,␉"Asus GeForce GTX 460M" },␊
652+␉{ 0x10DE0DD1,␉0x10432047,␉"Asus GeForce GTX 460M" },␊
653+␉{ 0x10DE0DD1,␉0x10432048,␉"Asus GeForce GTX 460M" },␊
654+␉{ 0x10DE0DD1,␉0x1043204A,␉"Asus GeForce GTX 460M" },␊
655+␉{ 0x10DE0DD1,␉0x1043204B,␉"Asus GeForce GTX 460M" },␊
656+␉{ 0x10DE0DD1,␉0x10438465,␉"Asus GeForce GTX 460M" },␊
657+␉{ 0x10DE0DD1,␉0x10DE10DE,␉"nVidia GeForce GTX 460M" },␊
658+␉{ 0x10DE0DD1,␉0x1179FC00,␉"Toshiba GeForce GTX 460M" },␊
659+␉{ 0x10DE0DD1,␉0x1179FC01,␉"Toshiba GeForce GTX 460M" },␊
660+␉{ 0x10DE0DD1,␉0x1179FC05,␉"Toshiba GeForce GTX 460M" },␊
661+␉{ 0x10DE0DD1,␉0x1179FCB0,␉"Toshiba GeForce GTX 460M" },␊
662+␉{ 0x10DE0DD1,␉0x1179FF50,␉"Toshiba GeForce GTX 460M" },␊
663+␉{ 0x10DE0DD1,␉0x1179FFD6,␉"Toshiba GeForce GTX 460M" },␊
664+␉{ 0x10DE0DD1,␉0x1179FFD7,␉"Toshiba GeForce GTX 460M" },␊
665+␉{ 0x10DE0DD1,␉0x1179FFD8,␉"Toshiba GeForce GTX 460M" },␊
666+␉{ 0x10DE0DD1,␉0x14621083,␉"MSi GeForce GTX 460M" },␊
667+␉{ 0x10DE0DD1,␉0x15585102,␉"Clevo/Kapok GeForce GTX 460M" },␊
668+␉{ 0x10DE0DD1,␉0x15587100,␉"Clevo/Kapok GeForce GTX 460M" },␊
669+␉{ 0x10DE0DD1,␉0x15587200,␉"Clevo/Kapok GeForce GTX 460M" },␊
670+␉{ 0x10DE0DD1,␉0x15588100,␉"Clevo/Kapok GeForce GTX 460M" },␊
671+␉{ 0x10DE0DD1,␉0x15588687,␉"Clevo/Kapok GeForce GTX 460M" },␊
672+␉{ 0x10DE0DD1,␉0x17AA3620,␉"Lenovo GeForce GTX 460M" },␊
673+␉{ 0x10DE0DD1,␉0x17C010EA,␉"Wistron GeForce GTX 460M" },␊
674+␉{ 0x10DE0DD6,␉0x10280010,␉"Dell GeForce GT 550M" },␊
675+␉{ 0x10DE0DD8,␉0x103C084A,␉"HP nVidia Quadro 2000" },␊
676+␉{ 0x10DE0DD8,␉0x10DE084A,␉"nVidia Quadro 2000" }, // mauriziopasotti␊
677+␉{ 0x10DE0DD8,␉0x10DE0914,␉"nVidia Quadro 2000 D" },␊
678+␉// 0DE0 - 0DEF␊
679+␉{ 0x10DE0DE1,␉0x38421430,␉"EVGA GeForce GT 430" },␊
680+␉{ 0x10DE0DE9,␉0x10250487,␉"Acer GeForce GT 630M" },␊
681+␉{ 0x10DE0DE9,␉0x10250488,␉"Acer GeForce GT 630M" },␊
682+␉{ 0x10DE0DE9,␉0x10250505,␉"Acer GeForce GT 630M" },␊
683+␉{ 0x10DE0DE9,␉0x10250507,␉"Acer GeForce GT 630M" },␊
684+␉{ 0x10DE0DE9,␉0x10250512,␉"Acer GeForce GT 630M" },␊
685+␉{ 0x10DE0DE9,␉0x10250573,␉"Acer GeForce GT 630M" },␊
686+␉{ 0x10DE0DE9,␉0x10250574,␉"Acer GeForce GT 630M" },␊
687+␉{ 0x10DE0DE9,␉0x10250575,␉"Acer GeForce GT 630M" },␊
688+␉{ 0x10DE0DE9,␉0x1028055E,␉"Dell GeForce GT 630M" },␊
689+␉{ 0x10DE0DE9,␉0x10280563,␉"Dell GeForce GT 630M" },␊
690+␉{ 0x10DE0DE9,␉0x103C181A,␉"HP GeForce GT 630M" },␊
691+␉{ 0x10DE0DE9,␉0x103C181B,␉"HP GeForce GT 630M" },␊
692+␉{ 0x10DE0DE9,␉0x103C181D,␉"HP GeForce GT 630M" },␊
693+␉{ 0x10DE0DE9,␉0x103C1837,␉"HP GeForce GT 630M" },␊
694+␉// 0DF0 - 0DFF␊
695+␉// 0E00 - 0E0F␊
696+␉// 0E10 - 0E1F␊
697+␉// 0E20 - 0E2F␊
698+␉{ 0x10DE0E22,␉0x1043835D,␉"Asus GeForce GTX 460" },␊
699+␉{ 0x10DE0E22,␉0x10B00401,␉"Gainward GeForce GTX 460" },␊
700+␉{ 0x10DE0E22,␉0x10B00801,␉"Gainward GeForce GTX 460" },␊
701+␉{ 0x10DE0E22,␉0x10DE0804,␉"nVidia GeForce GTX 460" },␊
702+␉{ 0x10DE0E22,␉0x10DE0865,␉"nVidia GeForce GTX 460" },␊
703+␉{ 0x10DE0E22,␉0x145834FA,␉"GigaByte GeForce GTX 460" },␊
704+␉{ 0x10DE0E22,␉0x145834FC,␉"GigaByte GeForce GTX 460" },␊
705+␉{ 0x10DE0E22,␉0x14583501,␉"GigaByte GeForce GTX 460" },␊
706+␉{ 0x10DE0E22,␉0x14622321,␉"MSi GeForce GTX 460" },␊
707+␉{ 0x10DE0E22,␉0x14622322,␉"MSi GeForce GTX 460" },␊
708+␉{ 0x10DE0E22,␉0x14622381,␉"MSi GeForce GTX 460" },␊
709+␉{ 0x10DE0E22,␉0x19DA1166,␉"Zotac GeForce GTX 460" },␊
710+␉{ 0x10DE0E22,␉0x19DA2166,␉"Zotac GeForce GTX 460" }, // Fabio71␊
711+␉{ 0x10DE0E22,␉0x38421370,␉"GeForce GTX 460" },␊
712+␉{ 0x10DE0E22,␉0x38421373,␉"GeForce GTX 460" },␊
713+␉{ 0x10DE0E23,␉0x10B00401,␉"Gainward GeForce GTX 460" },␊
714+␉// 0E30 - 0E3F␊
715+␉// 0E40 - 0E4F␊
716+␉// 0E50 - 0E5F␊
717+␉// 0E60 - 0E6F␊
718+␉// 0E70 - 0E7F␊
719+␉// 0E80 - 0E8F␊
720+␉// 0E90 - 0E9F␊
721+␉// 0EA0 - 0EAF␊
722+␉// 0EB0 - 0EBF␊
723+␉// 0EC0 - 0ECF␊
724+␉// 0ED0 - 0EDF␊
725+␉// 0EE0 - 0EEF␊
726+␉// 0EF0 - 0EFF␊
727+␉// 0F00 - 0F0F␊
728+␉// 0F10 - 0F1F␊
729+␉// 0F20 - 0F2F␊
730+␉// 0F30 - 0F3F␊
731+␉// 0F40 - 0F4F␊
732+␉// 0F50 - 0F5F␊
733+␉// 0F60 - 0F6F␊
734+␉// 0F70 - 0F7F␊
735+␉// 0F80 - 0F8F␊
736+␉// 0F90 - 0F9F␊
737+␉// 0FA0 - 0FAF␊
738+␉// 0FB0 - 0FBF␊
739+␉// 0FC0 - 0FCF␊
740+␉// 0FD0 - 0FDF␊
741+␉// 0FE0 - 0FEF␊
742+␉// 0FF0 - 0FFF␊
743+␉// 1000 - 100F␊
744+␉// 1010 - 101F␊
745+␉// 1020 - 102F␊
746+␉// 1030 - 103F␊
747+␉// 1040 - 104F␊
748+␉{ 0x10DE1040,␉0x104383A0,␉"Asus GeForce GT 520" },␊
749+␉{ 0x10DE1040,␉0x104383BD,␉"Asus GeForce GT 520" },␊
750+␉{ 0x10DE1040,␉0x104383C1,␉"Asus GeForce GT 520" },␊
751+␉{ 0x10DE1040,␉0x14622592,␉"MSi GeForce GT 520" },␊
752+␉{ 0x10DE1040,␉0x14622593,␉"MSi GeForce GT 520" },␊
753+␉{ 0x10DE1040,␉0x16423A98,␉"Bitland GeForce GT 520" },␊
754+␉{ 0x10DE1040,␉0x16423B42,␉"Bitland GeForce GT 520" },␊
755+␉{ 0x10DE1040,␉0x174B3214,␉"PC Partner GeForce GT 520" },␊
756+␉{ 0x10DE1040,␉0x196E0915,␉"PNY GeForce GT 520" },␊
757+␉{ 0x10DE1040,␉0x19DA1215,␉"Zotac GeForce GT 520" },␊
758+␉{ 0x10DE1040,␉0x19DA1222,␉"Zotac GeForce GT 520" }, // robertx␊
759+␉{ 0x10DE1040,␉0x1ACC5213,␉"Point of View GeForce GT 520" },␊
760+␉{ 0x10DE1040,␉0x1ACC5214,␉"Point of View GeForce GT 520" },␊
761+␉{ 0x10DE1040,␉0x1ACC522C,␉"Point of View GeForce GT 520" },␊
762+␉{ 0x10DE1040,␉0x1B0A90AA,␉"Pegatron GeForce GT 520" },␊
763+␉{ 0x10DE1054,␉0x10280511,␉"Dell GeForce 410M" },␊
764+␉{ 0x10DE1054,␉0x10CF1656,␉"Fujitsu GeForce 410M" },␊
765+␉{ 0x10DE1054,␉0x10CF1657,␉"Fujitsu GeForce 410M" },␊
766+␉{ 0x10DE1054,␉0x1179FCC0,␉"Toshiba GeForce 410M" },␊
767+␉{ 0x10DE1054,␉0x14581100,␉"GigaByte GeForce 410M" },␊
768+␉{ 0x10DE1054,␉0x14581125,␉"GigaByte GeForce 410M" },␊
769+␉{ 0x10DE1055,␉0x104D908A,␉"Sony GeForce 410M" },␊
770+␉{ 0x10DE1055,␉0x104D908B,␉"Sony GeForce 410M" }, // shulillo vedder␊
771+␉// 1060 - 106F␊
772+␉// 1070 - 107F␊
773+␉// 1080 - 108F␊
774+␉{ 0x10DE1081,␉0x10DE087E,␉"nVidia GeForce GTX 570" },␊
775+␉{ 0x10DE1086,␉0x10DE0871,␉"Inno3D GeForce GTX 570" },␊
776+␉{ 0x10DE1087,␉0x104383D6,␉"Asus ENGTX560Ti448 DCII" },␊
777+␉{ 0x10DE1087,␉0x19DA2207,␉"Zotac GeForce GTX 560 Ti-448" },␊
778+␉// 1090 - 109F␊
779+␉{ 0x10DE1091,␉0x10DE0887,␉"nVidia Tesla M2090" },␊
780+␉{ 0x10DE1091,␉0x10DE088E,␉"nVidia Tesla X2090" },␊
781+␉{ 0x10DE1091,␉0x10DE0891,␉"nVidia Tesla X2090" },␊
782+␉{ 0x10DE1094,␉0x10DE0888,␉"nVidia Tesla M2075" },␊
783+␉// 10A0 - 10AF␊
784+␉// 10B0 - 10BF␊
785+␉// 10C0 - 10CF␊
786+␉{ 0x10DE10C4,␉0x17AA3605,␉"Lenovo ION" },␊
787+␉// 10D0 - 10DF␊
788+␉// 10E0 - 10EF␊
789+␉// 10F0 - 10FF␊
790+␉// 1100 - 110F␊
791+␉// 1110 - 111F␊
792+␉// 1120 - 112F␊
793+␉// 1130 - 113F␊
794+␉// 1140 - 114F␊
795+␉// 1150 - 115F␊
796+␉// 1160 - 116F␊
797+␉// 1170 - 117F␊
798+␉// 1180 - 118F␊
799+␉{ 0x10DE1180,␉0x104383F0,␉"Asus GTX680-2GD5" },␊
800+␉{ 0x10DE1180,␉0x104383F7,␉"Asus GTX 680 Direct CU II" },␊
801+␉{ 0x10DE1180,␉0x10DE0969,␉"nVidia GTX 680" },␊
802+␉{ 0x10DE1180,␉0x118010B0,␉"Gainward GTX 680" },␊
803+␉{ 0x10DE1180,␉0x1458353C,␉"GV-N680OC-2GD WindForce GTX 680 OC" },␊
804+␉{ 0x10DE1180,␉0x15691180,␉"Palit GTX 680 JetStream" },␊
805+␉{ 0x10DE1180,␉0x19DA1255,␉"Zotac GTX 680" },␊
806+␉{ 0x10DE1180,␉0x38422680,␉"EVGA GTX 680" },␊
807+␉{ 0x10DE1180,␉0x38422682,␉"EVGA GTX 680 SC" },␊
808+␉{ 0x10DE1189,␉0x10438405,␉"Asus GTX 670 Direct CU II TOP" },␊
809+␉{ 0x10DE1180,␉0x10DE097A,␉"nVidia GTX 670" },␊
810+␉{ 0x10DE1180,␉0x15691189,␉"Palit GTX 670 JetStream" },␊
811+␉{ 0x10DE1180,␉0x19DA1255,␉"Zotac GTX 670" },␊
812+␉{ 0x10DE1189,␉0x38422672,␉"EVGA GTX 670" },␊
813+␉// 1190 - 119F␊
814+␉// 11A0 - 11AF␊
815+␉// 11B0 - 11BF␊
816+␉// 11C0 - 11CF␊
817+␉// 11D0 - 11DF␊
818+␉// 11E0 - 11EF␊
819+␉// 11F0 - 11FF␊
820+␉// 1200 - 120F␊
821+␉{ 0x10DE1210,␉0x10431487,␉"Asus GeForce GTX 570M" },␊
822+␉{ 0x10DE1210,␉0x10432104,␉"Asus GeForce GTX 570M" },␊
823+␉{ 0x10DE1210,␉0x146210BD,␉"MSi GeForce GTX 570M" },␊
824+␉{ 0x10DE1211,␉0x10280490,␉"Dell GeForce GTX 580M" },␊
825+␉{ 0x10DE1247,␉0x10431407,␉"Asus GeForce GT 555M" },␊
826+␉{ 0x10DE1247,␉0x10431752,␉"Asus GeForce GT 635M" },␊
827+␉{ 0x10DE1247,␉0x10432050,␉"Asus GeForce GT 555M" },␊
828+␉{ 0x10DE1247,␉0x10432051,␉"Asus GeForce GT 555M" },␊
829+␉{ 0x10DE1247,␉0x1043212A,␉"Asus GeForce GT 635M" },␊
830+␉{ 0x10DE1247,␉0x1043212B,␉"Asus GeForce GT 635M" },␊
831+␉{ 0x10DE1247,␉0x1043212C,␉"Asus GeForce GT 635M" },␊
832+␉{ 0x10DE1247,␉0x14581532,␉"GigaByte GeForce GT 555M" },␊
833+␉{ 0x10DE1247,␉0x14586744,␉"GigaByte GeForce GT 555M" },␊
834+␉{ 0x10DE1247,␉0x152D0930,␉"Quanta GeForce GT 635M" },␊
835+␉{ 0x10DE1251,␉0x102802A2,␉"Dell GeForce GTX 560M" },␊
836+␉{ 0x10DE1251,␉0x102802F8,␉"Dell GeForce GTX 560M" },␊
837+␉{ 0x10DE1251,␉0x1028048F,␉"Dell GeForce GTX 560M" },␊
838+␉{ 0x10DE1251,␉0x10280490,␉"Dell GeForce GTX 560M" },␊
839+␉{ 0x10DE1251,␉0x102804BA,␉"Dell GeForce GTX 560M" },␊
840+␉{ 0x10DE1251,␉0x104313B7,␉"Asus GeForce GTX 560M" },␊
841+␉{ 0x10DE1251,␉0x1043204A,␉"Asus GeForce GTX 560M" },␊
842+␉{ 0x10DE1251,␉0x1043204B,␉"Asus GeForce GTX 560M" },␊
843+␉{ 0x10DE1251,␉0x10432100,␉"Asus GeForce GTX 560M" },␊
844+␉{ 0x10DE1251,␉0x10432101,␉"Asus GeForce GTX 560M" },␊
845+␉{ 0x10DE1251,␉0x104384BA,␉"Asus GeForce GTX 560M" },␊
846+␉{ 0x10DE1251,␉0x1179FC00,␉"Toshiba GeForce GTX 560M" },␊
847+␉{ 0x10DE1251,␉0x1179FC01,␉"Toshiba GeForce GTX 560M" },␊
848+␉{ 0x10DE1251,␉0x1179FC05,␉"Toshiba GeForce GTX 560M" },␊
849+␉{ 0x10DE1251,␉0x146210A9,␉"MSi GeForce GTX 560M" },␊
850+␉{ 0x10DE1251,␉0x15585102,␉"Clevo/Kapok GeForce GTX 560M" },␊
851+␉{ 0x10DE1251,␉0x15587100,␉"Clevo/Kapok GeForce GTX 560M" },␊
852+␉{ 0x10DE1251,␉0x15587101,␉"Clevo/Kapok GeForce GTX 560M" },␊
853+␉{ 0x10DE1251,␉0x15587200,␉"Clevo/Kapok GeForce GTX 560M" },␊
854+␉{ 0x10DE1251,␉0x15588000,␉"Clevo/Kapok GeForce GTX 560M" },␊
855+␉// 1260 - 126F␊
856+␉// 1270 - 127F␊
857+␉// 1280 - 128F␊
858+␉// 1290 - 129F␊
859+␉// 12A0 - 12AF␊
860+␉// 12B0 - 12BF␊
861+␉// 12C0 - 12CF␊
862+␉// 12D0 - 12DF␊
863+␉// 12E0 - 12EF␊
864+␉// 12F0 - 12FF␊
865+ /* ------ Specific DeviceID and Generic SubDevID. ------ */␊
866+␉// 0000 - 0040␉␊
867 ␉// 0040 - 004F␉␊
868-␉{ 0x10DE0040, "GeForce 6800 Ultra" },␊
869-␉{ 0x10DE0041, "GeForce 6800" },␊
870-␉{ 0x10DE0042, "GeForce 6800 LE" },␊
871-␉{ 0x10DE0043, "GeForce 6800 XE" },␊
872-␉{ 0x10DE0044, "GeForce 6800 XT" },␊
873-␉{ 0x10DE0045, "GeForce 6800 GT" },␊
874-␉{ 0x10DE0046, "GeForce 6800 GT" },␊
875-␉{ 0x10DE0047, "GeForce 6800 GS" },␊
876-␉{ 0x10DE0048, "GeForce 6800 XT" },␊
877-␉{ 0x10DE004D, "Quadro FX 3400" },␊
878-␉{ 0x10DE004E, "Quadro FX 4000" },␊
879+␉{ 0x10DE0040,␉NV_SUB_IDS,␉"GeForce 6800 Ultra" },␊
880+␉{ 0x10DE0041,␉NV_SUB_IDS,␉"GeForce 6800" },␊
881+␉{ 0x10DE0042,␉NV_SUB_IDS,␉"GeForce 6800 LE" },␊
882+␉{ 0x10DE0043,␉NV_SUB_IDS,␉"GeForce 6800 XE" },␊
883+␉{ 0x10DE0044,␉NV_SUB_IDS,␉"GeForce 6800 XT" },␊
884+␉{ 0x10DE0045,␉NV_SUB_IDS,␉"GeForce 6800 GT" },␊
885+␉{ 0x10DE0046,␉NV_SUB_IDS,␉"GeForce 6800 GT" },␊
886+␉{ 0x10DE0047,␉NV_SUB_IDS,␉"GeForce 6800 GS" },␊
887+␉{ 0x10DE0048,␉NV_SUB_IDS,␉"GeForce 6800 XT" },␊
888+␉{ 0x10DE004D,␉NV_SUB_IDS,␉"Quadro FX 3400" },␊
889+␉{ 0x10DE004E,␉NV_SUB_IDS,␉"Quadro FX 4000" },␊
890 ␉// 0050 - 005F␊
891-␉// 0060 - 006F␉␊
892-␉// 0070 - 007F␉␊
893-␉// 0080 - 008F␉␊
894-␉// 0090 - 009F␉␊
895-␉{ 0x10DE0090, "GeForce 7800 GTX" },␊
896-␉{ 0x10DE0091, "GeForce 7800 GTX" },␊
897-␉{ 0x10DE0092, "GeForce 7800 GT" },␊
898-␉{ 0x10DE0093, "GeForce 7800 GS" },␊
899-␉{ 0x10DE0095, "GeForce 7800 SLI" },␊
900-␉{ 0x10DE0098, "GeForce Go 7800" },␊
901-␉{ 0x10DE0099, "GeForce Go 7800 GTX" },␊
902-␉{ 0x10DE009D, "Quadro FX 4500" },␊
903+␉// 0060 - 006F␊
904+␉// 0070 - 007F␊
905+␉// 0080 - 008F␊
906+␉// 0090 - 009F␊
907+␉{ 0x10DE0090,␉NV_SUB_IDS,␉"GeForce 7800 GTX" },␊
908+␉{ 0x10DE0091,␉NV_SUB_IDS,␉"GeForce 7800 GTX" },␊
909+␉{ 0x10DE0092,␉NV_SUB_IDS,␉"GeForce 7800 GT" },␊
910+␉{ 0x10DE0093,␉NV_SUB_IDS,␉"GeForce 7800 GS" },␊
911+␉{ 0x10DE0095,␉NV_SUB_IDS,␉"GeForce 7800 SLI" },␊
912+␉{ 0x10DE0098,␉NV_SUB_IDS,␉"GeForce Go 7800" },␊
913+␉{ 0x10DE0099,␉NV_SUB_IDS,␉"GeForce Go 7800 GTX" },␊
914+␉{ 0x10DE009D,␉NV_SUB_IDS,␉"Quadro FX 4500" },␊
915 ␉// 00A0 - 00AF␉␊
916 ␉// 00B0 - 00BF␉␊
917 ␉// 00C0 - 00CF␉␊
918-␉{ 0x10DE00C0, "GeForce 6800 GS" },␊
919-␉{ 0x10DE00C1, "GeForce 6800" },␊
920-␉{ 0x10DE00C2, "GeForce 6800 LE" },␊
921-␉{ 0x10DE00C3, "GeForce 6800 XT" },␊
922-␉{ 0x10DE00C8, "GeForce Go 6800" },␊
923-␉{ 0x10DE00C9, "GeForce Go 6800 Ultra" },␊
924-␉{ 0x10DE00CC, "Quadro FX Go1400" },␊
925-␉{ 0x10DE00CD, "Quadro FX 3450/4000 SDI" },␊
926-␉{ 0x10DE00CE, "Quadro FX 1400" },␊
927+␉{ 0x10DE00C0,␉NV_SUB_IDS,␉"GeForce 6800 GS" },␊
928+␉{ 0x10DE00C1,␉NV_SUB_IDS,␉"GeForce 6800" },␊
929+␉{ 0x10DE00C2,␉NV_SUB_IDS,␉"GeForce 6800 LE" },␊
930+␉{ 0x10DE00C3,␉NV_SUB_IDS,␉"GeForce 6800 XT" },␊
931+␉{ 0x10DE00C8,␉NV_SUB_IDS,␉"GeForce Go 6800" },␊
932+␉{ 0x10DE00C9,␉NV_SUB_IDS,␉"GeForce Go 6800 Ultra" },␊
933+␉{ 0x10DE00CC,␉NV_SUB_IDS,␉"Quadro FX Go1400" },␊
934+␉{ 0x10DE00CD,␉NV_SUB_IDS,␉"Quadro FX 3450/4000 SDI" },␊
935+␉{ 0x10DE00CE,␉NV_SUB_IDS,␉"Quadro FX 1400" },␊
936 ␉// 00D0 - 00DF␉␊
937 ␉// 00E0 - 00EF␉␊
938 ␉// 00F0 - 00FF␉␊
939-␉{ 0x10DE00F1, "GeForce 6600 GT" },␊
940-␉{ 0x10DE00F2, "GeForce 6600" },␊
941-␉{ 0x10DE00F3, "GeForce 6200" },␊
942-␉{ 0x10DE00F4, "GeForce 6600 LE" },␊
943-␉{ 0x10DE00F5, "GeForce 7800 GS" },␊
944-␉{ 0x10DE00F6, "GeForce 6800 GS/XT" },␊
945-␉{ 0x10DE00F8, "Quadro FX 3400/4400" },␊
946-␉{ 0x10DE00F9, "GeForce 6800 Series GPU" },␊
947+␉{ 0x10DE00F1,␉NV_SUB_IDS,␉"GeForce 6600 GT" },␊
948+␉{ 0x10DE00F2,␉NV_SUB_IDS,␉"GeForce 6600" },␊
949+␉{ 0x10DE00F3,␉NV_SUB_IDS,␉"GeForce 6200" },␊
950+␉{ 0x10DE00F4,␉NV_SUB_IDS,␉"GeForce 6600 LE" },␊
951+␉{ 0x10DE00F5,␉NV_SUB_IDS,␉"GeForce 7800 GS" },␊
952+␉{ 0x10DE00F6,␉NV_SUB_IDS,␉"GeForce 6800 GS/XT" },␊
953+␉{ 0x10DE00F8,␉NV_SUB_IDS,␉"Quadro FX 3400/4400" },␊
954+␉{ 0x10DE00F9,␉NV_SUB_IDS,␉"GeForce 6800 Series GPU" },␊
955 ␉// 0100 - 010F␉␊
956 ␉// 0110 - 011F␉␊
957 ␉// 0120 - 012F␉␊
958 ␉// 0130 - 013F␉␊
959 ␉// 0140 - 014F␉␊
960-␉{ 0x10DE0140, "GeForce 6600 GT" },␊
961-␉{ 0x10DE0141, "GeForce 6600" },␊
962-␉{ 0x10DE0142, "GeForce 6600 LE" },␊
963-␉{ 0x10DE0143, "GeForce 6600 VE" },␊
964-␉{ 0x10DE0144, "GeForce Go 6600" },␊
965-␉{ 0x10DE0145, "GeForce 6610 XL" },␊
966-␉{ 0x10DE0146, "GeForce Go 6600 TE/6200 TE" },␊
967-␉{ 0x10DE0147, "GeForce 6700 XL" },␊
968-␉{ 0x10DE0148, "GeForce Go 6600" },␊
969-␉{ 0x10DE0149, "GeForce Go 6600 GT" },␊
970-␉{ 0x10DE014A, "Quadro NVS 440" },␊
971-␉{ 0x10DE014C, "Quadro FX 550" },␊
972-␉{ 0x10DE014D, "Quadro FX 550" },␊
973-␉{ 0x10DE014E, "Quadro FX 540" },␊
974-␉{ 0x10DE014F, "GeForce 6200" },␊
975+␉{ 0x10DE0140,␉NV_SUB_IDS,␉"GeForce 6600 GT" },␊
976+␉{ 0x10DE0141,␉NV_SUB_IDS,␉"GeForce 6600" },␊
977+␉{ 0x10DE0142,␉NV_SUB_IDS,␉"GeForce 6600 LE" },␊
978+␉{ 0x10DE0143,␉NV_SUB_IDS,␉"GeForce 6600 VE" },␊
979+␉{ 0x10DE0144,␉NV_SUB_IDS,␉"GeForce Go 6600" },␊
980+␉{ 0x10DE0145,␉NV_SUB_IDS,␉"GeForce 6610 XL" },␊
981+␉{ 0x10DE0146,␉NV_SUB_IDS,␉"GeForce Go 6600 TE/6200 TE" },␊
982+␉{ 0x10DE0147,␉NV_SUB_IDS,␉"GeForce 6700 XL" },␊
983+␉{ 0x10DE0148,␉NV_SUB_IDS,␉"GeForce Go 6600" },␊
984+␉{ 0x10DE0149,␉NV_SUB_IDS,␉"GeForce Go 6600 GT" },␊
985+␉{ 0x10DE014A,␉NV_SUB_IDS,␉"Quadro NVS 440" },␊
986+␉{ 0x10DE014C,␉NV_SUB_IDS,␉"Quadro FX 550" },␊
987+␉{ 0x10DE014D,␉NV_SUB_IDS,␉"Quadro FX 550" },␊
988+␉{ 0x10DE014E,␉NV_SUB_IDS,␉"Quadro FX 540" },␊
989+␉{ 0x10DE014F,␉NV_SUB_IDS,␉"GeForce 6200" },␊
990 ␉// 0150 - 015F␉␊
991 ␉// 0160 - 016F␉␊
992-␉{ 0x10DE0160, "GeForce 6500" },␊
993-␉{ 0x10DE0161, "GeForce 6200 TurboCache(TM)" },␊
994-␉{ 0x10DE0162, "GeForce 6200SE TurboCache(TM)" },␊
995-␉{ 0x10DE0163, "GeForce 6200 LE" },␊
996-␉{ 0x10DE0164, "GeForce Go 6200" },␊
997-␉{ 0x10DE0165, "Quadro NVS 285" },␊
998-␉{ 0x10DE0166, "GeForce Go 6400" },␊
999-␉{ 0x10DE0167, "GeForce Go 6200" },␊
1000-␉{ 0x10DE0168, "GeForce Go 6400" },␊
1001-␉{ 0x10DE0169, "GeForce 6250" },␊
1002-␉{ 0x10DE016A, "GeForce 7100 GS" },␊
1003+␉{ 0x10DE0160,␉NV_SUB_IDS,␉"GeForce 6500" },␊
1004+␉{ 0x10DE0161,␉NV_SUB_IDS,␉"GeForce 6200 TurboCache(TM)" },␊
1005+␉{ 0x10DE0162,␉NV_SUB_IDS,␉"GeForce 6200SE TurboCache(TM)" },␊
1006+␉{ 0x10DE0163,␉NV_SUB_IDS,␉"GeForce 6200 LE" },␊
1007+␉{ 0x10DE0164,␉NV_SUB_IDS,␉"GeForce Go 6200" },␊
1008+␉{ 0x10DE0165,␉NV_SUB_IDS,␉"Quadro NVS 285" },␊
1009+␉{ 0x10DE0166,␉NV_SUB_IDS,␉"GeForce Go 6400" },␊
1010+␉{ 0x10DE0167,␉NV_SUB_IDS,␉"GeForce Go 6200" },␊
1011+␉{ 0x10DE0168,␉NV_SUB_IDS,␉"GeForce Go 6400" },␊
1012+␉{ 0x10DE0169,␉NV_SUB_IDS,␉"GeForce 6250" },␊
1013+␉{ 0x10DE016A,␉NV_SUB_IDS,␉"GeForce 7100 GS" },␊
1014+␉{ 0x10DE016C,␉NV_SUB_IDS,␉"NVIDIA NV44GLM" },␊
1015+␉{ 0x10DE016D,␉NV_SUB_IDS,␉"NVIDIA NV44GLM" },␊
1016 ␉// 0170 - 017F␉␊
1017 ␉// 0180 - 018F␉␊
1018 ␉// 0190 - 019F␉␉␊
1019-␉{ 0x10DE0191, "GeForce 8800 GTX" },␊
1020-␉{ 0x10DE0193, "GeForce 8800 GTS" },␊
1021-␉{ 0x10DE0194, "GeForce 8800 Ultra" },␊
1022-␉{ 0x10DE0197, "Tesla C870" },␊
1023-␉{ 0x10DE019D, "Quadro FX 5600" },␊
1024-␉{ 0x10DE019E, "Quadro FX 4600" },␊
1025-␉// 01A0 - 01AF␉␊
1026-␉// 01B0 - 01BF␉␊
1027-␉// 01C0 - 01CF␉␊
1028-␉// 01D0 - 01DF␉␉␊
1029-␉{ 0x10DE01D0, "GeForce 7350 LE" },␊
1030-␉{ 0x10DE01D1, "GeForce 7300 LE" },␊
1031-␉{ 0x10DE01D2, "GeForce 7550 LE" },␊
1032-␉{ 0x10DE01D3, "GeForce 7300 SE/7200 GS" },␊
1033-␉{ 0x10DE01D6, "GeForce Go 7200" },␊
1034-␉{ 0x10DE01D7, "GeForce Go 7300" },␊
1035-␉{ 0x10DE01D8, "GeForce Go 7400" },␊
1036-␉{ 0x10DE01D9, "GeForce Go 7400 GS" },␊
1037-␉{ 0x10DE01DA, "Quadro NVS 110M" },␊
1038-␉{ 0x10DE01DB, "Quadro NVS 120M" },␊
1039-␉{ 0x10DE01DC, "Quadro FX 350M" },␊
1040-␉{ 0x10DE01DD, "GeForce 7500 LE" },␊
1041-␉{ 0x10DE01DE, "Quadro FX 350" },␊
1042-␉{ 0x10DE01DF, "GeForce 7300 GS" },␊
1043+␉{ 0x10DE0191,␉NV_SUB_IDS,␉"GeForce 8800 GTX" },␊
1044+␉{ 0x10DE0193,␉NV_SUB_IDS,␉"GeForce 8800 GTS" },␊
1045+␉{ 0x10DE0194,␉NV_SUB_IDS,␉"GeForce 8800 Ultra" },␊
1046+␉{ 0x10DE0197,␉NV_SUB_IDS,␉"Tesla C870" },␊
1047+␉{ 0x10DE019D,␉NV_SUB_IDS,␉"Quadro FX 5600" },␊
1048+␉{ 0x10DE019E,␉NV_SUB_IDS,␉"Quadro FX 4600" },␊
1049+␉// 01A0 - 01AF␊
1050+␉// 01B0 - 01BF␊
1051+␉// 01C0 - 01CF␊
1052+␉// 01D0 - 01DF␊
1053+␉{ 0x10DE01D0,␉NV_SUB_IDS,␉"GeForce 7350 LE" },␊
1054+␉{ 0x10DE01D1,␉NV_SUB_IDS,␉"GeForce 7300 LE" },␊
1055+␉{ 0x10DE01D2,␉NV_SUB_IDS,␉"GeForce 7550 LE" },␊
1056+␉{ 0x10DE01D3,␉NV_SUB_IDS,␉"GeForce 7300 SE/7200 GS" },␊
1057+␉{ 0x10DE01D6,␉NV_SUB_IDS,␉"GeForce Go 7200" },␊
1058+␉{ 0x10DE01D7,␉NV_SUB_IDS,␉"Quadro NVS 110M / GeForce Go 7300" }, // 71 SubID␊
1059+␉{ 0x10DE01D8,␉NV_SUB_IDS,␉"GeForce Go 7400" },␊
1060+␉{ 0x10DE01D9,␉NV_SUB_IDS,␉"GeForce Go 7450" },␊
1061+␉{ 0x10DE01DA,␉NV_SUB_IDS,␉"Quadro NVS 110M" },␊
1062+␉{ 0x10DE01DB,␉NV_SUB_IDS,␉"Quadro NVS 120M" },␊
1063+␉{ 0x10DE01DC,␉NV_SUB_IDS,␉"Quadro FX 350M" },␊
1064+␉{ 0x10DE01DD,␉NV_SUB_IDS,␉"GeForce 7500 LE" },␊
1065+␉{ 0x10DE01DE,␉NV_SUB_IDS,␉"Quadro FX 350" },␊
1066+␉{ 0x10DE01DF,␉NV_SUB_IDS,␉"GeForce 7300 GS" },␊
1067 ␉// 01E0 - 01EF␉␊
1068 ␉// 01F0 - 01FF␊
1069- { 0x10DE01F0,␉"GeForce4 MX" },␊
1070+␉{ 0x10DE01F0,␉NV_SUB_IDS,␉"GeForce4 MX" },␊
1071 ␉// 0200 - 020F␉␊
1072 ␉// 0210 - 021F␉␊
1073-␉{ 0x10DE0211, "GeForce 6800" },␊
1074-␉{ 0x10DE0212, "GeForce 6800 LE" },␊
1075-␉{ 0x10DE0215, "GeForce 6800 GT" },␊
1076-␉{ 0x10DE0218, "GeForce 6800 XT" },␊
1077-␉// 0220 - 022F␉␊
1078-␉{ 0x10DE0221, "GeForce 6200" },␊
1079-␉{ 0x10DE0222, "GeForce 6200 A-LE" },␊
1080- { 0x10DE0228,␉"NVIDIA NV44M" },␊
1081-␉// 0230 - 023F␉␊
1082-␉// 0240 - 024F␉␊
1083-␉{ 0x10DE0240, "GeForce 6150" },␊
1084-␉{ 0x10DE0241, "GeForce 6150 LE" },␊
1085-␉{ 0x10DE0242, "GeForce 6100" },␊
1086- ␉{ 0x10DE0243,␉"NVIDIA C51" },␊
1087-␉{ 0x10DE0244, "GeForce Go 6150" },␊
1088-␉{ 0x10DE0245, "Quadro NVS 210S / GeForce 6150LE" },␊
1089-␉{ 0x10DE0247, "GeForce Go 6100" },␊
1090-␉// 0250 - 025F␉␊
1091-␉// 0260 - 026F␉␊
1092-␉// 0270 - 027F␉␊
1093-␉// 0280 - 028F␉␉␊
1094-␉// 0290 - 029F␉␊
1095-␉{ 0x10DE0290, "GeForce 7900 GTX" },␊
1096-␉{ 0x10DE0291, "GeForce 7900 GT/GTO" },␊
1097-␉{ 0x10DE0292, "GeForce 7900 GS" },␊
1098-␉{ 0x10DE0293, "GeForce 7950 GX2" },␊
1099-␉{ 0x10DE0294, "GeForce 7950 GX2" },␊
1100-␉{ 0x10DE0295, "GeForce 7950 GT" },␊
1101-␉{ 0x10DE0298, "GeForce Go 7900 GS" },␊
1102-␉{ 0x10DE0299, "GeForce Go 7900 GTX" },␊
1103-␉{ 0x10DE029A, "Quadro FX 2500M" },␊
1104-␉{ 0x10DE029B, "Quadro FX 1500M" },␊
1105-␉{ 0x10DE029C, "Quadro FX 5500" },␊
1106-␉{ 0x10DE029D, "Quadro FX 3500" },␊
1107-␉{ 0x10DE029E, "Quadro FX 1500" },␊
1108-␉{ 0x10DE029F, "Quadro FX 4500 X2" },␊
1109-␉// 02A0 - 02AF␉␊
1110-␉// 02B0 - 02BF␉␊
1111-␉// 02C0 - 02CF␉␊
1112-␉// 02D0 - 02DF␉␉␊
1113-␉// 02E0 - 02EF␉␉␊
1114-␉{ 0x10DE02E0, "GeForce 7600 GT" },␊
1115-␉{ 0x10DE02E1, "GeForce 7600 GS" },␊
1116-␉{ 0x10DE02E2, "GeForce 7300 GT" },␊
1117-␉{ 0x10DE02E3, "GeForce 7900 GS" },␊
1118-␉{ 0x10DE02E4, "GeForce 7950 GT" },␊
1119-␉// 02F0 - 02FF␉␉␊
1120-␉// 0300 - 030F␉␉␊
1121-␉{ 0x10DE0301, "GeForce FX 5800 Ultra" },␊
1122-␉{ 0x10DE0302, "GeForce FX 5800" },␊
1123-␉{ 0x10DE0308, "Quadro FX 2000" },␊
1124-␉{ 0x10DE0309, "Quadro FX 1000" },␊
1125-␉// 0310 - 031F␉␉␊
1126-␉{ 0x10DE0311, "GeForce FX 5600 Ultra" },␊
1127-␉{ 0x10DE0312, "GeForce FX 5600" },␊
1128-␉{ 0x10DE0314, "GeForce FX 5600XT" },␊
1129-␉{ 0x10DE031A, "GeForce FX Go5600" },␊
1130-␉{ 0x10DE031B, "GeForce FX Go5650" },␊
1131-␉{ 0x10DE031C, "Quadro FX Go700" },␊
1132+␉{ 0x10DE0211,␉NV_SUB_IDS,␉"GeForce 6800" },␊
1133+␉{ 0x10DE0212,␉NV_SUB_IDS,␉"GeForce 6800 LE" },␊
1134+␉{ 0x10DE0215,␉NV_SUB_IDS,␉"GeForce 6800 GT" },␊
1135+␉{ 0x10DE0218,␉NV_SUB_IDS,␉"GeForce 6800 XT" },␊
1136+␉// 0220 - 022F␊
1137+␉{ 0x10DE0221,␉NV_SUB_IDS,␉"GeForce 6200" },␊
1138+␉{ 0x10DE0222,␉NV_SUB_IDS,␉"GeForce 6200 A-LE" },␊
1139+␉{ 0x10DE0228,␉NV_SUB_IDS,␉"NVIDIA NV44M" },␊
1140+␉// 0230 - 023F␊
1141+␉// 0240 - 024F␊
1142+␉{ 0x10DE0240,␉NV_SUB_IDS,␉"GeForce 6150" },␊
1143+␉{ 0x10DE0241,␉NV_SUB_IDS,␉"GeForce 6150 LE" },␊
1144+␉{ 0x10DE0242,␉NV_SUB_IDS,␉"GeForce 6100" },␊
1145+␉{ 0x10DE0243,␉NV_SUB_IDS,␉"NVIDIA C51" },␊
1146+␉{ 0x10DE0244,␉NV_SUB_IDS,␉"GeForce Go 6150" },␊
1147+␉{ 0x10DE0245,␉NV_SUB_IDS,␉"Quadro NVS 210S / GeForce 6150LE" },␊
1148+␉{ 0x10DE0247,␉NV_SUB_IDS,␉"GeForce Go 6100" },␊
1149+␉// 0250 - 025F␊
1150+␉{ 0x10DE025B,␉NV_SUB_IDS,␉"Quadro4 700 XGL" },␊
1151+␉// 0260 - 026F␊
1152+␉// 0270 - 027F␊
1153+␉// 0280 - 028F␊
1154+␉// 0290 - 029F␊
1155+␉{ 0x10DE0290,␉NV_SUB_IDS,␉"GeForce 7900 GTX" },␊
1156+␉{ 0x10DE0291,␉NV_SUB_IDS,␉"GeForce 7900 GT/GTO" },␊
1157+␉{ 0x10DE0292,␉NV_SUB_IDS,␉"GeForce 7900 GS" },␊
1158+␉{ 0x10DE0293,␉NV_SUB_IDS,␉"GeForce 7950 GX2" },␊
1159+␉{ 0x10DE0294,␉NV_SUB_IDS,␉"GeForce 7950 GX2" },␊
1160+␉{ 0x10DE0295,␉NV_SUB_IDS,␉"GeForce 7950 GT" },␊
1161+␉{ 0x10DE0298,␉NV_SUB_IDS,␉"GeForce Go 7900 GS" },␊
1162+␉{ 0x10DE0299,␉NV_SUB_IDS,␉"GeForce Go 7900 GTX" },␊
1163+␉{ 0x10DE029A,␉NV_SUB_IDS,␉"Quadro FX 2500M" },␊
1164+␉{ 0x10DE029B,␉NV_SUB_IDS,␉"Quadro FX 1500M" },␊
1165+␉{ 0x10DE029C,␉NV_SUB_IDS,␉"Quadro FX 5500" },␊
1166+␉{ 0x10DE029D,␉NV_SUB_IDS,␉"Quadro FX 3500" },␊
1167+␉{ 0x10DE029E,␉NV_SUB_IDS,␉"Quadro FX 1500" },␊
1168+␉{ 0x10DE029F,␉NV_SUB_IDS,␉"Quadro FX 4500 X2" },␊
1169+␉// 02A0 - 02AF␊
1170+␉// 02B0 - 02BF␊
1171+␉// 02C0 - 02CF␊
1172+␉// 02D0 - 02DF␊
1173+␉// 02E0 - 02EF␊
1174+␉{ 0x10DE02E0,␉NV_SUB_IDS,␉"GeForce 7600 GT" },␊
1175+␉{ 0x10DE02E1,␉NV_SUB_IDS,␉"GeForce 7600 GS" },␊
1176+␉{ 0x10DE02E2,␉NV_SUB_IDS,␉"GeForce 7300 GT" },␊
1177+␉{ 0x10DE02E3,␉NV_SUB_IDS,␉"GeForce 7900 GS" },␊
1178+␉{ 0x10DE02E4,␉NV_SUB_IDS,␉"GeForce 7950 GT" },␊
1179+␉// 02F0 - 02FF␊
1180+␉// 0300 - 030F␊
1181+␉{ 0x10DE0301,␉NV_SUB_IDS,␉"GeForce FX 5800 Ultra" },␊
1182+␉{ 0x10DE0302,␉NV_SUB_IDS,␉"GeForce FX 5800" },␊
1183+␉{ 0x10DE0308,␉NV_SUB_IDS,␉"Quadro FX 2000" },␊
1184+␉{ 0x10DE0309,␉NV_SUB_IDS,␉"Quadro FX 1000" },␊
1185+␉// 0310 - 031F␊
1186+␉{ 0x10DE0311,␉NV_SUB_IDS,␉"GeForce FX 5600 Ultra" },␊
1187+␉{ 0x10DE0312,␉NV_SUB_IDS,␉"GeForce FX 5600" },␊
1188+␉{ 0x10DE0314,␉NV_SUB_IDS,␉"GeForce FX 5600XT" },␊
1189+␉{ 0x10DE031A,␉NV_SUB_IDS,␉"GeForce FX Go5600" },␊
1190+␉{ 0x10DE031B,␉NV_SUB_IDS,␉"GeForce FX Go5650" },␊
1191+␉{ 0x10DE031C,␉NV_SUB_IDS,␉"Quadro FX Go700" },␊
1192 ␉// 0320 - 032F␊
1193- { 0x10DE0320, "GeForce FX 5200" },␊
1194-␉{ 0x10DE0321, "GeForce FX 5200 Ultra" },␊
1195-␉{ 0x10DE0322, "GeForce FX 5200" },␊
1196-␉{ 0x10DE0323, "GeForce FX 5200 LE" },␊
1197-␉{ 0x10DE0324, "GeForce FX Go5200" },␊
1198-␉{ 0x10DE0325, "GeForce FX Go5250" },␊
1199-␉{ 0x10DE0326, "GeForce FX 5500" },␊
1200-␉{ 0x10DE0328, "GeForce FX Go5200 32M/64M" },␊
1201- ␉{ 0x10DE0329, "GeForce FX Go5200" },␊
1202-␉{ 0x10DE032A, "Quadro NVS 55/280 PCI" },␊
1203-␉{ 0x10DE032B, "Quadro FX 500/600 PCI" },␊
1204-␉{ 0x10DE032C, "GeForce FX Go53xx Series" },␊
1205-␉{ 0x10DE032D, "GeForce FX Go5100" },␊
1206+␉{ 0x10DE0320,␉NV_SUB_IDS,␉"GeForce FX 5200" },␊
1207+␉{ 0x10DE0321,␉NV_SUB_IDS,␉"GeForce FX 5200 Ultra" },␊
1208+␉{ 0x10DE0322,␉NV_SUB_IDS,␉"GeForce FX 5200" },␊
1209+␉{ 0x10DE0323,␉NV_SUB_IDS,␉"GeForce FX 5200 LE" },␊
1210+␉{ 0x10DE0324,␉NV_SUB_IDS,␉"GeForce FX Go5200" },␊
1211+␉{ 0x10DE0325,␉NV_SUB_IDS,␉"GeForce FX Go5250" },␊
1212+␉{ 0x10DE0326,␉NV_SUB_IDS,␉"GeForce FX 5500" },␊
1213+␉{ 0x10DE0328,␉NV_SUB_IDS,␉"GeForce FX Go5200 32M/64M" },␊
1214+␉{ 0x10DE0329,␉NV_SUB_IDS,␉"GeForce FX Go5200" },␊
1215+␉{ 0x10DE032A,␉NV_SUB_IDS,␉"Quadro NVS 55/280 PCI" },␊
1216+␉{ 0x10DE032B,␉NV_SUB_IDS,␉"Quadro FX 500/600 PCI" },␊
1217+␉{ 0x10DE032C,␉NV_SUB_IDS,␉"GeForce FX Go53xx Series" },␊
1218+␉{ 0x10DE032D,␉NV_SUB_IDS,␉"GeForce FX Go5100" },␊
1219+␉// { 0x10DE032F,␉NV_SUB_IDS,␉"NVIDIA NV34GL" },␊
1220 ␉// 0330 - 033F␊
1221-␉{ 0x10DE0330, "GeForce FX 5900 Ultra" },␊
1222-␉{ 0x10DE0331, "GeForce FX 5900" },␊
1223-␉{ 0x10DE0332, "GeForce FX 5900XT" },␊
1224-␉{ 0x10DE0333, "GeForce FX 5950 Ultra" },␊
1225-␉{ 0x10DE0334, "GeForce FX 5900ZT" },␊
1226-␉{ 0x10DE0338, "Quadro FX 3000" },␊
1227-␉{ 0x10DE033F, "Quadro FX 700" },␊
1228+␉{ 0x10DE0330,␉NV_SUB_IDS,␉"GeForce FX 5900 Ultra" },␊
1229+␉{ 0x10DE0331,␉NV_SUB_IDS,␉"GeForce FX 5900" },␊
1230+␉{ 0x10DE0332,␉NV_SUB_IDS,␉"GeForce FX 5900XT" },␊
1231+␉{ 0x10DE0333,␉NV_SUB_IDS,␉"GeForce FX 5950 Ultra" },␊
1232+␉{ 0x10DE0334,␉NV_SUB_IDS,␉"GeForce FX 5900ZT" },␊
1233+␉{ 0x10DE0338,␉NV_SUB_IDS,␉"Quadro FX 3000" },␊
1234+␉{ 0x10DE033F,␉NV_SUB_IDS,␉"Quadro FX 700" },␊
1235 ␉// 0340 - 034F␊
1236-␉{ 0x10DE0341, "GeForce FX 5700 Ultra" },␊
1237-␉{ 0x10DE0342, "GeForce FX 5700" },␊
1238-␉{ 0x10DE0343, "GeForce FX 5700LE" },␊
1239-␉{ 0x10DE0344, "GeForce FX 5700VE" },␊
1240-␉{ 0x10DE0347, "GeForce FX Go5700" },␊
1241-␉{ 0x10DE0348, "GeForce FX Go5700" },␊
1242-␉{ 0x10DE034C, "Quadro FX Go1000" },␊
1243-␉{ 0x10DE034E, "Quadro FX 1100" },␊
1244-␉// 0350 - 035F␉␊
1245-␉// 0360 - 036F␉␊
1246-␉// 0370 - 037F␉␊
1247-␉// 0380 - 038F␉␉␉␊
1248-␉{ 0x10DE038B, "GeForce 7650 GS" },␊
1249+␉{ 0x10DE0341,␉NV_SUB_IDS,␉"GeForce FX 5700 Ultra" },␊
1250+␉{ 0x10DE0342,␉NV_SUB_IDS,␉"GeForce FX 5700" },␊
1251+␉{ 0x10DE0343,␉NV_SUB_IDS,␉"GeForce FX 5700LE" },␊
1252+␉{ 0x10DE0344,␉NV_SUB_IDS,␉"GeForce FX 5700VE" },␊
1253+␉// { 0x10DE0345,␉NV_SUB_IDS,␉"NVIDIA NV36.5" },␊
1254+␉{ 0x10DE0347,␉NV_SUB_IDS,␉"GeForce FX Go5700" },␊
1255+␉{ 0x10DE0348,␉NV_SUB_IDS,␉"GeForce FX Go5700" },␊
1256+␉// { 0x10DE0349,␉NV_SUB_IDS,␉"NVIDIA NV36M Pro" },␊
1257+␉// { 0x10DE034B,␉NV_SUB_IDS,␉"NVIDIA NV36MAP" },␊
1258+␉{ 0x10DE034C,␉NV_SUB_IDS,␉"Quadro FX Go1000" },␊
1259+␉{ 0x10DE034E,␉NV_SUB_IDS,␉"Quadro FX 1100" },␊
1260+␉// { 0x10DE034F,␉NV_SUB_IDS,␉"NVIDIA NV36GL" },␊
1261+␉// 0350 - 035F␊
1262+␉// 0360 - 036F␊
1263+␉// 0370 - 037F␊
1264+␉// 0380 - 038F␊
1265+␉{ 0x10DE038B,␉NV_SUB_IDS,␉"GeForce 7650 GS" },␊
1266 ␉// 0390 - 039F␊
1267-␉{ 0x10DE0390, "GeForce 7650 GS" },␊
1268-␉{ 0x10DE0391, "GeForce 7600 GT" },␊
1269-␉{ 0x10DE0392, "GeForce 7600 GS" },␊
1270-␉{ 0x10DE0393, "GeForce 7300 GT" },␊
1271-␉{ 0x10DE0394, "GeForce 7600 LE" },␊
1272-␉{ 0x10DE0395, "GeForce 7300 GT" },␊
1273-␉{ 0x10DE0397, "GeForce Go 7700" },␊
1274-␉{ 0x10DE0398, "GeForce Go 7600" },␊
1275-␉{ 0x10DE0399, "GeForce Go 7600 GT"},␊
1276-␉{ 0x10DE039A, "Quadro NVS 300M" },␊
1277-␉{ 0x10DE039B, "GeForce Go 7900 SE" },␊
1278-␉{ 0x10DE039C, "Quadro FX 550M" },␊
1279-␉{ 0x10DE039E, "Quadro FX 560" },␊
1280-␉// 03A0 - 03AF␉␊
1281-␉// 03B0 - 03BF␉␊
1282-␉// 03C0 - 03CF␉␊
1283-␉// 03D0 - 03DF␉␉␉␊
1284-␉{ 0x10DE03D0, "GeForce 6150SE nForce 430" },␊
1285-␉{ 0x10DE03D1, "GeForce 6100 nForce 405" },␊
1286-␉{ 0x10DE03D2, "GeForce 6100 nForce 400" },␊
1287-␉{ 0x10DE03D5, "GeForce 6100 nForce 420" },␊
1288-␉{ 0x10DE03D6, "GeForce 7025 / nForce 630a" },␊
1289+␉{ 0x10DE0390,␉NV_SUB_IDS,␉"GeForce 7650 GS" },␊
1290+␉{ 0x10DE0391,␉NV_SUB_IDS,␉"GeForce 7600 GT" },␊
1291+␉{ 0x10DE0392,␉NV_SUB_IDS,␉"GeForce 7600 GS" },␊
1292+␉{ 0x10DE0393,␉NV_SUB_IDS,␉"GeForce 7300 GT" },␊
1293+␉{ 0x10DE0394,␉NV_SUB_IDS,␉"GeForce 7600 LE" },␊
1294+␉{ 0x10DE0395,␉NV_SUB_IDS,␉"GeForce 7300 GT" },␊
1295+␉{ 0x10DE0397,␉NV_SUB_IDS,␉"GeForce Go 7700" },␊
1296+␉{ 0x10DE0398,␉NV_SUB_IDS,␉"GeForce Go 7600" },␊
1297+␉{ 0x10DE0399,␉NV_SUB_IDS,␉"GeForce Go 7600 GT"},␊
1298+␉{ 0x10DE039A,␉NV_SUB_IDS,␉"Quadro NVS 300M" },␊
1299+␉{ 0x10DE039B,␉NV_SUB_IDS,␉"GeForce Go 7900 SE" },␊
1300+␉{ 0x10DE039C,␉NV_SUB_IDS,␉"Quadro FX 560M" },␊
1301+␉{ 0x10DE039E,␉NV_SUB_IDS,␉"Quadro FX 560" },␊
1302+␉// 03A0 - 03AF␊
1303+␉// 03B0 - 03BF␊
1304+␉// 03C0 - 03CF␊
1305+␉// 03D0 - 03DF␊
1306+␉{ 0x10DE03D0,␉NV_SUB_IDS,␉"GeForce 6150SE nForce 430" },␊
1307+␉{ 0x10DE03D1,␉NV_SUB_IDS,␉"GeForce 6100 nForce 405" },␊
1308+␉{ 0x10DE03D2,␉NV_SUB_IDS,␉"GeForce 6100 nForce 400" },␊
1309+␉{ 0x10DE03D5,␉NV_SUB_IDS,␉"GeForce 6100 nForce 420" },␊
1310+␉{ 0x10DE03D6,␉NV_SUB_IDS,␉"GeForce 7025 / nForce 630a" },␊
1311 ␉// 03E0 - 03EF␊
1312 ␉// 03F0 - 03FF␊
1313-␉// 0400 - 040F␉␉␊
1314-␉{ 0x10DE0400, "GeForce 8600 GTS" },␊
1315-␉{ 0x10DE0401, "GeForce 8600 GT" },␊
1316-␉{ 0x10DE0402, "GeForce 8600 GT" },␊
1317-␉{ 0x10DE0403, "GeForce 8600 GS" },␊
1318-␉{ 0x10DE0404, "GeForce 8400 GS" },␊
1319-␉{ 0x10DE0405, "GeForce 9500M GS" },␊
1320-␉{ 0x10DE0406, "GeForce 8300 GS" },␊
1321-␉{ 0x10DE0407, "GeForce 8600M GT" },␊
1322-␉{ 0x10DE0408, "GeForce 9650M GS" },␊
1323-␉{ 0x10DE0409, "GeForce 8700M GT" },␊
1324-␉{ 0x10DE040A, "Quadro FX 370" },␊
1325-␉{ 0x10DE040B, "Quadro NVS 320M" },␊
1326-␉{ 0x10DE040C, "Quadro FX 570M" },␊
1327-␉{ 0x10DE040D, "Quadro FX 1600M" },␊
1328-␉{ 0x10DE040E, "Quadro FX 570" },␊
1329-␉{ 0x10DE040F, "Quadro FX 1700" },␊
1330-␉// 0410 - 041F␉␊
1331-␉{ 0x10DE0410, "GeForce GT 330" },␊
1332-␉// 0420 - 042F␉␊
1333-␉{ 0x10DE0420, "GeForce 8400 SE" },␊
1334-␉{ 0x10DE0421, "GeForce 8500 GT" },␊
1335-␉{ 0x10DE0422, "GeForce 8400 GS" },␊
1336-␉{ 0x10DE0423, "GeForce 8300 GS" },␊
1337-␉{ 0x10DE0424, "GeForce 8400 GS" },␊
1338-␉{ 0x10DE0425, "GeForce 8600M GS" },␊
1339-␉{ 0x10DE0426, "GeForce 8400M GT" },␊
1340-␉{ 0x10DE0427, "GeForce 8400M GS" },␊
1341-␉{ 0x10DE0428, "GeForce 8400M G" },␊
1342-␉{ 0x10DE0429, "Quadro NVS 140M" },␊
1343-␉{ 0x10DE042A, "Quadro NVS 130M" },␊
1344-␉{ 0x10DE042B, "Quadro NVS 135M" },␊
1345-␉{ 0x10DE042C, "GeForce 9400 GT" },␊
1346-␉{ 0x10DE042D, "Quadro FX 360M" },␊
1347-␉{ 0x10DE042E, "GeForce 9300M G" },␊
1348-␉{ 0x10DE042F, "Quadro NVS 290" },␊
1349+␉// 0400 - 040F␊
1350+␉{ 0x10DE0400,␉NV_SUB_IDS,␉"GeForce 8600 GTS" },␊
1351+␉{ 0x10DE0401,␉NV_SUB_IDS,␉"GeForce 8600 GT" },␊
1352+␉{ 0x10DE0402,␉NV_SUB_IDS,␉"GeForce 8600 GT" },␊
1353+␉{ 0x10DE0403,␉NV_SUB_IDS,␉"GeForce 8600 GS" },␊
1354+␉{ 0x10DE0404,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
1355+␉{ 0x10DE0405,␉NV_SUB_IDS,␉"GeForce 9500M GS" },␊
1356+␉{ 0x10DE0406,␉NV_SUB_IDS,␉"GeForce 8300 GS" },␊
1357+␉{ 0x10DE0407,␉NV_SUB_IDS,␉"GeForce 8600M GT" },␊
1358+␉{ 0x10DE0408,␉NV_SUB_IDS,␉"GeForce 9650M GS" },␊
1359+␉{ 0x10DE0409,␉NV_SUB_IDS,␉"GeForce 8700M GT" },␊
1360+␉{ 0x10DE040A,␉NV_SUB_IDS,␉"Quadro FX 370" },␊
1361+␉{ 0x10DE040B,␉NV_SUB_IDS,␉"Quadro NVS 320M" },␊
1362+␉{ 0x10DE040C,␉NV_SUB_IDS,␉"Quadro FX 570M" },␊
1363+␉{ 0x10DE040D,␉NV_SUB_IDS,␉"Quadro FX 1600M" },␊
1364+␉{ 0x10DE040E,␉NV_SUB_IDS,␉"Quadro FX 570" },␊
1365+␉{ 0x10DE040F,␉NV_SUB_IDS,␉"Quadro FX 1700" },␊
1366+␉// 0410 - 041F␊
1367+␉{ 0x10DE0410,␉NV_SUB_IDS,␉"GeForce GT 330" },␊
1368+␉// 0420 - 042F␊
1369+␉{ 0x10DE0420,␉NV_SUB_IDS,␉"GeForce 8400 SE" },␊
1370+␉{ 0x10DE0421,␉NV_SUB_IDS,␉"GeForce 8500 GT" },␊
1371+␉{ 0x10DE0422,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
1372+␉{ 0x10DE0423,␉NV_SUB_IDS,␉"GeForce 8300 GS" },␊
1373+␉{ 0x10DE0424,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
1374+␉{ 0x10DE0425,␉NV_SUB_IDS,␉"GeForce 8600M GS" },␊
1375+␉{ 0x10DE0426,␉NV_SUB_IDS,␉"GeForce 8400M GT" },␊
1376+␉{ 0x10DE0427,␉NV_SUB_IDS,␉"GeForce 8400M GS" },␊
1377+␉{ 0x10DE0428,␉NV_SUB_IDS,␉"GeForce 8400M G" },␊
1378+␉{ 0x10DE0429,␉NV_SUB_IDS,␉"Quadro NVS 140M" },␊
1379+␉{ 0x10DE042A,␉NV_SUB_IDS,␉"Quadro NVS 130M" },␊
1380+␉{ 0x10DE042B,␉NV_SUB_IDS,␉"Quadro NVS 135M" },␊
1381+␉{ 0x10DE042C,␉NV_SUB_IDS,␉"GeForce 9400 GT" },␊
1382+␉{ 0x10DE042D,␉NV_SUB_IDS,␉"Quadro FX 360M" },␊
1383+␉{ 0x10DE042E,␉NV_SUB_IDS,␉"GeForce 9300M G" },␊
1384+␉{ 0x10DE042F,␉NV_SUB_IDS,␉"Quadro NVS 290" },␊
1385 ␉// 0430 - 043F␊
1386 ␉// 0440 - 044F␊
1387 ␉// 0450 - 045F␊
1388@@ -394,35 +1149,35 @@␊
1389 ␉// 04A0 - 04AF␊
1390 ␉// 04B0 - 04BF␊
1391 ␉// 04C0 - 04CF␊
1392- { 0x10DE04C0,␉"NVIDIA G78" },␊
1393-␉{ 0x10DE04C1,␉"NVIDIA G78" },␊
1394-␉{ 0x10DE04C2,␉"NVIDIA G78" },␊
1395-␉{ 0x10DE04C3,␉"NVIDIA G78" },␊
1396-␉{ 0x10DE04C4,␉"NVIDIA G78" },␊
1397-␉{ 0x10DE04C5,␉"NVIDIA G78" },␊
1398-␉{ 0x10DE04C6,␉"NVIDIA G78" },␊
1399-␉{ 0x10DE04C7,␉"NVIDIA G78" },␊
1400-␉{ 0x10DE04C8,␉"NVIDIA G78" },␊
1401-␉{ 0x10DE04C9,␉"NVIDIA G78" },␊
1402-␉{ 0x10DE04CA,␉"NVIDIA G78" },␊
1403-␉{ 0x10DE04CB,␉"NVIDIA G78" },␊
1404-␉{ 0x10DE04CC,␉"NVIDIA G78" },␊
1405-␉{ 0x10DE04CD,␉"NVIDIA G78" },␊
1406-␉{ 0x10DE04CE,␉"NVIDIA G78" },␊
1407-␉{ 0x10DE04CF,␉"NVIDIA G78" },␊
1408+␉{ 0x10DE04C0,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1409+␉{ 0x10DE04C1,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1410+␉{ 0x10DE04C2,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1411+␉{ 0x10DE04C3,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1412+␉{ 0x10DE04C4,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1413+␉{ 0x10DE04C5,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1414+␉{ 0x10DE04C6,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1415+␉{ 0x10DE04C7,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1416+␉{ 0x10DE04C8,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1417+␉{ 0x10DE04C9,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1418+␉{ 0x10DE04CA,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1419+␉{ 0x10DE04CB,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1420+␉{ 0x10DE04CC,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1421+␉{ 0x10DE04CD,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1422+␉{ 0x10DE04CE,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1423+␉{ 0x10DE04CF,␉NV_SUB_IDS,␉"NVIDIA G78" },␊
1424 ␉// 04D0 - 04DF␊
1425 ␉// 04E0 - 04EF␊
1426 ␉// 04F0 - 04FF␊
1427-␉// 0500 - 050F␉␊
1428-␉// 0510 - 051F␉␊
1429-␉// 0520 - 052F␉␊
1430-␉// 0530 - 053F␉␊
1431-␉{ 0x10DE0530,␉"GeForce 7190M / nForce 650M" },␊
1432-␉{ 0x10DE0531,␉"GeForce 7150M / nForce 630M" },␊
1433-␉{ 0x10DE0533,␉"GeForce 7000M / nForce 610M" },␊
1434-␉{ 0x10DE053A,␉"GeForce 7050 PV / nForce 630a" },␊
1435-␉{ 0x10DE053B,␉"GeForce 7050 PV / nForce 630a" },␊
1436-␉{ 0x10DE053E,␉"GeForce 7025 / nForce 630a" },␊
1437+␉// 0500 - 050F␊
1438+␉// 0510 - 051F␊
1439+␉// 0520 - 052F␊
1440+␉// 0530 - 053F␊
1441+␉{ 0x10DE0530,␉NV_SUB_IDS,␉"GeForce 7190M / nForce 650M" },␊
1442+␉{ 0x10DE0531,␉NV_SUB_IDS,␉"GeForce 7150M / nForce 630M" },␊
1443+␉{ 0x10DE0533,␉NV_SUB_IDS,␉"GeForce 7000M / nForce 610M" },␊
1444+␉{ 0x10DE053A,␉NV_SUB_IDS,␉"GeForce 7050 PV / nForce 630a" },␊
1445+␉{ 0x10DE053B,␉NV_SUB_IDS,␉"GeForce 7050 PV / nForce 630a" },␊
1446+␉{ 0x10DE053E,␉NV_SUB_IDS,␉"GeForce 7025 / nForce 630a" },␊
1447 ␉// 0540 - 054F␊
1448 ␉// 0550 - 055F␊
1449 ␉// 0560 - 056F␊
1450@@ -433,197 +1188,193 @@␊
1451 ␉// 05B0 - 05BF␊
1452 ␉// 05C0 - 05CF␊
1453 ␉// 05D0 - 05DF␊
1454-␉// 05E0 - 05EF␉␊
1455-␉{ 0x10DE05E0,␉"GeForce GTX 295" },␊
1456-␉{ 0x10DE05E1,␉"GeForce GTX 280" },␊
1457-␉{ 0x10DE05E2,␉"GeForce GTX 260" },␊
1458-␉{ 0x10DE05E3,␉"GeForce GTX 285" },␊
1459-␉{ 0x10DE05E4,␉"NVIDIA GT200" },␊
1460-␉{ 0x10DE05E5,␉"NVIDIA GT200" },␊
1461-␉{ 0x10DE05E6,␉"GeForce GTX 275" },␊
1462-␉{ 0x10DE05E7,␉"Tesla C1060" },␊
1463-␉{ 0x10DE05E8,␉"NVIDIA GT200" },␊
1464-␉{ 0x10DE05E9,␉"NVIDIA GT200" },␊
1465-␉{ 0x10DE05EA,␉"GeForce GTX 260" },␊
1466-␉{ 0x10DE05EB,␉"GeForce GTX 295" },␊
1467-␉{ 0x10DE05EC,␉"NVIDIA GT200" },␊
1468-␉{ 0x10DE05ED,␉"Quadroplex 2200 D2" },␊
1469-␉{ 0x10DE05EE,␉"NVIDIA GT200" },␊
1470-␉{ 0x10DE05EF,␉"NVIDIA GT200" },␊
1471-␉// 05F0 - 05FF␉␉␊
1472-␉{ 0x10DE05F0,␉"NVIDIA GT200" },␊
1473-␉{ 0x10DE05F1,␉"NVIDIA GT200" },␊
1474-␉{ 0x10DE05F2,␉"NVIDIA GT200" },␊
1475-␉{ 0x10DE05F3,␉"NVIDIA GT200" },␊
1476-␉{ 0x10DE05F4,␉"NVIDIA GT200" },␊
1477-␉{ 0x10DE05F5,␉"NVIDIA GT200" },␊
1478-␉{ 0x10DE05F6,␉"NVIDIA GT200" },␊
1479-␉{ 0x10DE05F7,␉"NVIDIA GT200" },␊
1480-␉{ 0x10DE05F8,␉"Quadroplex 2200 S4" },␊
1481-␉{ 0x10DE05F9,␉"Quadro CX" },␊
1482-␉{ 0x10DE05FA,␉"NVIDIA GT200" },␊
1483-␉{ 0x10DE05FB,␉"NVIDIA GT200" },␊
1484-␉{ 0x10DE05FC,␉"NVIDIA GT200" },␊
1485-␉{ 0x10DE05FD,␉"Quadro FX 5800" },␊
1486-␉{ 0x10DE05FE,␉"Quadro FX 4800" },␊
1487-␉{ 0x10DE05FF,␉"Quadro FX 3800" },␊
1488-␉// 0600 - 060F␉␊
1489-␉{ 0x10DE0600, "GeForce 8800 GTS 512" },␊
1490-␉{ 0x10DE0601, "GeForce 9800 GT" },␊
1491-␉{ 0x10DE0602, "GeForce 8800 GT" },␊
1492-␉{ 0x10DE0603, "GeForce GT 230" },␊
1493-␉{ 0x10DE0604, "GeForce 9800 GX2" },␊
1494-␉{ 0x10DE0605, "GeForce 9800 GT" },␊
1495-␉{ 0x10DE0606, "GeForce 8800 GS" },␊
1496-␉{ 0x10DE0607, "GeForce GTS 240" },␊
1497-␉{ 0x10DE0608, "GeForce 9800M GTX" },␊
1498-␉{ 0x10DE0609, "GeForce 8800M GTS" },␊
1499-␉{ 0x10DE060A, "GeForce GTX 280M" },␊
1500-␉{ 0x10DE060B, "GeForce 9800M GT" },␊
1501-␉{ 0x10DE060C, "GeForce 8800M GTX" },␊
1502-␉{ 0x10DE060D, "GeForce 8800 GS" },␊
1503-␉{ 0x10DE060F, "GeForce GTX 285M" },␊
1504-␉// 0610 - 061F␉␊
1505-␉{ 0x10DE0610, "GeForce 9600 GSO" },␊
1506-␉{ 0x10DE0611, "GeForce 8800 GT" },␊
1507-␉{ 0x10DE0612, "GeForce 9800 GTX" },␊
1508-␉{ 0x10DE0613, "GeForce 9800 GTX+" },␊
1509-␉{ 0x10DE0614, "GeForce 9800 GT" },␊
1510-␉{ 0x10DE0615, "GeForce GTS 250" },␊
1511-␉{ 0x10DE0617, "GeForce 9800M GTX" },␊
1512-␉{ 0x10DE0618, "GeForce GTX 260M" },␊
1513-␉{ 0x10DE0619, "Quadro FX 4700 X2" },␊
1514-␉{ 0x10DE061A, "Quadro FX 3700" },␊
1515-␉{ 0x10DE061B, "Quadro VX 200" },␊
1516-␉{ 0x10DE061C, "Quadro FX 3600M" },␊
1517-␉{ 0x10DE061D, "Quadro FX 2800M" },␊
1518-␉{ 0x10DE061E, "Quadro FX 3700M" }, ␊
1519-␉{ 0x10DE061F, "Quadro FX 3800M" },␊
1520-␉// 0620 - 062F␉␊
1521-␉{ 0x10DE0620,␉"NVIDIA G94" }, // GeForce 8100/8200/8300␊
1522-␉{ 0x10DE0621,␉"GeForce GT 230" },␊
1523-␉{ 0x10DE0622,␉"GeForce 9600 GT" },␊
1524-␉{ 0x10DE0623,␉"GeForce 9600 GS" },␊
1525-␉{ 0x10DE0624,␉"NVIDIA G94" },␊
1526-␉{ 0x10DE0625,␉"GeForce 9600 GSO 512"},␊
1527-␉{ 0x10DE0626,␉"GeForce GT 130" },␊
1528-␉{ 0x10DE0627,␉"GeForce GT 140" },␊
1529-␉{ 0x10DE0628,␉"GeForce 9800M GTS" },␊
1530-␉{ 0x10DE0629,␉"NVIDIA G94" },␊
1531-␉{ 0x10DE062A,␉"GeForce 9700M GTS" },␊
1532-␉{ 0x10DE062B,␉"GeForce 9800M GS" },␊
1533-␉{ 0x10DE062C,␉"GeForce 9800M GTS" },␊
1534-␉{ 0x10DE062D,␉"GeForce 9600 GT" },␊
1535-␉{ 0x10DE062E,␉"GeForce 9600 GT" },␊
1536-␉{ 0x10DE062F,␉"GeForce 9800 S" },␊
1537-␉// 0630 - 063F␉␊
1538-␉{ 0x10DE0630,␉"NVIDIA G94" },␊
1539-␉{ 0x10DE0631,␉"GeForce GTS 160M" },␊
1540-␉{ 0x10DE0632,␉"GeForce GTS 150M" },␊
1541-␉{ 0x10DE0633,␉"NVIDIA G94" },␊
1542-␉{ 0x10DE0634,␉"NVIDIA G94" },␊
1543-␉{ 0x10DE0635,␉"GeForce 9600 GSO" },␊
1544-␉{ 0x10DE0636,␉"NVIDIA G94" },␊
1545-␉{ 0x10DE0637,␉"GeForce 9600 GT" },␊
1546-␉{ 0x10DE0638,␉"Quadro FX 1800" },␊
1547-␉{ 0x10DE0639,␉"NVIDIA G94" },␊
1548-␉{ 0x10DE063A,␉"Quadro FX 2700M" },␊
1549-␉{ 0x10DE063B,␉"NVIDIA G94" },␊
1550-␉{ 0x10DE063C,␉"NVIDIA G94" },␊
1551-␉{ 0x10DE063D,␉"NVIDIA G94" },␊
1552-␉{ 0x10DE063E,␉"NVIDIA G94" },␊
1553-␉{ 0x10DE063F,␉"NVIDIA G94" },␊
1554-␉// 0640 - 064F␉␊
1555-␉{ 0x10DE0640, "GeForce 9500 GT" },␊
1556-␉{ 0x10DE0641, "GeForce 9400 GT" },␊
1557-␉{ 0x10DE0642, "GeForce 8400 GS" },␊
1558-␉{ 0x10DE0643, "GeForce 9500 GT" },␊
1559-␉{ 0x10DE0644, "GeForce 9500 GS" },␊
1560-␉{ 0x10DE0645, "GeForce 9500 GS" },␊
1561-␉{ 0x10DE0646, "GeForce GT 120" },␊
1562-␉{ 0x10DE0647, "GeForce 9600M GT" },␊
1563-␉{ 0x10DE0648, "GeForce 9600M GS" },␊
1564-␉{ 0x10DE0649, "GeForce 9600M GT" },␊
1565-␉{ 0x10DE064A, "GeForce 9700M GT" },␊
1566-␉{ 0x10DE064B, "GeForce 9500M G" },␊
1567-␉{ 0x10DE064C, "GeForce 9650M GT" },␊
1568-␉// 0650 - 065F␉␉␊
1569-␉{ 0x10DE0650,␉"NVIDIA G96-825" },␊
1570-␉{ 0x10DE0651,␉"GeForce G 110M" },␊
1571-␉{ 0x10DE0652,␉"GeForce GT 130M" },␊
1572-␉{ 0x10DE0653,␉"GeForce GT 120M" },␊
1573-␉{ 0x10DE0654,␉"GeForce GT 220M" },␊
1574-␉{ 0x10DE0655,␉"GeForce GT 120" },␊
1575-␉{ 0x10DE0656,␉"GeForce 9650 S" },␊
1576-␉{ 0x10DE0657,␉"NVIDIA G96" },␊
1577-␉{ 0x10DE0658,␉"Quadro FX 380" },␊
1578-␉{ 0x10DE0659,␉"Quadro FX 580" },␊
1579-␉{ 0x10DE065A,␉"Quadro FX 1700M" },␊
1580-␉{ 0x10DE065B,␉"GeForce 9400 GT" },␊
1581-␉{ 0x10DE065C,␉"Quadro FX 770M" },␊
1582-␉{ 0x10DE065D,␉"NVIDIA G96" },␊
1583-␉{ 0x10DE065E,␉"NVIDIA G96" },␊
1584-␉{ 0x10DE065F,␉"GeForce G210" },␊
1585+␉// 05E0 - 05EF␊
1586+␉{ 0x10DE05E0,␉NV_SUB_IDS,␉"GeForce GTX 295" },␊
1587+␉{ 0x10DE05E1,␉NV_SUB_IDS,␉"GeForce GTX 280" },␊
1588+␉{ 0x10DE05E2,␉NV_SUB_IDS,␉"GeForce GTX 260" },␊
1589+␉{ 0x10DE05E3,␉NV_SUB_IDS,␉"GeForce GTX 285" },␊
1590+␉{ 0x10DE05E4,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1591+␉{ 0x10DE05E5,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1592+␉{ 0x10DE05E6,␉NV_SUB_IDS,␉"GeForce GTX 275" },␊
1593+␉{ 0x10DE05E7,␉NV_SUB_IDS,␉"nVidia Tesla C1060" },␊
1594+␉{ 0x10DE05E8,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1595+␉{ 0x10DE05E9,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1596+␉{ 0x10DE05EA,␉NV_SUB_IDS,␉"GeForce GTX 260" },␊
1597+␉{ 0x10DE05EB,␉NV_SUB_IDS,␉"GeForce GTX 295" },␊
1598+␉{ 0x10DE05EC,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1599+␉{ 0x10DE05ED,␉NV_SUB_IDS,␉"Quadroplex 2200 D2" },␊
1600+␉{ 0x10DE05EE,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1601+␉{ 0x10DE05EF,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1602+␉// 05F0 - 05FF␊
1603+␉{ 0x10DE05F0,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1604+␉{ 0x10DE05F1,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1605+␉{ 0x10DE05F2,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1606+␉{ 0x10DE05F3,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1607+␉{ 0x10DE05F4,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1608+␉{ 0x10DE05F5,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1609+␉{ 0x10DE05F6,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1610+␉{ 0x10DE05F7,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1611+␉{ 0x10DE05F8,␉NV_SUB_IDS,␉"Quadroplex 2200 S4" },␊
1612+␉{ 0x10DE05F9,␉NV_SUB_IDS,␉"NVIDIA Quadro CX" },␊
1613+␉{ 0x10DE05FA,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1614+␉{ 0x10DE05FB,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1615+␉{ 0x10DE05FC,␉NV_SUB_IDS,␉"NVIDIA GT200" },␊
1616+␉{ 0x10DE05FD,␉NV_SUB_IDS,␉"Quadro FX 5800" },␊
1617+␉{ 0x10DE05FE,␉NV_SUB_IDS,␉"Quadro FX 4800" },␊
1618+␉{ 0x10DE05FF,␉NV_SUB_IDS,␉"Quadro FX 3800" },␊
1619+␉// 0600 - 060F␊
1620+␉{ 0x10DE0600,␉NV_SUB_IDS,␉"GeForce 8800 GTS 512" },␊
1621+␉{ 0x10DE0601,␉NV_SUB_IDS,␉"GeForce 9800 GT" },␊
1622+␉{ 0x10DE0602,␉NV_SUB_IDS,␉"GeForce 8800 GT" },␊
1623+␉{ 0x10DE0603,␉NV_SUB_IDS,␉"GeForce GT 230" },␊
1624+␉{ 0x10DE0604,␉NV_SUB_IDS,␉"GeForce 9800 GX2" },␊
1625+␉{ 0x10DE0605,␉NV_SUB_IDS,␉"GeForce 9800 GT" },␊
1626+␉{ 0x10DE0606,␉NV_SUB_IDS,␉"GeForce 8800 GS" },␊
1627+␉{ 0x10DE0607,␉NV_SUB_IDS,␉"GeForce GTS 240" },␊
1628+␉{ 0x10DE0608,␉NV_SUB_IDS,␉"GeForce 9800M GTX" },␊
1629+␉{ 0x10DE0609,␉NV_SUB_IDS,␉"GeForce 8800M GTS" },␊
1630+␉{ 0x10DE060A,␉NV_SUB_IDS,␉"GeForce GTX 280M" },␊
1631+␉{ 0x10DE060B,␉NV_SUB_IDS,␉"GeForce 9800M GT" },␊
1632+␉{ 0x10DE060C,␉NV_SUB_IDS,␉"GeForce 8800M GTX" },␊
1633+␉{ 0x10DE060D,␉NV_SUB_IDS,␉"GeForce 8800 GS" },␊
1634+␉{ 0x10DE060F,␉NV_SUB_IDS,␉"GeForce GTX 285M" },␊
1635+␉// 0610 - 061F␊
1636+␉{ 0x10DE0610,␉NV_SUB_IDS,␉"GeForce 9600 GSO" },␊
1637+␉{ 0x10DE0611,␉NV_SUB_IDS,␉"GeForce 8800 GT" },␊
1638+␉{ 0x10DE0612,␉NV_SUB_IDS,␉"GeForce 9800 GTX" },␊
1639+␉{ 0x10DE0613,␉NV_SUB_IDS,␉"GeForce 9800 GTX+" },␊
1640+␉{ 0x10DE0614,␉NV_SUB_IDS,␉"GeForce 9800 GT" },␊
1641+␉{ 0x10DE0615,␉NV_SUB_IDS,␉"GeForce GTS 250" },␊
1642+␉{ 0x10DE0617,␉NV_SUB_IDS,␉"GeForce 9800M GTX" },␊
1643+␉{ 0x10DE0618,␉NV_SUB_IDS,␉"GeForce GTX 170M" },␊
1644+␉{ 0x10DE0619,␉NV_SUB_IDS,␉"Quadro FX 4700 X2" },␊
1645+␉{ 0x10DE061A,␉NV_SUB_IDS,␉"Quadro FX 3700" },␊
1646+␉{ 0x10DE061B,␉NV_SUB_IDS,␉"Quadro VX 200" },␊
1647+␉{ 0x10DE061C,␉NV_SUB_IDS,␉"Quadro FX 3600M" },␊
1648+␉{ 0x10DE061D,␉NV_SUB_IDS,␉"Quadro FX 2800M" },␊
1649+␉{ 0x10DE061E,␉NV_SUB_IDS,␉"Quadro FX 3700M" },␊
1650+␉{ 0x10DE061F,␉NV_SUB_IDS,␉"Quadro FX 3800M" },␊
1651+␉// 0620 - 062F␊
1652+␉{ 0x10DE0620,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1653+␉{ 0x10DE0621,␉NV_SUB_IDS,␉"GeForce GT 230" },␊
1654+␉{ 0x10DE0622,␉NV_SUB_IDS,␉"GeForce 9600 GT" },␊
1655+␉{ 0x10DE0623,␉NV_SUB_IDS,␉"GeForce 9600 GS" },␊
1656+␉{ 0x10DE0624,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1657+␉{ 0x10DE0625,␉NV_SUB_IDS,␉"GeForce 9600 GSO 512"},␊
1658+␉{ 0x10DE0626,␉NV_SUB_IDS,␉"GeForce GT 130" },␊
1659+␉{ 0x10DE0627,␉NV_SUB_IDS,␉"GeForce GT 140" },␊
1660+␉{ 0x10DE0628,␉NV_SUB_IDS,␉"GeForce 9800M GTS" },␊
1661+␉{ 0x10DE0629,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1662+␉{ 0x10DE062A,␉NV_SUB_IDS,␉"GeForce 9700M GTS" },␊
1663+␉{ 0x10DE062B,␉NV_SUB_IDS,␉"GeForce 9800M GS" },␊
1664+␉{ 0x10DE062C,␉NV_SUB_IDS,␉"GeForce 9800M GTS" },␊
1665+␉{ 0x10DE062D,␉NV_SUB_IDS,␉"GeForce 9600 GT" },␊
1666+␉{ 0x10DE062E,␉NV_SUB_IDS,␉"GeForce 9600 GT" },␊
1667+␉{ 0x10DE062F,␉NV_SUB_IDS,␉"GeForce 9800 S" },␊
1668+␉// 0630 - 063F␊
1669+␉{ 0x10DE0630,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1670+␉{ 0x10DE0631,␉NV_SUB_IDS,␉"GeForce GTS 160M" },␊
1671+␉{ 0x10DE0632,␉NV_SUB_IDS,␉"GeForce GTS 150M" },␊
1672+␉{ 0x10DE0633,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1673+␉{ 0x10DE0634,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1674+␉{ 0x10DE0635,␉NV_SUB_IDS,␉"GeForce 9600 GSO" },␊
1675+␉{ 0x10DE0636,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1676+␉{ 0x10DE0637,␉NV_SUB_IDS,␉"GeForce 9600 GT" },␊
1677+␉{ 0x10DE0638,␉NV_SUB_IDS,␉"Quadro FX 1800" },␊
1678+␉{ 0x10DE0639,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1679+␉{ 0x10DE063A,␉NV_SUB_IDS,␉"Quadro FX 2700M" },␊
1680+␉{ 0x10DE063B,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1681+␉{ 0x10DE063C,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1682+␉{ 0x10DE063D,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1683+␉{ 0x10DE063E,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1684+␉{ 0x10DE063F,␉NV_SUB_IDS,␉"NVIDIA G94" },␊
1685+␉// 0640 - 064F␊
1686+␉{ 0x10DE0640,␉NV_SUB_IDS,␉"GeForce 9500 GT" },␊
1687+␉{ 0x10DE0641,␉NV_SUB_IDS,␉"GeForce 9400 GT" },␊
1688+␉{ 0x10DE0642,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
1689+␉{ 0x10DE0643,␉NV_SUB_IDS,␉"GeForce 9500 GT" },␊
1690+␉{ 0x10DE0644,␉NV_SUB_IDS,␉"GeForce 9500 GS" },␊
1691+␉{ 0x10DE0645,␉NV_SUB_IDS,␉"GeForce 9500 GS" },␊
1692+␉{ 0x10DE0646,␉NV_SUB_IDS,␉"GeForce GT 120" },␊
1693+␉{ 0x10DE0647,␉NV_SUB_IDS,␉"GeForce 9600M GT" },␊
1694+␉{ 0x10DE0648,␉NV_SUB_IDS,␉"GeForce 9600M GS" },␊
1695+␉{ 0x10DE0649,␉NV_SUB_IDS,␉"GeForce 9600M GT" },␊
1696+␉{ 0x10DE064A,␉NV_SUB_IDS,␉"GeForce 9700M GT" },␊
1697+␉{ 0x10DE064B,␉NV_SUB_IDS,␉"GeForce 9500M G" },␊
1698+␉{ 0x10DE064C,␉NV_SUB_IDS,␉"GeForce 9650M GT" },␊
1699+␉// 0650 - 065F␊
1700+␉{ 0x10DE0650,␉NV_SUB_IDS,␉"NVIDIA G96-825" },␊
1701+␉{ 0x10DE0651,␉NV_SUB_IDS,␉"GeForce G 110M" },␊
1702+␉{ 0x10DE0652,␉NV_SUB_IDS,␉"GeForce GT 130M" },␊
1703+␉{ 0x10DE0653,␉NV_SUB_IDS,␉"GeForce GT 120M" },␊
1704+␉{ 0x10DE0654,␉NV_SUB_IDS,␉"GeForce GT 220M" },␊
1705+␉{ 0x10DE0655,␉NV_SUB_IDS,␉"GeForce GT 120" },␊
1706+␉{ 0x10DE0656,␉NV_SUB_IDS,␉"GeForce 9650 S" },␊
1707+␉{ 0x10DE0657,␉NV_SUB_IDS,␉"NVIDIA G96" },␊
1708+␉{ 0x10DE0658,␉NV_SUB_IDS,␉"Quadro FX 380" },␊
1709+␉{ 0x10DE0659,␉NV_SUB_IDS,␉"Quadro FX 580" },␊
1710+␉{ 0x10DE065A,␉NV_SUB_IDS,␉"Quadro FX 1700M" },␊
1711+␉{ 0x10DE065B,␉NV_SUB_IDS,␉"GeForce 9400 GT" },␊
1712+␉{ 0x10DE065C,␉NV_SUB_IDS,␉"Quadro FX 770M" },␊
1713+␉{ 0x10DE065D,␉NV_SUB_IDS,␉"NVIDIA G96" },␊
1714+␉{ 0x10DE065E,␉NV_SUB_IDS,␉"NVIDIA G96" },␊
1715+␉{ 0x10DE065F,␉NV_SUB_IDS,␉"GeForce G210" },␊
1716 ␉// 0660 - 066F␊
1717 ␉// 0670 - 067F␊
1718 ␉// 0680 - 068F␊
1719 ␉// 0690 - 069F␊
1720 ␉// 06A0 - 06AF␊
1721-␉{ 0x10DE06A0,␉"NVIDIA GT214" },␊
1722+␉{ 0x10DE06A0,␉NV_SUB_IDS,␉"NVIDIA GT214" },␊
1723 ␉// 06B0 - 06BF␊
1724-␉{ 0x10DE06B0,␉"NVIDIA GT214" },␊
1725+␉{ 0x10DE06B0,␉NV_SUB_IDS,␉"NVIDIA GT214" },␊
1726 ␉// 06C0 - 06CF␊
1727-␉{ 0x10DE06C0, "GeForce GTX 480" },␊
1728-␉{ 0x10DE06C3, "GeForce GTX D12U" },␊
1729-␉{ 0x10DE06C4, "GeForce GTX 465" },␊
1730-␉{ 0x10DE06CA, "GeForce GTX 480M" },␊
1731-␉{ 0x10DE06CD, "GeForce GTX 470" },␊
1732+␉{ 0x10DE06C0,␉NV_SUB_IDS,␉"GeForce GTX 480" },␊
1733+␉{ 0x10DE06C3,␉NV_SUB_IDS,␉"GeForce GTX D12U" },␊
1734+␉{ 0x10DE06C4,␉NV_SUB_IDS,␉"GeForce GTX 465" },␊
1735+␉{ 0x10DE06CA,␉NV_SUB_IDS,␉"GeForce GTX 480M" },␊
1736+␉{ 0x10DE06CD,␉NV_SUB_IDS,␉"GeForce GTX 470" },␊
1737 ␉// 06D0 - 06DF␊
1738-␉{ 0x10DE06D1,␉"Tesla C2050 / C2070" },␊
1739-␉// { 0x10DE06D1,␉0x10DE0771,␉"Tesla C2050" },␊
1740-␉// { 0x10DE06D1,␉0x10DE0772,␉"Tesla C2070" },␊
1741-␉{ 0x10DE06D2,␉"Tesla M2070 / X2070" },␊
1742-␉{ 0x10DE06D8, "Quadro 6000" },␊
1743-␉{ 0x10DE06D9, "Quadro 5000" },␊
1744-␉{ 0x10DE06DA, "Quadro 5000M" },␊
1745-␉{ 0x10DE06DC, "Quadro 6000" },␊
1746-␉{ 0x10DE06DD, "Quadro 4000" },␊
1747-␉{ 0x10DE06DE, "Tesla M2050" },␉// TODO: sub-device id: 0x0846␊
1748-␉{ 0x10DE06DE, "Tesla M2070" },␉// TODO: sub-device id: ?␉␊
1749-␉{ 0x10DE06DF, "Tesla M2070-Q" }, ␊
1750-␉// 0x10DE06DE also applies to misc S2050, X2070, M2050, M2070␊
1751-␉// 06E0 - 06EF␉␊
1752-␉{ 0x10DE06E0, "GeForce 9300 GE" },␊
1753-␉{ 0x10DE06E1, "GeForce 9300 GS" },␊
1754-␉{ 0x10DE06E2, "GeForce 8400" },␊
1755-␉{ 0x10DE06E3, "GeForce 8400 SE" },␊
1756-␉{ 0x10DE06E4, "GeForce 8400 GS" },␊
1757-␉{ 0x10DE06E5, "GeForce 9300M GS" },␊
1758-␉{ 0x10DE06E6, "GeForce G100" },␊
1759-␉{ 0x10DE06E7, "GeForce 9300 SE" },␊
1760-␉{ 0x10DE06E8, "GeForce 9200M GS" },␊
1761-␉{ 0x10DE06E9, "GeForce 9300M GS" },␊
1762-␉{ 0x10DE06EA, "Quadro NVS 150M" },␊
1763-␉{ 0x10DE06EB, "Quadro NVS 160M" },␊
1764-␉{ 0x10DE06EC, "GeForce G 105M" },␊
1765-␉{ 0x10DE06EF, "GeForce G 103M" },␊
1766-␉// 06F0 - 06FF␉␊
1767-␉{ 0x10DE06F0,␉"NVIDIA G98" },␊
1768-␉{ 0x10DE06F1,␉"GeForce G105M" },␊
1769-␉{ 0x10DE06F2,␉"NVIDIA G98" },␊
1770-␉{ 0x10DE06F3,␉"NVIDIA G98" },␊
1771-␉{ 0x10DE06F4,␉"NVIDIA G98" },␊
1772-␉{ 0x10DE06F5,␉"NVIDIA G98" },␊
1773-␉{ 0x10DE06F6,␉"NVIDIA G98" },␊
1774-␉{ 0x10DE06F7,␉"NVIDIA G98" },␊
1775-␉{ 0x10DE06F8,␉"Quadro NVS 420" },␊
1776-␉{ 0x10DE06F9,␉"Quadro FX 370 LP" },␊
1777-␉{ 0x10DE06FA,␉"Quadro NVS 450" },␊
1778-␉{ 0x10DE06FB,␉"Quadro FX 370M" },␊
1779-␉{ 0x10DE06FC,␉"NVIDIA G98" },␊
1780-␉{ 0x10DE06FD,␉"Quadro NVS 295" },␊
1781-␉{ 0x10DE06FE,␉"NVIDIA G98" },␊
1782-␉{ 0x10DE06FF,␉"HICx16 + Graphics" },␊
1783+␉{ 0x10DE06D1,␉NV_SUB_IDS,␉"Tesla C2050 / C2070" },␊
1784+␉{ 0x10DE06D2,␉NV_SUB_IDS,␉"Tesla M2070 / X2070" },␊
1785+␉{ 0x10DE06D8,␉NV_SUB_IDS,␉"Quadro 6000" },␊
1786+␉{ 0x10DE06D9,␉NV_SUB_IDS,␉"Quadro 5000" },␊
1787+␉{ 0x10DE06DC,␉NV_SUB_IDS,␉"Quadro 6000" },␊
1788+␉{ 0x10DE06DD,␉NV_SUB_IDS,␉"nVidia Quadro 4000" },␊
1789+␉{ 0x10DE06DE,␉NV_SUB_IDS,␉"nVidia Tesla S2050" },␊
1790+␉{ 0x10DE06DF,␉NV_SUB_IDS,␉"Tesla M2070Q" },␊
1791+␉// 06E0 - 06EF␊
1792+␉{ 0x10DE06E0,␉NV_SUB_IDS,␉"GeForce 9300 GE" },␊
1793+␉{ 0x10DE06E1,␉NV_SUB_IDS,␉"GeForce 9300 GS" },␊
1794+␉{ 0x10DE06E2,␉NV_SUB_IDS,␉"GeForce 8400" },␊
1795+␉{ 0x10DE06E3,␉NV_SUB_IDS,␉"GeForce 8400 SE" },␊
1796+␉{ 0x10DE06E4,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
1797+␉{ 0x10DE06E5,␉NV_SUB_IDS,␉"GeForce 9300M GS" },␊
1798+␉{ 0x10DE06E6,␉NV_SUB_IDS,␉"GeForce G100" },␊
1799+␉{ 0x10DE06E7,␉NV_SUB_IDS,␉"GeForce 9300 SE" },␊
1800+␉{ 0x10DE06E8,␉NV_SUB_IDS,␉"GeForce 9200M GS" },␊
1801+␉{ 0x10DE06E9,␉NV_SUB_IDS,␉"GeForce 9300M GS" },␊
1802+␉{ 0x10DE06EA,␉NV_SUB_IDS,␉"Quadro NVS 150M" },␊
1803+␉{ 0x10DE06EB,␉NV_SUB_IDS,␉"Quadro NVS 160M" },␊
1804+␉{ 0x10DE06EC,␉NV_SUB_IDS,␉"GeForce G 105M" },␊
1805+␉{ 0x10DE06ED,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1806+␉{ 0x10DE06EF,␉NV_SUB_IDS,␉"GeForce G 103M" },␊
1807+␉// 06F0 - 06FF␊
1808+␉{ 0x10DE06F0,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1809+␉{ 0x10DE06F1,␉NV_SUB_IDS,␉"GeForce G105M" },␊
1810+␉{ 0x10DE06F2,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1811+␉{ 0x10DE06F3,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1812+␉{ 0x10DE06F4,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1813+␉{ 0x10DE06F5,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1814+␉{ 0x10DE06F6,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1815+␉{ 0x10DE06F7,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1816+␉{ 0x10DE06F8,␉NV_SUB_IDS,␉"Quadro NVS 420" },␊
1817+␉{ 0x10DE06F9,␉NV_SUB_IDS,␉"Quadro FX 370 LP" },␊
1818+␉{ 0x10DE06FA,␉NV_SUB_IDS,␉"Quadro NVS 450" },␊
1819+␉{ 0x10DE06FB,␉NV_SUB_IDS,␉"Quadro FX 370M" },␊
1820+␉{ 0x10DE06FC,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1821+␉{ 0x10DE06FD,␉NV_SUB_IDS,␉"Quadro NVS 295" },␊
1822+␉{ 0x10DE06FE,␉NV_SUB_IDS,␉"NVIDIA G98" },␊
1823+␉// { 0x10DE06FF,␉NV_SUB_IDS,␉"HICx16 + Graphics" },␊
1824 ␉// 0700 - 070F␊
1825 ␉// 0710 - 071F␊
1826 ␉// 0720 - 072F␊
1827@@ -637,71 +1388,76 @@␊
1828 ␉// 07A0 - 07AF␊
1829 ␉// 07B0 - 07BF␊
1830 ␉// 07C0 - 07CF␊
1831-␉// 07D0 - 07DF␉␊
1832-␉// 07E0 - 07EF␉␉␊
1833-␉{ 0x10DE07E0, "GeForce 7150 / nForce 630i" },␊
1834-␉{ 0x10DE07E1, "GeForce 7100 / nForce 630i" },␊
1835-␉{ 0x10DE07E2, "GeForce 7050 / nForce 630i" },␊
1836-␉{ 0x10DE07E3, "GeForce 7050 / nForce 610i" },␊
1837-␉{ 0x10DE07E5, "GeForce 7050 / nForce 620i" },␊
1838-␉// 07F0 - 07FF␉␊
1839+␉// 07D0 - 07DF␊
1840+␉// 07E0 - 07EF␊
1841+␉{ 0x10DE07E0,␉NV_SUB_IDS,␉"GeForce 7150 / nForce 630i" },␊
1842+␉{ 0x10DE07E1,␉NV_SUB_IDS,␉"GeForce 7100 / nForce 630i" },␊
1843+␉{ 0x10DE07E2,␉NV_SUB_IDS,␉"GeForce 7050 / nForce 630i" },␊
1844+␉{ 0x10DE07E3,␉NV_SUB_IDS,␉"GeForce 7050 / nForce 610i" },␊
1845+␉{ 0x10DE07E5,␉NV_SUB_IDS,␉"GeForce 7050 / nForce 620i" },␊
1846+␉// 07F0 - 07FF␊
1847 ␉// 0800 - 080F␊
1848 ␉// 0810 - 081F␊
1849 ␉// 0820 - 082F␊
1850 ␉// 0830 - 083F␊
1851 ␉// 0840 - 084F␊
1852-␉{ 0x10DE0840, "GeForce 8200M" }, ␊
1853-␉{ 0x10DE0844, "GeForce 9100M G" },␊
1854-␉{ 0x10DE0845, "GeForce 8200M G" },␊
1855-␉{ 0x10DE0846, "GeForce 9200" },␊
1856-␉{ 0x10DE0847, "GeForce 9100" },␊
1857-␉{ 0x10DE0848, "GeForce 8300" },␊
1858-␉{ 0x10DE0849, "GeForce 8200" },␊
1859-␉{ 0x10DE084A, "nForce 730a" },␊
1860-␉{ 0x10DE084B, "GeForce 9200" },␊
1861-␉{ 0x10DE084C, "nForce 980a/780a SLI" },␊
1862-␉{ 0x10DE084D, "nForce 750a SLI" },␊
1863-␉{ 0x10DE084F, "GeForce 8100 / nForce 720a" },␊
1864+␉{ 0x10DE0840,␉NV_SUB_IDS,␉"GeForce 8200M" },␊
1865+␉{ 0x10DE0844,␉NV_SUB_IDS,␉"GeForce 9100M G" },␊
1866+␉{ 0x10DE0845,␉NV_SUB_IDS,␉"GeForce 8200M G" },␊
1867+␉{ 0x10DE0846,␉NV_SUB_IDS,␉"GeForce 9200" },␊
1868+␉{ 0x10DE0847,␉NV_SUB_IDS,␉"GeForce 9100" },␊
1869+␉{ 0x10DE0848,␉NV_SUB_IDS,␉"GeForce 8300" },␊
1870+␉{ 0x10DE0849,␉NV_SUB_IDS,␉"GeForce 8200" },␊
1871+␉{ 0x10DE084A,␉NV_SUB_IDS,␉"nForce 730a" },␊
1872+␉{ 0x10DE084B,␉NV_SUB_IDS,␉"GeForce 9200" },␊
1873+␉{ 0x10DE084C,␉NV_SUB_IDS,␉"nForce 980a/780a SLI" },␊
1874+␉{ 0x10DE084D,␉NV_SUB_IDS,␉"nForce 750a SLI" },␊
1875+␉{ 0x10DE084F,␉NV_SUB_IDS,␉"GeForce 8100 / nForce 720a" },␊
1876 ␉// 0850 - 085F␊
1877-␉// 0860 - 086F␉␊
1878-␉{ 0x10DE0860, "GeForce 9400" },␊
1879-␉{ 0x10DE0861, "GeForce 9400" },␊
1880-␉{ 0x10DE0862, "GeForce 9400M G" },␊
1881-␉{ 0x10DE0863, "GeForce 9400M" },␊
1882-␉{ 0x10DE0864, "GeForce 9300" },␊
1883-␉{ 0x10DE0865, "ION" },␊
1884-␉{ 0x10DE0866, "GeForce 9400M G" },␊
1885-␉{ 0x10DE0867, "GeForce 9400" },␊
1886-␉{ 0x10DE0868, "nForce 760i SLI" },␊
1887-␉{ 0x10DE0869, "GeForce 9400" }, ␊
1888-␉{ 0x10DE086A, "GeForce 9400" },␊
1889-␉{ 0x10DE086C, "GeForce 9300 / nForce 730i" },␊
1890-␉{ 0x10DE086D, "GeForce 9200" },␊
1891-␉{ 0x10DE086E, "GeForce 9100M G" },␊
1892-␉{ 0x10DE086F, "GeForce 8200M G" },␊
1893-␉// 0870 - 087F␉␊
1894-␉{ 0x10DE0870, "GeForce 9400M" },␊
1895-␉{ 0x10DE0871, "GeForce 9200" },␊
1896-␉{ 0x10DE0872, "GeForce G102M" },␊
1897-␉{ 0x10DE0873, "GeForce G102M" },␊
1898-␉{ 0x10DE0874, "ION 9300M" },␉␊
1899-␉{ 0x10DE0876, "ION" },␊
1900-␉{ 0x10DE087A, "GeForce 9400" },␊
1901-␉{ 0x10DE087D, "ION 9400M" },␊
1902-␉{ 0x10DE087E, "ION LE" },␊
1903-␉{ 0x10DE087F, "ION LE" },␊
1904+␉// 0860 - 086F␊
1905+␉{ 0x10DE0860,␉NV_SUB_IDS,␉"GeForce 9300" },␊
1906+␉{ 0x10DE0861,␉NV_SUB_IDS,␉"GeForce 9400" },␊
1907+␉{ 0x10DE0862,␉NV_SUB_IDS,␉"GeForce 9400M G" },␊
1908+␉{ 0x10DE0863,␉NV_SUB_IDS,␉"GeForce 9400M" },␊
1909+␉{ 0x10DE0864,␉NV_SUB_IDS,␉"GeForce 9300" },␊
1910+␉{ 0x10DE0865,␉NV_SUB_IDS,␉"GeForce 9300" },␊
1911+␉{ 0x10DE0866,␉NV_SUB_IDS,␉"GeForce 9400M G" },␊
1912+␉{ 0x10DE0867,␉NV_SUB_IDS,␉"GeForce 9400" },␊
1913+␉{ 0x10DE0868,␉NV_SUB_IDS,␉"nForce 760i SLI" },␊
1914+␉{ 0x10DE0869,␉NV_SUB_IDS,␉"GeForce 9400" },␊
1915+␉{ 0x10DE086A,␉NV_SUB_IDS,␉"GeForce 9400" },␊
1916+␉{ 0x10DE086C,␉NV_SUB_IDS,␉"GeForce 9300 / nForce 730i" },␊
1917+␉{ 0x10DE086D,␉NV_SUB_IDS,␉"GeForce 9200" },␊
1918+␉{ 0x10DE086E,␉NV_SUB_IDS,␉"GeForce 9100M G" },␊
1919+␉{ 0x10DE086F,␉NV_SUB_IDS,␉"GeForce 8200M G" },␊
1920+␉// 0870 - 087F␊
1921+␉{ 0x10DE0870,␉NV_SUB_IDS,␉"GeForce 9400M" },␊
1922+␉{ 0x10DE0871,␉NV_SUB_IDS,␉"GeForce 9200" },␊
1923+␉{ 0x10DE0872,␉NV_SUB_IDS,␉"GeForce G102M" },␊
1924+␉{ 0x10DE0873,␉NV_SUB_IDS,␉"GeForce G102M" },␊
1925+␉{ 0x10DE0874,␉NV_SUB_IDS,␉"ION 9300M" },␊
1926+␉{ 0x10DE0876,␉NV_SUB_IDS,␉"ION 9400M" },␊
1927+␉{ 0x10DE087A,␉NV_SUB_IDS,␉"GeForce 9400" },␊
1928+␉{ 0x10DE087D,␉NV_SUB_IDS,␉"ION 9400M" },␊
1929+␉{ 0x10DE087E,␉NV_SUB_IDS,␉"ION LE" },␊
1930+␉{ 0x10DE087F,␉NV_SUB_IDS,␉"ION LE" },␊
1931 ␉// 0880 - 088F␊
1932 ␉// 0890 - 089F␊
1933 ␉// 08A0 - 08AF␊
1934-␉{ 0x10DE08A0,␉"GeForce 320M" },␊
1935-␉{ 0x10DE08A3,␉"GeForce 320M" },␊
1936-␉{ 0x10DE08A4,␉"GeForce 320M" },␊
1937-␉{ 0x10DE08A5,␉"GeForce 320M" },␊
1938+␉{ 0x10DE08A0,␉NV_SUB_IDS,␉"GeForce 320M" },␊
1939+␉// { 0x10DE08A1,␉NV_SUB_IDS,␉"NVIDIA MCP89-MZT" },␊
1940+␉// { 0x10DE08A2,␉NV_SUB_IDS,␉"NVIDIA MCP89-EPT" },␊
1941+␉{ 0x10DE08A3,␉NV_SUB_IDS,␉"GeForce 320M" },␊
1942+␉{ 0x10DE08A4,␉NV_SUB_IDS,␉"GeForce 320M" },␊
1943+␉{ 0x10DE08A5,␉NV_SUB_IDS,␉"GeForce 320M" },␊
1944 ␉// 08B0 - 08BF␊
1945-␉{ 0x10DE08B1,␉"GeForce 300M" },␊
1946+␉// { 0x10DE08B0,␉NV_SUB_IDS,␉"MCP83 MMD" },␊
1947+␉{ 0x10DE08B1,␉NV_SUB_IDS,␉"GeForce 300M" },␊
1948+␉// { 0x10DE08B2,␉NV_SUB_IDS,␉"NVIDIA MCP83-MJ" },␊
1949+␉// { 0x10DE08B3,␉NV_SUB_IDS,␉"NVIDIA MCP89 MM9" },␊
1950 ␉// 08C0 - 08CF␊
1951-␉// 08D0 - 08DF␉␊
1952-␉// 08E0 - 08EF␉␉␉␊
1953+␉// 08D0 - 08DF␊
1954+␉// 08E0 - 08EF␊
1955 ␉// 08F0 - 08FF␊
1956 ␉// 0900 - 090F␊
1957 ␉// 0910 - 091F␊
1958@@ -716,63 +1472,74 @@␊
1959 ␉// 09A0 - 09AF␊
1960 ␉// 09B0 - 09BF␊
1961 ␉// 09C0 - 09CF␊
1962-␉// 09D0 - 09DF␉␊
1963+␉// 09D0 - 09DF␊
1964 ␉// 09E0 - 09EF␊
1965 ␉// 09F0 - 09FF␊
1966 ␉// 0A00 - 0A0F␊
1967+␉// { 0x10DE0A00,␉NV_SUB_IDS,␉"NVIDIA GT212" },␊
1968 ␉// 0A10 - 0A1F␊
1969+␉// { 0x10DE0A10,␉NV_SUB_IDS,␉"NVIDIA GT212" },␊
1970 ␉// 0A20 - 0A2F␊
1971-␉{ 0x10DE0A20, "GeForce GT220" },␊
1972-␉{ 0x10DE0A22, "GeForce 315" },␊
1973-␉{ 0x10DE0A23, "GeForce 210" },␊
1974-␉{ 0x10DE0A26, "GeForce 405" }, ␊
1975-␉{ 0x10DE0A27, "GeForce 405" }, ␊
1976-␉{ 0x10DE0A28, "GeForce GT 230M" },␊
1977-␉{ 0x10DE0A29, "GeForce GT 330M" },␊
1978-␉{ 0x10DE0A2A, "GeForce GT 230M" },␊
1979-␉{ 0x10DE0A2B, "GeForce GT 330M" },␊
1980-␉{ 0x10DE0A2C, "NVS 5100M" },␊
1981-␉{ 0x10DE0A2D, "GeForce GT 320M" },␉␊
1982-␉// 0A30 - 0A3F␉␊
1983-␉{ 0x10DE0A32,␉"GeForce GT 415" },␊
1984-␉{ 0x10DE0A34,␉"GeForce GT 240M" },␊
1985-␉{ 0x10DE0A35,␉"GeForce GT 325M" },␊
1986-␉{ 0x10DE0A38,␉"Quadro 400" },␊
1987-␉{ 0x10DE0A3C,␉"Quadro FX 880M" },␊
1988+␉{ 0x10DE0A20,␉NV_SUB_IDS,␉"GeForce GT 220" },␊
1989+␉// { 0x10DE0A21,␉NV_SUB_IDS,␉"NVIDIA D10M2-20" },␊
1990+␉{ 0x10DE0A22,␉NV_SUB_IDS,␉"GeForce 315" },␊
1991+␉{ 0x10DE0A23,␉NV_SUB_IDS,␉"GeForce 210" },␊
1992+␉{ 0x10DE0A26,␉NV_SUB_IDS,␉"GeForce 405" },␊
1993+␉{ 0x10DE0A27,␉NV_SUB_IDS,␉"GeForce 405" },␊
1994+␉{ 0x10DE0A28,␉NV_SUB_IDS,␉"GeForce GT 230M" },␊
1995+␉{ 0x10DE0A29,␉NV_SUB_IDS,␉"GeForce GT 330M" },␊
1996+␉{ 0x10DE0A2A,␉NV_SUB_IDS,␉"GeForce GT 230M" },␊
1997+␉{ 0x10DE0A2B,␉NV_SUB_IDS,␉"GeForce GT 330M" },␊
1998+␉{ 0x10DE0A2C,␉NV_SUB_IDS,␉"NVS 5100M" },␊
1999+␉{ 0x10DE0A2D,␉NV_SUB_IDS,␉"GeForce GT 320M" },␉␊
2000+␉// 0A30 - 0A3F␊
2001+␉// { 0x10DE0A30,␉NV_SUB_IDS,␉"NVIDIA GT216" },␊
2002+␉{ 0x10DE0A32,␉NV_SUB_IDS,␉"GeForce GT 415" },␊
2003+␉{ 0x10DE0A34,␉NV_SUB_IDS,␉"GeForce GT 240M" },␊
2004+␉{ 0x10DE0A35,␉NV_SUB_IDS,␉"GeForce GT 325M" },␊
2005+␉{ 0x10DE0A38,␉NV_SUB_IDS,␉"Quadro 400" },␊
2006+␉{ 0x10DE0A3C,␉NV_SUB_IDS,␉"Quadro FX 880M" },␊
2007+␉// { 0x10DE0A3D,␉NV_SUB_IDS,␉"NVIDIA N10P-ES" },␊
2008+␉// { 0x10DE0A3F,␉NV_SUB_IDS,␉"NVIDIA GT216-INT" },␊
2009 ␉// 0A40 - 0A4F␊
2010 ␉// 0A50 - 0A5F␊
2011 ␉// 0A60 - 0A6F␊
2012-␉{ 0x10DE0A60, "GeForce G210" },␊
2013-␉{ 0x10DE0A62, "GeForce 205" },␊
2014-␉{ 0x10DE0A63, "GeForce 310" },␊
2015-␉{ 0x10DE0A64, "ION" },␊
2016-␉{ 0x10DE0A65, "GeForce 210" },␊
2017-␉{ 0x10DE0A66, "GeForce 310" },␊
2018-␉{ 0x10DE0A67, "GeForce 315" },␊
2019-␉{ 0x10DE0A68, "GeForce G105M" },␊
2020-␉{ 0x10DE0A69, "GeForce G105M" },␊
2021-␉{ 0x10DE0A6A, "NVS 2100M" },␊
2022-␉{ 0x10DE0A6C, "NVS 3100M" },␊
2023-␉{ 0x10DE0A6E, "GeForce 305M" },␊
2024-␉{ 0x10DE0A6F, "ION" },␉␊
2025+␉{ 0x10DE0A60,␉NV_SUB_IDS,␉"GeForce G210" },␊
2026+␉// { 0x10DE0A61,␉NV_SUB_IDS,␉"NVIDIA NVS 2100" },␊
2027+␉{ 0x10DE0A62,␉NV_SUB_IDS,␉"GeForce 205" },␊
2028+␉{ 0x10DE0A63,␉NV_SUB_IDS,␉"GeForce 310" },␊
2029+␉{ 0x10DE0A64,␉NV_SUB_IDS,␉"ION" },␊
2030+␉{ 0x10DE0A65,␉NV_SUB_IDS,␉"GeForce 210" },␊
2031+␉{ 0x10DE0A66,␉NV_SUB_IDS,␉"GeForce 310" },␊
2032+␉{ 0x10DE0A67,␉NV_SUB_IDS,␉"GeForce 315" },␊
2033+␉{ 0x10DE0A68,␉NV_SUB_IDS,␉"GeForce G105M" },␊
2034+␉{ 0x10DE0A69,␉NV_SUB_IDS,␉"GeForce G105M" },␊
2035+␉{ 0x10DE0A6A,␉NV_SUB_IDS,␉"NVS 2100M" },␊
2036+␉{ 0x10DE0A6C,␉NV_SUB_IDS,␉"NVS 3100M" },␊
2037+␉{ 0x10DE0A6E,␉NV_SUB_IDS,␉"GeForce 305M" },␊
2038+␉{ 0x10DE0A6F,␉NV_SUB_IDS,␉"ION" },␉␊
2039 ␉// 0A70 - 0A7F␊
2040-␉{ 0x10DE0A70, "GeForce 310M" },␊
2041-␉{ 0x10DE0A71, "GeForce 305M" },␊
2042-␉{ 0x10DE0A72, "GeForce 310M" },␊
2043-␉{ 0x10DE0A73, "GeForce 305M" },␊
2044-␉{ 0x10DE0A74, "GeForce G210M" },␊
2045-␉{ 0x10DE0A75, "GeForce G310M" },␊
2046-␉{ 0x10DE0A76, "ION" }, ␊
2047-␉{ 0x10DE0A78, "Quadro FX 380 LP" },␊
2048-␉{ 0x10DE0A7A, "GeForce 315M" },␊
2049- ␉{ 0x10DE0A7B,␉"GeForce 505" },␊
2050-␉{ 0x10DE0A7C, "Quadro FX 380M" },␊
2051+␉{ 0x10DE0A70,␉NV_SUB_IDS,␉"GeForce 310M" },␊
2052+␉{ 0x10DE0A71,␉NV_SUB_IDS,␉"GeForce 305M" },␊
2053+␉{ 0x10DE0A72,␉NV_SUB_IDS,␉"GeForce 310M" },␊
2054+␉{ 0x10DE0A73,␉NV_SUB_IDS,␉"GeForce 305M" },␊
2055+␉{ 0x10DE0A74,␉NV_SUB_IDS,␉"GeForce G210M" },␊
2056+␉{ 0x10DE0A75,␉NV_SUB_IDS,␉"GeForce G310M" },␊
2057+␉{ 0x10DE0A76,␉NV_SUB_IDS,␉"ION" },␊
2058+␉{ 0x10DE0A78,␉NV_SUB_IDS,␉"Quadro FX 380 LP" },␊
2059+␉// { 0x10DE0A79,␉NV_SUB_IDS,␉"N12M-NS-S" },␊
2060+␉{ 0x10DE0A7A,␉NV_SUB_IDS,␉"GeForce 315M" },␊
2061+␉{ 0x10DE0A7B,␉NV_SUB_IDS,␉"GeForce 505" },␊
2062+␉{ 0x10DE0A7C,␉NV_SUB_IDS,␉"Quadro FX 380M" },␊
2063+␉// { 0x10DE0A7D,␉NV_SUB_IDS,␉"NVIDIA GT218-ES" },␊
2064+␉// { 0x10DE0A7E,␉NV_SUB_IDS,␉"NVIDIA GT218-INT-S" },␊
2065+␉// { 0x10DE0A7F,␉NV_SUB_IDS,␉"NVIDIA GT218-INT-B" },␊
2066 ␉// 0A80 - 0A8F␊
2067 ␉// 0A90 - 0A9F␊
2068 ␉// 0AA0 - 0AAF␊
2069 ␉// 0AB0 - 0ABF␊
2070 ␉// 0AC0 - 0ACF␊
2071-␉// 0AD0 - 0ADF␉␊
2072+␉// 0AD0 - 0ADF␊
2073 ␉// 0AE0 - 0AEF␊
2074 ␉// 0AF0 - 0AFF␊
2075 ␉// 0B00 - 0B0F␊
2076@@ -788,7 +1555,7 @@␊
2077 ␉// 0BA0 - 0BAF␊
2078 ␉// 0BB0 - 0BBF␊
2079 ␉// 0BC0 - 0BCF␊
2080-␉// 0BD0 - 0BDF␉␊
2081+␉// 0BD0 - 0BDF␊
2082 ␉// 0BE0 - 0BEF␊
2083 ␉// 0BF0 - 0BFF␊
2084 ␉// 0C00 - 0C0F␊
2085@@ -802,22 +1569,24 @@␊
2086 ␉// 0C80 - 0C8F␊
2087 ␉// 0C90 - 0C9F␊
2088 ␉// 0CA0 - 0CAF␊
2089-␉{ 0x10DE0CA0, "GeForce GT 330 " },␊
2090-␉{ 0x10DE0CA2, "GeForce GT 320" },␊
2091-␉{ 0x10DE0CA3, "GeForce GT 240" },␊
2092-␉{ 0x10DE0CA4, "GeForce GT 340" },␊
2093-␉{ 0x10DE0CA5, "GeForce GT 220" }, ␊
2094-␉{ 0x10DE0CA7, "GeForce GT 330" },␊
2095-␉{ 0x10DE0CA8, "GeForce GTS 260M" },␊
2096-␉{ 0x10DE0CA9, "GeForce GTS 250M" },␊
2097-␉{ 0x10DE0CAC, "GeForce GT 220" }, ␊
2098-␉{ 0x10DE0CAF, "GeForce GT 335M" },␊
2099+␉{ 0x10DE0CA0,␉NV_SUB_IDS,␉"GeForce GT 330 " },␊
2100+␉{ 0x10DE0CA2,␉NV_SUB_IDS,␉"GeForce GT 320" },␊
2101+␉{ 0x10DE0CA3,␉NV_SUB_IDS,␉"GeForce GT 240" },␊
2102+␉{ 0x10DE0CA4,␉NV_SUB_IDS,␉"GeForce GT 340" },␊
2103+␉{ 0x10DE0CA5,␉NV_SUB_IDS,␉"GeForce GT 220" },␊
2104+␉{ 0x10DE0CA7,␉NV_SUB_IDS,␉"GeForce GT 330" },␊
2105+␉{ 0x10DE0CA8,␉NV_SUB_IDS,␉"GeForce GTS 260M" },␊
2106+␉{ 0x10DE0CA9,␉NV_SUB_IDS,␉"GeForce GTS 250M" },␊
2107+␉{ 0x10DE0CAC,␉NV_SUB_IDS,␉"GeForce GT 220" },␊
2108+␉// { 0x10DE0CAD,␉NV_SUB_IDS,␉"NVIDIA N10E-ES" },␊
2109+␉// { 0x10DE0CAE,␉NV_SUB_IDS,␉"NVIDIA GT215-INT" },␊
2110+␉{ 0x10DE0CAF,␉NV_SUB_IDS,␉"GeForce GT 335M" },␊
2111 ␉// 0CB0 - 0CBF␉␊
2112-␉{ 0x10DE0CB0, "GeForce GTS 350M" },␊
2113-␉{ 0x10DE0CB1, "GeForce GTS 360M" },␊
2114-␉{ 0x10DE0CBC, "Quadro FX 1800M" },␊
2115+␉{ 0x10DE0CB0,␉NV_SUB_IDS,␉"GeForce GTS 350M" },␊
2116+␉{ 0x10DE0CB1,␉NV_SUB_IDS,␉"GeForce GTS 360M" },␊
2117+␉{ 0x10DE0CBC,␉NV_SUB_IDS,␉"Quadro FX 1800M" },␊
2118 ␉// 0CC0 - 0CCF␊
2119-␉// 0CD0 - 0CDF␉␊
2120+␉// 0CD0 - 0CDF␊
2121 ␉// 0CE0 - 0CEF␊
2122 ␉// 0CF0 - 0CFF␊
2123 ␉// 0D00 - 0D0F␊
2124@@ -830,73 +1599,78 @@␊
2125 ␉// 0D70 - 0D7F␊
2126 ␉// 0D80 - 0D8F␊
2127 ␉// 0D90 - 0D9F␊
2128-␉// 0DA0 - 0DAF␉␊
2129+␉// 0DA0 - 0DAF␊
2130 ␉// 0DB0 - 0DBF␊
2131 ␉// 0DC0 - 0DCF␊
2132-␉{ 0x10DE0DC0, "GeForce GT 440" },␊
2133-␉{ 0x10DE0DC1, "D12-P1-35" },␊
2134-␉{ 0x10DE0DC2, "D12-P1-35" },␊
2135-␉{ 0x10DE0DC4, "GeForce GTS 450" },␊
2136-␉{ 0x10DE0DC5, "GeForce GTS 450" },␊
2137-␉{ 0x10DE0DC6, "GeForce GTS 450" },␊
2138-␉{ 0x10DE0DCA, "GF10x" },␊
2139-␉{ 0x10DE0DCD, "GeForce GT 555M" }, ␊
2140-␉{ 0x10DE0DCE, "GeForce GT 555M" }, ␊
2141+␉{ 0x10DE0DC0,␉NV_SUB_IDS,␉"GeForce GT 440" },␊
2142+␉// { 0x10DE0DC1,␉NV_SUB_IDS,␉"D12-P1-35" },␊
2143+␉// { 0x10DE0DC2,␉NV_SUB_IDS,␉"D12-P1-35" },␊
2144+␉{ 0x10DE0DC4,␉NV_SUB_IDS,␉"GeForce GTS 450" },␊
2145+␉{ 0x10DE0DC5,␉NV_SUB_IDS,␉"GeForce GTS 450" },␊
2146+␉{ 0x10DE0DC6,␉NV_SUB_IDS,␉"GeForce GTS 450" },␊
2147+␉// { 0x10DE0DCA,␉NV_SUB_IDS,␉"GF10x" },␊
2148+␉// { 0x10DE0DCC,␉NV_SUB_IDS,␉"N12E-GS" },␊
2149+␉{ 0x10DE0DCD,␉NV_SUB_IDS,␉"GeForce GT 555M" },␊
2150+␉{ 0x10DE0DCE,␉NV_SUB_IDS,␉"GeForce GT 555M" },␊
2151+␉// { 0x10DE0DCF,␉NV_SUB_IDS,␉"N12P-GT-B" },␊
2152 ␉// 0DD0 - 0DDF␉␊
2153-␉{ 0x10DE0DD1, "GeForce GTX 460M" },␊
2154-␉{ 0x10DE0DD2, "GeForce GT 445M" },␊
2155-␉{ 0x10DE0DD3, "GeForce GT 435M" },␊
2156-␉{ 0x10DE0DD6, "GeForce GT 550M" }, ␊
2157-␉{ 0x10DE0DD8, "Quadro 2000" },␊
2158-␉{ 0x10DE0DDA, "Quadro 2000M" }, ␊
2159-␉{ 0x10DE0DDE, "GF106-ES" },␊
2160-␉{ 0x10DE0DDF, "GF106-INT" },␊
2161-␉// 0DE0 - 0DEF␉␊
2162-␉{ 0x10DE0DE0,␉"GeForce GT 440" },␊
2163-␉{ 0x10DE0DE1,␉"GeForce GT 430" },␊
2164-␉{ 0x10DE0DE2,␉"GeForce GT 420" },␊
2165-␉{ 0x10DE0DE4,␉"GeForce GT 520" },␊
2166-␉{ 0x10DE0DE5,␉"GeForce GT 530" },␊
2167-␉{ 0x10DE0DE8,␉"GeForce GT 620M" },␊
2168-␉{ 0x10DE0DE9,␉"GeForce GT 630M" },␊
2169-␉{ 0x10DE0DEA,␉"GeForce GT 610M" },␊
2170-␉{ 0x10DE0DEB,␉"GeForce GT 555M" },␊
2171-␉{ 0x10DE0DEC,␉"GeForce GT 525M" },␊
2172-␉{ 0x10DE0DED,␉"GeForce GT 520M" },␊
2173-␉{ 0x10DE0DEE,␉"GeForce GT 415M" },␊
2174-␊
2175-␉// 0DF0 - 0DFF␉␊
2176-␉{ 0x10DE0DF0, "GeForce GT 425M" },␊
2177-␉{ 0x10DE0DF1, "GeForce GT 420M" },␊
2178-␉{ 0x10DE0DF2, "GeForce GT 435M" },␊
2179-␉{ 0x10DE0DF3, "GeForce GT 420M" },␊
2180-␉{ 0x10DE0DF4, "GeForce GT 540M" }, ␊
2181-␉{ 0x10DE0DF5, "GeForce GT 525M" }, ␊
2182-␉{ 0x10DE0DF6, "GeForce GT 550M" }, ␊
2183-␉{ 0x10DE0DF7, "GeForce GT 520M" }, ␊
2184-␉{ 0x10DE0DF8, "Quadro 600" },␊
2185- ␉{ 0x10DE0DF9,␉"Quadro 500M" },␊
2186-␉{ 0x10DE0DFA, "Quadro 1000M" }, ␊
2187-␉{ 0x10DE0DFE, "GF108 ES" },␊
2188-␉{ 0x10DE0DFF, "GF108 INT" },␊
2189+␉// { 0x10DE0DD0,␉NV_SUB_IDS,␉"N11E-GT" },␊
2190+␉{ 0x10DE0DD1,␉NV_SUB_IDS,␉"GeForce GTX 460M" },␊
2191+␉{ 0x10DE0DD2,␉NV_SUB_IDS,␉"GeForce GT 445M" },␊
2192+␉{ 0x10DE0DD3,␉NV_SUB_IDS,␉"GeForce GT 435M" },␊
2193+␉{ 0x10DE0DD6,␉NV_SUB_IDS,␉"GeForce GT 550M" },␊
2194+␉{ 0x10DE0DD8,␉NV_SUB_IDS,␉"Quadro 2000" },␊
2195+␉{ 0x10DE0DDA,␉NV_SUB_IDS,␉"Quadro 2000M" },␊
2196+␉// { 0x10DE0DDE,␉NV_SUB_IDS,␉"GF106-ES" },␊
2197+␉// { 0x10DE0DDF,␉NV_SUB_IDS,␉"GF106-INT" },␊
2198+␉// 0DE0 - 0DEF␊
2199+␉{ 0x10DE0DE0,␉NV_SUB_IDS,␉"GeForce GT 440" },␊
2200+␉{ 0x10DE0DE1,␉NV_SUB_IDS,␉"GeForce GT 430" },␊
2201+␉{ 0x10DE0DE2,␉NV_SUB_IDS,␉"GeForce GT 420" },␊
2202+␉{ 0x10DE0DE4,␉NV_SUB_IDS,␉"GeForce GT 520" },␊
2203+␉{ 0x10DE0DE5,␉NV_SUB_IDS,␉"GeForce GT 530" },␊
2204+␉{ 0x10DE0DE8,␉NV_SUB_IDS,␉"GeForce GT 620M" },␊
2205+␉{ 0x10DE0DE9,␉NV_SUB_IDS,␉"GeForce GT 630M" },␊
2206+␉{ 0x10DE0DEA,␉NV_SUB_IDS,␉"GeForce GT 610M" },␊
2207+␉{ 0x10DE0DEB,␉NV_SUB_IDS,␉"GeForce GT 555M" },␊
2208+␉{ 0x10DE0DEC,␉NV_SUB_IDS,␉"GeForce GT 525M" },␊
2209+␉{ 0x10DE0DED,␉NV_SUB_IDS,␉"GeForce GT 520M" },␊
2210+␉{ 0x10DE0DEE,␉NV_SUB_IDS,␉"GeForce GT 415M" },␊
2211+␉// { 0x10DE0DEF,␉NV_SUB_IDS,␉"N13P-NS1-A1" },␊
2212+␉// 0DF0 - 0DFF␊
2213+␉{ 0x10DE0DF0,␉NV_SUB_IDS,␉"GeForce GT 425M" },␊
2214+␉{ 0x10DE0DF1,␉NV_SUB_IDS,␉"GeForce GT 420M" },␊
2215+␉{ 0x10DE0DF2,␉NV_SUB_IDS,␉"GeForce GT 435M" },␊
2216+␉{ 0x10DE0DF3,␉NV_SUB_IDS,␉"GeForce GT 420M" },␊
2217+␉{ 0x10DE0DF4,␉NV_SUB_IDS,␉"GeForce GT 540M" },␊
2218+␉{ 0x10DE0DF5,␉NV_SUB_IDS,␉"GeForce GT 525M" },␊
2219+␉{ 0x10DE0DF6,␉NV_SUB_IDS,␉"GeForce GT 550M" },␊
2220+␉{ 0x10DE0DF7,␉NV_SUB_IDS,␉"GeForce GT 520M" },␊
2221+␉{ 0x10DE0DF8,␉NV_SUB_IDS,␉"Quadro 600" },␊
2222+␉{ 0x10DE0DF9,␉NV_SUB_IDS,␉"Quadro 500M" },␊
2223+␉{ 0x10DE0DFA,␉NV_SUB_IDS,␉"Quadro 1000M" },␊
2224+␉{ 0x10DE0DFC,␉NV_SUB_IDS,␉"NVS 5200M" },␊
2225+␉// { 0x10DE0DFE,␉NV_SUB_IDS,␉"GF108 ES" },␊
2226+␉// { 0x10DE0DFF,␉NV_SUB_IDS,␉"GF108 INT" },␊
2227 ␉// 0E00 - 0E0F␊
2228 ␉// 0E10 - 0E1F␊
2229 ␉// 0E20 - 0E2F␊
2230-␉{ 0x10DE0E21, "D12U-25" },␊
2231-␉{ 0x10DE0E22, "GeForce GTX 460" },␊
2232-␉{ 0x10DE0E23, "GeForce GTX 460 SE" },␊
2233-␉{ 0x10DE0E24, "GeForce GTX 460" },␊
2234-␉{ 0x10DE0E25, "D12U-50" },␊
2235- ␉{ 0x10DE0E28,␉"GeForce GTX 460" },␊
2236-␉// 0E30 - 0E3F␉␊
2237-␉{ 0x10DE0E30, "GeForce GTX 470M" },␊
2238-␉{ 0x10DE0E31, "GeForce GTX 485M" }, ␊
2239-␉{ 0x10DE0E38, "GF104GL" },␊
2240-␉{ 0x10DE0E3A, "Quadro 3000M" }, ␊
2241-␉{ 0x10DE0E3B, "Quadro 4000M" }, ␊
2242-␉{ 0x10DE0E3E, "GF104-ES" },␊
2243-␉{ 0x10DE0E3F, "GF104-INT" },␊
2244-␉// 0E40 - 0E4F␉␊
2245+␉{ 0x10DE0E21,␉NV_SUB_IDS,␉"D12U-25" },␊
2246+␉{ 0x10DE0E22,␉NV_SUB_IDS,␉"GeForce GTX 460" },␊
2247+␉{ 0x10DE0E23,␉NV_SUB_IDS,␉"GeForce GTX 460 SE" },␊
2248+␉{ 0x10DE0E24,␉NV_SUB_IDS,␉"GeForce GTX 460" },␊
2249+␉// { 0x10DE0E25,␉NV_SUB_IDS,␉"D12U-50" },␊
2250+␉{ 0x10DE0E28,␉NV_SUB_IDS,␉"GeForce GTX 460" },␊
2251+␉// 0E30 - 0E3F␊
2252+␉{ 0x10DE0E30,␉NV_SUB_IDS,␉"GeForce GTX 470M" },␊
2253+␉{ 0x10DE0E31,␉NV_SUB_IDS,␉"GeForce GTX 485M" },␊
2254+␉// { 0x10DE0E32,␉NV_SUB_IDS,␉"N12E-GT" },␊
2255+␉{ 0x10DE0E38,␉NV_SUB_IDS,␉"GF104GL" },␊
2256+␉{ 0x10DE0E3A,␉NV_SUB_IDS,␉"Quadro 3000M" },␊
2257+␉{ 0x10DE0E3B,␉NV_SUB_IDS,␉"Quadro 4000M" },␊
2258+␉// { 0x10DE0E3E,␉NV_SUB_IDS,␉"GF104-ES" },␊
2259+␉// { 0x10DE0E3F,␉NV_SUB_IDS,␉"GF104-INT" },␊
2260+␉// 0E40 - 0E4F␊
2261 ␉// 0E50 - 0E5F␊
2262 ␉// 0E60 - 0E6F␊
2263 ␉// 0E70 - 0E7F␊
2264@@ -905,7 +1679,7 @@␊
2265 ␉// 0EA0 - 0EAF␊
2266 ␉// 0EB0 - 0EBF␊
2267 ␉// 0EC0 - 0ECF␊
2268-␉// 0ED0 - 0EDF␉␊
2269+␉// 0ED0 - 0EDF␊
2270 ␉// 0EE0 - 0EEF␊
2271 ␉// 0EF0 - 0EFF␊
2272 ␉// 0F00 - 0F0F␊
2273@@ -922,9 +1696,10 @@␊
2274 ␉// 0FB0 - 0FBF␊
2275 ␉// 0FC0 - 0FCF␊
2276 ␉// 0FD0 - 0FDF␊
2277- { 0x10DE0FD1,␉"GeForce GT 650M" },␊
2278-␉{ 0x10DE0FD2,␉"GeForce GT 640M" },␊
2279-␉{ 0x10DE0FD4,␉"GeForce GTX 660M" },␊
2280+␉{ 0x10DE0FD1,␉NV_SUB_IDS,␉"GeForce GT 650M" },␊
2281+␉{ 0x10DE0FD2,␉NV_SUB_IDS,␉"GeForce GT 640M" },␊
2282+␉{ 0x10DE0FD4,␉NV_SUB_IDS,␉"GeForce GTX 660M" },␊
2283+␉// { 0x10DE0FDB,␉NV_SUB_IDS,␉"GK107-ESP-A1" },␊
2284 ␉// 0FE0 - 0FEF␊
2285 ␉// 0FF0 - 0FFF␊
2286 ␉// 1000 - 100F␊
2287@@ -932,77 +1707,81 @@␊
2288 ␉// 1020 - 102F␊
2289 ␉// 1030 - 103F␊
2290 ␉// 1040 - 104F␊
2291-␉{ 0x10DE1040, "GeForce GT 520" },␊
2292- { 0x10DE1042,␉"GeForce 510" },␊
2293-␉{ 0x10DE1048,␉"GeForce 605" },␊
2294-␉{ 0x10DE1049,␉"GeForce GT 620" },␊
2295+␉{ 0x10DE1040,␉NV_SUB_IDS,␉"GeForce GT 520" },␊
2296+␉// { 0x10DE1041,␉NV_SUB_IDS,␉"D13M1-45" },␊
2297+␉{ 0x10DE1042,␉NV_SUB_IDS,␉"GeForce 510" },␊
2298+␉{ 0x10DE1048,␉NV_SUB_IDS,␉"GeForce 605" },␊
2299+␉{ 0x10DE1049,␉NV_SUB_IDS,␉"GeForce GT 620" },␊
2300 ␉// 1050 - 105F␊
2301-␉{ 0x10DE1050,␉"GeForce GT 520M" },␊
2302-␉{ 0x10DE1051,␉"GeForce GT 520MX" },␊
2303-␉{ 0x10DE1052,␉"GeForce GT 520M" },␊
2304-␉{ 0x10DE1054,␉"GeForce GT 410M" },␊
2305-␉{ 0x10DE1055,␉"GeForce 410M" },␊
2306-␉{ 0x10DE1056,␉"Quadro NVS 4200M" },␊
2307-␉{ 0x10DE1057,␉"Quadro NVS 4200M" },␊
2308-␉{ 0x10DE1058,␉"GeForce 610M" },␊
2309-␉{ 0x10DE1059,␉"GeForce 610M" },␊
2310-␉{ 0x10DE105A,␉"GeForce 610M" },␊
2311+␉{ 0x10DE1050,␉NV_SUB_IDS,␉"GeForce GT 520M" },␊
2312+␉{ 0x10DE1051,␉NV_SUB_IDS,␉"GeForce GT 520MX" },␊
2313+␉{ 0x10DE1052,␉NV_SUB_IDS,␉"GeForce GT 520M" },␊
2314+␉{ 0x10DE1054,␉NV_SUB_IDS,␉"GeForce GT 410M" },␊
2315+␉{ 0x10DE1055,␉NV_SUB_IDS,␉"GeForce 410M" },␊
2316+␉{ 0x10DE1056,␉NV_SUB_IDS,␉"Quadro NVS 4200M" },␊
2317+␉{ 0x10DE1057,␉NV_SUB_IDS,␉"Quadro NVS 4200M" },␊
2318+␉{ 0x10DE1058,␉NV_SUB_IDS,␉"GeForce 610M" },␊
2319+␉{ 0x10DE1059,␉NV_SUB_IDS,␉"GeForce 610M" },␊
2320+␉{ 0x10DE105A,␉NV_SUB_IDS,␉"GeForce 610M" },␊
2321 ␉// 1060 - 106F␊
2322 ␉// 1070 - 107F␊
2323-␉{ 0x10DE107F, "NVIDIA GF119-ES" }, ␊
2324+␉// { 0x10DE107D,␉NV_SUB_IDS,␉"GF119" },␊
2325+␉// { 0x10DE107E,␉NV_SUB_IDS,␉"GF119-INT" },␊
2326+␉// { 0x10DE107F,␉NV_SUB_IDS,␉"GF119-ES" },␊
2327 ␉// 1080 - 108F␊
2328-␉{ 0x10DE1080, "GeForce GTX 580" },␊
2329-␉{ 0x10DE1081, "GeForce GTX 570" },␊
2330-␉{ 0x10DE1082, "GeForce GTX 560 Ti" },␊
2331-␉{ 0x10DE1083, "D13U" },␊
2332-␉{ 0x10DE1084, "GeForce GTX 560" }, ␊
2333-␉{ 0x10DE1086, "GeForce GTX 570" }, ␊
2334-␉{ 0x10DE1087, "GeForce GTX 560 Ti-448" }, ␊
2335-␉{ 0x10DE1088, "GeForce GTX 590" },␊
2336-␉{ 0x10DE1089, "GeForce GTX 580" }, ␊
2337-␉{ 0x10DE108B, "GeForce GTX 590" },␊
2338- ␉{ 0x10DE108E,␉"Tesla C2090" },␊
2339-␉// 1090 - 109F␉␊
2340-␉{ 0x10DE1091, "Tesla M2090" },␊
2341- { 0x10DE1094,␉"Tesla M2075 Dual-Slot Computing Processor Module" },␊
2342-␉{ 0x10DE1096,␉"Tesla C2075" },␊
2343-␉{ 0x10DE1098, "D13U" },␊
2344-␉{ 0x10DE109A, "Quadro 5010M" }, ␊
2345-␉{ 0x10DE109B, "Quadro 7000" }, ␊
2346+␉{ 0x10DE1080,␉NV_SUB_IDS,␉"GeForce GTX 580" },␊
2347+␉{ 0x10DE1081,␉NV_SUB_IDS,␉"GeForce GTX 570" },␊
2348+␉{ 0x10DE1082,␉NV_SUB_IDS,␉"GeForce GTX 560 Ti" },␊
2349+␉{ 0x10DE1083,␉NV_SUB_IDS,␉"D13U" },␊
2350+␉{ 0x10DE1084,␉NV_SUB_IDS,␉"GeForce GTX 560" },␊
2351+␉{ 0x10DE1086,␉NV_SUB_IDS,␉"GeForce GTX 570" },␊
2352+␉{ 0x10DE1087,␉NV_SUB_IDS,␉"GeForce GTX 560 Ti-448" },␊
2353+␉{ 0x10DE1088,␉NV_SUB_IDS,␉"GeForce GTX 590" },␊
2354+␉{ 0x10DE1089,␉NV_SUB_IDS,␉"GeForce GTX 580" },␊
2355+␉{ 0x10DE108B,␉NV_SUB_IDS,␉"GeForce GTX 590" },␊
2356+␉// { 0x10DE108C,␉NV_SUB_IDS,␉"D13U" },␊
2357+␉{ 0x10DE108E,␉NV_SUB_IDS,␉"Tesla C2090" },␊
2358+␉// 1090 - 109F␊
2359+␉{ 0x10DE1091,␉NV_SUB_IDS,␉"nVidia Tesla M2090" },␊
2360+␉{ 0x10DE1094,␉NV_SUB_IDS,␉"Tesla M2075 Dual-Slot Computing Processor Module" },␊
2361+␉{ 0x10DE1096,␉NV_SUB_IDS,␉"Tesla C2075" },␊
2362+␉// { 0x10DE1098,␉NV_SUB_IDS,␉"D13U" },␊
2363+␉{ 0x10DE109A,␉NV_SUB_IDS,␉"Quadro 5010M" },␊
2364+␉{ 0x10DE109B,␉NV_SUB_IDS,␉"Quadro 7000" },␊
2365 ␉// 10A0 - 10AF␊
2366 ␉// 10B0 - 10BF␊
2367 ␉// 10C0 - 10CF␊
2368-␉{ 0x10DE10C0, "GeForce 9300 GS" }, ␊
2369-␉{ 0x10DE10C3, "GeForce 8400 GS" },␊
2370- ␉{ 0x10DE10C4,␉"NVIDIA ION" },␊
2371-␉{ 0x10DE10C5, "GeForce 405" }, ␊
2372+␉{ 0x10DE10C0,␉NV_SUB_IDS,␉"GeForce 9300 GS" },␊
2373+␉{ 0x10DE10C3,␉NV_SUB_IDS,␉"GeForce 8400 GS" },␊
2374+␉{ 0x10DE10C4,␉NV_SUB_IDS,␉"NVIDIA ION" },␊
2375+␉{ 0x10DE10C5,␉NV_SUB_IDS,␉"GeForce 405" },␊
2376 ␉// 10D0 - 10DF␊
2377-␉{ 0x10DE10D8, "NVS 300" },␊
2378- // 10E0 - 10EF␊
2379+␉{ 0x10DE10D8,␉NV_SUB_IDS,␉"NVS 300" },␊
2380+␉// 10E0 - 10EF␊
2381 ␉// 10F0 - 10FF␊
2382 ␉// 1100 - 110F␊
2383 ␉// 1110 - 111F␊
2384 ␉// 1120 - 112F␊
2385 ␉// 1130 - 113F␊
2386 ␉// 1140 - 114F␊
2387-␉// { 0x10DE1140,␉"GF117" },␊
2388-␉{ 0x10DE1141,␉"GeForce 610M" },␊
2389-␉{ 0x10DE1142,␉"GeForce 620M" },␊
2390-␉// { 0x10DE1143,␉"N13P-GV" },␊
2391-␉// { 0x10DE1144,␉"GF117" },␊
2392-␉// { 0x10DE1145,␉"GF117" },␊
2393-␉// { 0x10DE1146,␉"GF117" },␊
2394-␉// { 0x10DE1147,␉"GF117" },␊
2395-␉// { 0x10DE1149,␉"GF117-ES" },␊
2396-␉// { 0x10DE114A,␉"GF117-INT" },␊
2397-␉// { 0x10DE114B,␉"PCI-GEN3-B" },␊
2398+␉// { 0x10DE1140,␉NV_SUB_IDS,␉"GF117" },␊
2399+␉{ 0x10DE1141,␉NV_SUB_IDS,␉"GeForce 610M" },␊
2400+␉{ 0x10DE1142,␉NV_SUB_IDS,␉"GeForce 620M" },␊
2401+␉// { 0x10DE1143,␉NV_SUB_IDS,␉"N13P-GV" },␊
2402+␉// { 0x10DE1144,␉NV_SUB_IDS,␉"GF117" },␊
2403+␉// { 0x10DE1145,␉NV_SUB_IDS,␉"GF117" },␊
2404+␉// { 0x10DE1146,␉NV_SUB_IDS,␉"GF117" },␊
2405+␉// { 0x10DE1147,␉NV_SUB_IDS,␉"GF117" },␊
2406+␉// { 0x10DE1149,␉NV_SUB_IDS,␉"GF117-ES" },␊
2407+␉// { 0x10DE114A,␉NV_SUB_IDS,␉"GF117-INT" },␊
2408+␉// { 0x10DE114B,␉NV_SUB_IDS,␉"PCI-GEN3-B" },␊
2409 ␉// 1150 - 115F␊
2410 ␉// 1160 - 116F␊
2411 ␉// 1170 - 117F␊
2412 ␉// 1180 - 118F␊
2413-␉{ 0x10DE1180,␉"GeForce GTX 680" },␊
2414-␉{ 0x10DE1188,␉"GeForce GTX 690" },␊
2415-␉{ 0x10DE1189,␉"GeForce GTX 670" },␊
2416+␉{ 0x10DE1180,␉NV_SUB_IDS,␉"GeForce GTX 680" },␊
2417+␉{ 0x10DE1188,␉NV_SUB_IDS,␉"GeForce GTX 690" },␊
2418+␉{ 0x10DE1189,␉NV_SUB_IDS,␉"GeForce GTX 670" },␊
2419 ␉// 1190 - 119F␊
2420 ␉// 11A0 - 11AF␊
2421 ␉// 11B0 - 11BF␊
2422@@ -1011,29 +1790,29 @@␊
2423 ␉// 11E0 - 11EF␊
2424 ␉// 11F0 - 11FF␊
2425 ␉// 1200 - 120F␊
2426-␉{ 0x10DE1200,␉"GeForce GTX 560 Ti" },␊
2427-␉{ 0x10DE1201,␉"GeForce GTX 560" },␊
2428-␉{ 0x10DE1202,␉"GeForce GTX 560 Ti" },␊
2429-␉{ 0x10DE1203,␉"GeForce GTX 460 SE v2" },␊
2430-␉{ 0x10DE1205,␉"GeForce GTX 460 v2" },␊
2431-␉{ 0x10DE1206,␉"GeForce GTX 555" },␊
2432-␉{ 0x10DE1208,␉"GeForce GTX 560 SE" },␊
2433-␉{ 0x10DE1210,␉"GeForce GTX 570M" },␊
2434-␉{ 0x10DE1211,␉"GeForce GTX 580M" },␊
2435-␉{ 0x10DE1212,␉"GeForce GTX 675M" },␊
2436-␉{ 0x10DE1213,␉"GeForce GTX 670M" },␊
2437-␉{ 0x10DE1240,␉"GeForce GT 620M" },␊
2438-␉{ 0x10DE1241,␉"GeForce GT 545" },␊
2439-␉{ 0x10DE1243,␉"GeForce GT 545" },␊
2440-␉{ 0x10DE1244,␉"GeForce GTX 550 Ti" },␊
2441-␉{ 0x10DE1245,␉"GeForce GTS 450" },␊
2442-␉{ 0x10DE1246,␉"GeForce GTX 550M" },␊
2443-␉{ 0x10DE1247,␉"GeForce GT 635M" }, // Subsystem Id: 1043 212C Asus GeForce GT 635M␊
2444-␉{ 0x10DE1248,␉"GeForce GTX 555M" },␊
2445-␉{ 0x10DE124B,␉"GeForce GT 640" },␊
2446-␉{ 0x10DE124D,␉"GeForce GTX 555M" },␊
2447-␉// { 0x10DE1250,␉"GF116-INT" },␊
2448-␉{ 0x10DE1251,␉"GeForce GTX 560M" },␊
2449+␉{ 0x10DE1200,␉NV_SUB_IDS,␉"GeForce GTX 560 Ti" },␊
2450+␉{ 0x10DE1201,␉NV_SUB_IDS,␉"GeForce GTX 560" },␊
2451+␉{ 0x10DE1202,␉NV_SUB_IDS,␉"GeForce GTX 560 Ti" },␊
2452+␉{ 0x10DE1203,␉NV_SUB_IDS,␉"GeForce GTX 460 SE v2" },␊
2453+␉{ 0x10DE1205,␉NV_SUB_IDS,␉"GeForce GTX 460 v2" },␊
2454+␉{ 0x10DE1206,␉NV_SUB_IDS,␉"GeForce GTX 555" },␊
2455+␉{ 0x10DE1208,␉NV_SUB_IDS,␉"GeForce GTX 560 SE" },␊
2456+␉{ 0x10DE1210,␉NV_SUB_IDS,␉"GeForce GTX 570M" },␊
2457+␉{ 0x10DE1211,␉NV_SUB_IDS,␉"GeForce GTX 580M" },␊
2458+␉{ 0x10DE1212,␉NV_SUB_IDS,␉"GeForce GTX 675M" },␊
2459+␉{ 0x10DE1213,␉NV_SUB_IDS,␉"GeForce GTX 670M" },␊
2460+␉{ 0x10DE1240,␉NV_SUB_IDS,␉"GeForce GT 620M" },␊
2461+␉{ 0x10DE1241,␉NV_SUB_IDS,␉"GeForce GT 545" },␊
2462+␉{ 0x10DE1243,␉NV_SUB_IDS,␉"GeForce GT 545" },␊
2463+␉{ 0x10DE1244,␉NV_SUB_IDS,␉"GeForce GTX 550 Ti" },␊
2464+␉{ 0x10DE1245,␉NV_SUB_IDS,␉"GeForce GTS 450" },␊
2465+␉{ 0x10DE1246,␉NV_SUB_IDS,␉"GeForce GTX 550M" },␊
2466+␉{ 0x10DE1247,␉NV_SUB_IDS,␉"GeForce GT 635M" },␊
2467+␉{ 0x10DE1248,␉NV_SUB_IDS,␉"GeForce GTX 555M" },␊
2468+␉{ 0x10DE124B,␉NV_SUB_IDS,␉"GeForce GT 640" },␊
2469+␉{ 0x10DE124D,␉NV_SUB_IDS,␉"GeForce GTX 555M" },␊
2470+␉// { 0x10DE1250,␉NV_SUB_IDS,␉"GF116-INT" },␊
2471+␉{ 0x10DE1251,␉NV_SUB_IDS,␉"GeForce GTX 560M" },␊
2472 ␉// 1260 - 126F␊
2473 ␉// 1270 - 127F␊
2474 ␉// 1280 - 128F␊
2475@@ -1044,11 +1823,8 @@␊
2476 ␉// 12D0 - 12DF␊
2477 ␉// 12E0 - 12EF␊
2478 ␉// 12F0 - 12FF␊
2479-␊
2480 };␊
2481 ␊
2482-␊
2483-␊
2484 static int patch_nvidia_rom(uint8_t *rom)␊
2485 {␊
2486 ␉if (!rom || (rom[0] != 0x55 && rom[1] != 0xaa)) {␊
2487@@ -1064,7 +1840,7 @@␊
2488 ␉}␊
2489 //␉else␊
2490 //␉␉printf("dcb table at offset 0x%04x\n", dcbptr);␊
2491-␉ ␊
2492+␊
2493 ␉uint8_t *dcbtable␉␉ = &rom[dcbptr];␊
2494 ␉uint8_t dcbtable_version = dcbtable[0];␊
2495 ␉uint8_t headerlength␉ = 0;␊
2496@@ -1192,7 +1968,7 @@␊
2497 ␉␉␉␉␉␉␉channel1 |= ( 0x1 << entries[i].index);␊
2498 ␉␉␉␉␉␉␉entries[i].type = TYPE_GROUPED;␊
2499 ␉␉␉␉␉␉␉␊
2500-␉␉␉␉␉␉␉if ( entries[i-1].type == 0x0 )␊
2501+␉␉␉␉␉␉␉if ((entries[i-1].type == 0x0))␊
2502 ␉␉␉␉␉␉␉{␊
2503 ␉␉␉␉␉␉␉␉channel1 |= ( 0x1 << entries[i-1].index);␊
2504 ␉␉␉␉␉␉␉␉entries[i-1].type = TYPE_GROUPED;␊
2505@@ -1211,7 +1987,7 @@␊
2506 ␉␉␉␉␉␉␉channel2 |= ( 0x1 << entries[i].index);␊
2507 ␉␉␉␉␉␉␉entries[i].type = TYPE_GROUPED;␊
2508 ␉␉␉␉␉␉␉␊
2509-␉␉␉␉␉␉␉if ( entries[i - 1].type == 0x0 )␊
2510+␉␉␉␉␉␉␉if ((entries[i - 1].type == 0x0))␊
2511 ␉␉␉␉␉␉␉{␊
2512 ␉␉␉␉␉␉␉␉channel2 |= ( 0x1 << entries[i-1].index);␊
2513 ␉␉␉␉␉␉␉␉entries[i-1].type = TYPE_GROUPED;␊
2514@@ -1273,17 +2049,23 @@␊
2515 ␉return (has_lvds ? PATCH_ROM_SUCCESS_HAS_LVDS : PATCH_ROM_SUCCESS);␊
2516 }␊
2517 ␊
2518-static char *get_nvidia_model(uint32_t id)␊
2519+static char *get_nvidia_model(uint32_t device_id, uint32_t subsys_id)␊
2520 {␊
2521 ␉int i;␊
2522-␉␊
2523-␉for (i = 1; i < (sizeof(NVKnownChipsets) / sizeof(NVKnownChipsets[0])); i++) {␊
2524-␉␉if (NVKnownChipsets[i].device == id)␊
2525-␉␉{␊
2526-␉␉␉return NVKnownChipsets[i].name;␊
2527-␉␉}␊
2528+␉for (i = 1; i < (sizeof(nvidia_cards) / sizeof(nvidia_cards[0])); i++) // size of NVKnowChipsets array for-loop␊
2529+␉{␊
2530+␉␉if ((nvidia_cards[i].device == device_id) && (nvidia_cards[i].subdev == subsys_id))␊
2531+ {␊
2532+ return nvidia_cards[i].name_model;␊
2533+ break;␊
2534+ }␊
2535+ else if ((nvidia_cards[i].device == device_id) && (nvidia_cards[i].subdev == 0x00000000))␊
2536+ {␊
2537+ return nvidia_cards[i].name_model;␊
2538+ break;␊
2539+ }␊
2540 ␉}␊
2541-␉return NVKnownChipsets[0].name;␊
2542+ return nvidia_cards[0].name_model;␊
2543 }␊
2544 ␊
2545 static uint32_t load_nvidia_bios_file(const char *filename, uint8_t *buf, int bufsize)␊
2546@@ -1310,7 +2092,6 @@␊
2547 ␉return size > 0 ? size : 0;␊
2548 }␊
2549 ␊
2550-␊
2551 static int devprop_add_nvidia_template(struct DevPropDevice *device)␊
2552 {␊
2553 ␉char tmp[16];␊
2554@@ -1340,7 +2121,7 @@␊
2555 ␉ if (!DP_ADD_TEMP_VAL(device, nvidia_device_type_child))␊
2556 ␉␉ return 0;␊
2557 ␉}␊
2558-␉␊
2559+␊
2560 ␉// Rek : Dont use sprintf return, it does not WORK !! our custom sprintf() always return 0!␊
2561 ␉// len = sprintf(tmp, "Slot-%x", devices_number);␊
2562 ␉sprintf(tmp, "Slot-%x",devices_number);␊
2563@@ -1398,15 +2179,12 @@␊
2564 ␉␉vram_size *= REG32(NVC0_MEM_CTRLR_COUNT);␊
2565 ␉}␊
2566 ␉␊
2567-␉// Workaround for 9600M GT, GT 420/430/440 & GT 525M␊
2568+␉// Workaround for 9600M GT, GT 210/420/430/440/525M/540M & GTX 560M␊
2569 ␉switch (nvda_dev->device_id)␊
2570 ␉{␊
2571- // 9600M GT␊
2572-␉␉case 0x0649:␊
2573- case 0x0647:␊
2574- vram_size = 512*1024*1024;␊
2575- break;␊
2576- case 0x0A65: vram_size = 1024*1024*1024; break; // GT 210␊
2577+␉␉case 0x0647: vram_size = 512*1024*1024; break;␉// 9600M GT 0647␊
2578+␉␉//case 0x0649: vram_size = 1024*1024*1024; break;␉// 9600M GT 0649␊
2579+␉␉case 0x0A65: vram_size = 1024*1024*1024; break; // GT 210␊
2580 ␉␉case 0x0DE0: vram_size = 1024*1024*1024; break; // GT 440␊
2581 ␉␉case 0x0DE1: vram_size = 1024*1024*1024; break; // GT 430␊
2582 ␉␉case 0x0DE2: vram_size = 1024*1024*1024; break; // GT 420␊
2583@@ -1455,12 +2233,13 @@␊
2584 ␉␊
2585 ␉// Amount of VRAM in kilobytes␊
2586 ␉videoRam = mem_detect(regs, nvCardType, nvda_dev);␊
2587-␉model = get_nvidia_model((nvda_dev->vendor_id << 16) | nvda_dev->device_id);␊
2588+␉model = get_nvidia_model(((nvda_dev->vendor_id << 16) | nvda_dev->device_id),((nvda_dev->subsys_id.subsys.vendor_id << 16) | nvda_dev->subsys_id.subsys.device_id));␊
2589 ␉␊
2590- verbose("nVidia %s %dMB NV%02x [%04x:%04x] :: %s device number: %d\n",␊
2591- model, (uint32_t)(videoRam / 1024 / 1024),␊
2592- (REG32(0) >> 20) & 0x1ff, nvda_dev->vendor_id, nvda_dev->device_id,␊
2593- ␉␉␉devicepath, devices_number);␊
2594+␉verbose("%s %dMB NV%02x [%04x:%04x]-[%04x:%04x] :: %s device number: %d\n",␊
2595+␉␉␉model, (uint32_t)(videoRam / 1024 / 1024),␊
2596+␉␉␉(REG32(0) >> 20) & 0x1ff, nvda_dev->vendor_id, nvda_dev->device_id,␊
2597+␉␉␉nvda_dev->subsys_id.subsys.vendor_id, nvda_dev->subsys_id.subsys.device_id,␊
2598+␉␉␉devicepath, devices_number);␊
2599 ␉␊
2600 ␉rom = malloc(NVIDIA_ROM_SIZE);␊
2601 ␉sprintf(nvFilename, "/Extra/%04x_%04x.rom", (uint16_t)nvda_dev->vendor_id,␊
2602@@ -1491,7 +2270,7 @@␊
2603 // Enable PROM access␊
2604 (REG32(NV_PBUS_PCI_NV_20)) = NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED;␊
2605 nvRom = (uint8_t*)&regs[NV_PROM_OFFSET];␊
2606- ␊
2607+␊
2608 // Valid Signature ?␊
2609 ␉␉if (checkNvRomSig(nvRom))␊
2610 ␉␉{␊
2611@@ -1503,10 +2282,10 @@␊
2612 ␊
2613 // disable PROM access␊
2614 (REG32(NV_PBUS_PCI_NV_20)) = NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED;␊
2615- ␊
2616-␉␉ //PRAM next␊
2617+␊
2618+␉ //PRAM next␊
2619 nvRom = (uint8_t*)&regs[NV_PRAMIN_OFFSET];␊
2620- ␊
2621+␊
2622 if(checkNvRomSig(nvRom))␊
2623 {␊
2624 bcopy((uint32_t *)nvRom, rom, NVIDIA_ROM_SIZE);␊
2625@@ -1527,14 +2306,12 @@␊
2626 {␊
2627 DBG("ROM Address 0x%x Signature 0x%02x%02x\n", nvRom, rom[0], rom[1]);␊
2628 }␊
2629- ␊
2630-␉␉␉}//end PRAM check␊
2631- ␊
2632- }//end PROM check␊
2633- ␊
2634-␉}//end load rom from bios␊
2635+ ␉␉␉}//end PRAM check␊
2636+ }//end PROM check␊
2637+ ␉}//end load rom from bios␊
2638 ␉␊
2639-␉if ((nvPatch = patch_nvidia_rom(rom)) == PATCH_ROM_FAILED) {␊
2640+␉if ((nvPatch = patch_nvidia_rom(rom)) == PATCH_ROM_FAILED)␊
2641+␉{␊
2642 ␉␉printf("ERROR: nVidia ROM Patching Failed!\n");␊
2643 ␉␉//return false;␊
2644 ␉}␊
2645@@ -1547,7 +2324,7 @@␊
2646 ␉␉if (rom_pci_header->device_id != nvda_dev->device_id)␊
2647 ␉␉{␊
2648 ␉␉␉// Get Model from the OpROM␊
2649-␉␉␉model = get_nvidia_model((rom_pci_header->vendor_id << 16) | rom_pci_header->device_id);␊
2650+␉␉␉model = get_nvidia_model(((rom_pci_header->vendor_id << 16) | rom_pci_header->device_id), NV_SUB_IDS);␊
2651 ␉␉}␊
2652 ␉␉else␊
2653 ␉␉{␊
2654@@ -1679,17 +2456,17 @@␊
2655 ␉{␊
2656 ␉␉devprop_add_value(device, "vbios", rom, (nvBiosOveride > 0) ? nvBiosOveride : (rom[2] * 512));␊
2657 ␉}␊
2658-␉␊
2659+␊
2660 ␉//add HDMI Audio back to nvidia␊
2661 ␉doit = false;␊
2662 ␉//http://forge.voodooprojects.org/p/chameleon/issues/67/␊
2663-␉if(getBoolForKey(kEnableHDMIAudio, &doit, &bootInfo->chameleonConfig) && doit){␊
2664-␉␉uint8_t connector_type_1[]= {0x00, 0x08, 0x00, 0x00};␊
2665+␉if(getBoolForKey(kEnableHDMIAudio, &doit, &bootInfo->chameleonConfig) && doit)␊
2666+␉{␊
2667+ static uint8_t connector_type_1[]= {0x00, 0x08, 0x00, 0x00};␊
2668 ␉␉devprop_add_value(device, "@1,connector-type",connector_type_1, 4);␊
2669 ␉}␊
2670 ␉//end Nvidia HDMI Audio␊
2671-␉␊
2672-␉␊
2673+␊
2674 ␉stringdata = malloc(sizeof(uint8_t) * string->length);␊
2675 ␉memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length);␊
2676 ␉stringlength = string->length;␊
2677diff -xrevision -x.svn -x.DS_Store -Naur a/i386/libsaio/nvidia.h b/i386/libsaio/nvidia.h␊
2678--- a/i386/libsaio/nvidia.h␉2012-03-14 02:11:46.000000000 +0000␊
2679+++ b/i386/libsaio/nvidia.h␉2012-05-29 12:15:40.000000000 +0100␊
2680@@ -1,50 +1,50 @@␊
2681 /*␊
2682- * NVidia injector␊
2683+ *␉NVidia injector␊
2684 *␊
2685- * Copyright (C) 2009 Jasmin Fazlic, iNDi␊
2686+ *␉Copyright (C) 2009␉Jasmin Fazlic, iNDi␊
2687 *␊
2688- * NVidia injector is free software: you can redistribute it and/or modify␊
2689- * it under the terms of the GNU General Public License as published by␊
2690- * the Free Software Foundation, either version 3 of the License, or␊
2691- * (at your option) any later version.␊
2692- *␊
2693- * NVidia driver and injector is distributed in the hope that it will be useful,␊
2694- * but WITHOUT ANY WARRANTY; without even the implied warranty of␊
2695- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the␊
2696- * GNU General Public License for more details.␊
2697+ *␉NVidia injector modified by Fabio (ErmaC) on May 2012,␊
2698+ *␉for allow the cosmetics injection also based on SubVendorID and SubDeviceID.␊
2699 *␊
2700- * You should have received a copy of the GNU General Public License␊
2701- * along with NVidia injector. If not, see <http://www.gnu.org/licenses/>.␊
2702- */␊
2703- /*␊
2704- * Alternatively you can choose to comply with APSL␊
2705- */␊
2706- ␊
2707-/*␊
2708- * DCB-Table parsing is based on software (nouveau driver) originally distributed under following license:␊
2709+ *␉NVidia injector is free software: you can redistribute it and/or modify␊
2710+ *␉it under the terms of the GNU General Public License as published by␊
2711+ *␉the Free Software Foundation, either version 3 of the License, or␊
2712+ *␉(at your option) any later version.␊
2713+ *␊
2714+ *␉NVidia driver and injector is distributed in the hope that it will be useful,␊
2715+ *␉but WITHOUT ANY WARRANTY; without even the implied warranty of␊
2716+ *␉MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the␊
2717+ *␉GNU General Public License for more details.␊
2718+ *␊
2719+ *␉You should have received a copy of the GNU General Public License␊
2720+ *␉along with NVidia injector.␉ If not, see <http://www.gnu.org/licenses/>.␊
2721+ *␊
2722+ *␉Alternatively you can choose to comply with APSL␊
2723 *␊
2724+ *␉DCB-Table parsing is based on software (nouveau driver) originally distributed under following license:␊
2725 *␊
2726- * Copyright 2005-2006 Erik Waling␊
2727- * Copyright 2006 Stephane Marchesin␊
2728- * Copyright 2007-2009 Stuart Bennett␊
2729- *␊
2730- * Permission is hereby granted, free of charge, to any person obtaining a␊
2731- * copy of this software and associated documentation files (the "Software"),␊
2732- * to deal in the Software without restriction, including without limitation␊
2733- * the rights to use, copy, modify, merge, publish, distribute, sublicense,␊
2734- * and/or sell copies of the Software, and to permit persons to whom the␊
2735- * Software is furnished to do so, subject to the following conditions:␊
2736- *␊
2737- * The above copyright notice and this permission notice shall be included in␊
2738- * all copies or substantial portions of the Software.␊
2739- *␊
2740- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR␊
2741- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,␊
2742- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL␊
2743- * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,␊
2744- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF␊
2745- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE␊
2746- * SOFTWARE.␊
2747+ *␊
2748+ *␉Copyright 2005-2006 Erik Waling␊
2749+ *␉Copyright 2006 Stephane Marchesin␊
2750+ *␉Copyright 2007-2009 Stuart Bennett␊
2751+ *␊
2752+ *␉Permission is hereby granted, free of charge, to any person obtaining a␊
2753+ *␉copy of this software and associated documentation files (the "Software"),␊
2754+ *␉to deal in the Software without restriction, including without limitation␊
2755+ *␉the rights to use, copy, modify, merge, publish, distribute, sublicense,␊
2756+ *␉and/or sell copies of the Software, and to permit persons to whom the␊
2757+ *␉Software is furnished to do so, subject to the following conditions:␊
2758+ *␊
2759+ *␉The above copyright notice and this permission notice shall be included in␊
2760+ *␉all copies or substantial portions of the Software.␊
2761+ *␊
2762+ *␉THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR␊
2763+ *␉IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,␊
2764+ *␉FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL␊
2765+ *␉THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,␊
2766+ *␉WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF␊
2767+ *␉OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE␊
2768+ *␉SOFTWARE.␊
2769 */␊
2770 ␊
2771 #ifndef __LIBSAIO_NVIDIA_H␊
2772@@ -52,10 +52,13 @@␊
2773 ␊
2774 bool setup_nvidia_devprop(pci_dt_t *nvda_dev);␊
2775 ␊
2776-struct nv_chipsets_t {␊
2777-␉unsigned device;␊
2778-␉char *name;␊
2779-};␊
2780+typedef struct {␊
2781+␉uint32_t device; // VendorID + DeviceID␊
2782+␉uint32_t subdev; // SubdeviceID + SubvendorID␊
2783+␉char *name_model;␊
2784+␉//bool kEnableHDMIAudio //␉HDMi␊
2785+␉//VRAM␊
2786+} nvidia_card_info_t;␊
2787 ␊
2788 #define DCB_MAX_NUM_ENTRIES 16␊
2789 #define DCB_MAX_NUM_I2C_ENTRIES 16␊
2790@@ -67,6 +70,12 @@␊
2791 ␉uint8_t␉␉size;␉␉␉/* Size in multiples of 512 */␊
2792 };␊
2793 ␊
2794+#define NV_SUB_IDS 0x00000000␊
2795+#define NV_PMC_OFFSET␉␉␉␉␉␉␉0x000000␊
2796+#define NV_PMC_SIZE 0x2ffff␊
2797+#define NV_PDISPLAY_OFFSET␉␉␉␉␉␉0x610000␊
2798+#define NV_PDISPLAY_SIZE␉␉␉␉␉␉0x10000␊
2799+␊
2800 #define NV_PROM_OFFSET␉␉␉␉␉␉␉0x300000␊
2801 #define NV_PROM_SIZE␉␉␉␉␉␉␉0x0000ffff␊
2802 #define NV_PRAMIN_OFFSET␉␉␉␉␉␉0x00700000␊
2803@@ -77,7 +86,7 @@␊
2804 #define NVC0_MEM_CTRLR_COUNT␉␉␉␉␉0x00121c74␊
2805 #define NVC0_MEM_CTRLR_RAM_AMOUNT␉␉␉␉0x0010f20c␊
2806 ␊
2807-#define NV_PBUS_PCI_NV_20␉0x00001850␊
2808+#define NV_PBUS_PCI_NV_20␉␉␉␉␉␉0x00001850␊
2809 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED␉(0 << 0)␊
2810 #define NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED␉(1 << 0)␊
2811 ␊
2812@@ -85,51 +94,51 @@␊
2813 #define REG16(reg) ((volatile uint16_t *)regs)[(reg) >> 1]␊
2814 #define REG32(reg) ((volatile uint32_t *)regs)[(reg) >> 2]␊
2815 ␊
2816-#define NV_ARCH_03 0x03␊
2817-#define NV_ARCH_04 0x04␊
2818-#define NV_ARCH_10 0x10␊
2819-#define NV_ARCH_20 0x20␊
2820-#define NV_ARCH_30 0x30␊
2821-#define NV_ARCH_40 0x40␊
2822-#define NV_ARCH_50 0x50␊
2823-#define NV_ARCH_C0 0xC0␊
2824-␊
2825-#define CHIPSET_NV03 0x0010␊
2826-#define CHIPSET_NV04 0x0020␊
2827-#define CHIPSET_NV10 0x0100␊
2828-#define CHIPSET_NV11 0x0110␊
2829-#define CHIPSET_NV15 0x0150␊
2830-#define CHIPSET_NV17 0x0170␊
2831-#define CHIPSET_NV18 0x0180␊
2832-#define CHIPSET_NFORCE 0x01A0␊
2833-#define CHIPSET_NFORCE2 0x01F0␊
2834-#define CHIPSET_NV20 0x0200␊
2835-#define CHIPSET_NV25 0x0250␊
2836-#define CHIPSET_NV28 0x0280␊
2837-#define CHIPSET_NV30 0x0300␊
2838-#define CHIPSET_NV31 0x0310␊
2839-#define CHIPSET_NV34 0x0320␊
2840-#define CHIPSET_NV35 0x0330␊
2841-#define CHIPSET_NV36 0x0340␊
2842-#define CHIPSET_NV40 0x0040␊
2843-#define CHIPSET_NV41 0x00C0␊
2844-#define CHIPSET_NV43 0x0140␊
2845-#define CHIPSET_NV44 0x0160␊
2846-#define CHIPSET_NV44A 0x0220␊
2847-#define CHIPSET_NV45 0x0210␊
2848-#define CHIPSET_NV50 0x0190␊
2849-#define CHIPSET_NV84 0x0400␊
2850-#define CHIPSET_MISC_BRIDGED 0x00F0␊
2851-#define CHIPSET_G70 0x0090␊
2852-#define CHIPSET_G71 0x0290␊
2853-#define CHIPSET_G72 0x01D0␊
2854-#define CHIPSET_G73 0x0390␊
2855+#define NV_ARCH_03 0x03␊
2856+#define NV_ARCH_04 0x04␊
2857+#define NV_ARCH_10 0x10␊
2858+#define NV_ARCH_20 0x20␊
2859+#define NV_ARCH_30 0x30␊
2860+#define NV_ARCH_40 0x40␊
2861+#define NV_ARCH_50 0x50␊
2862+#define NV_ARCH_C0 0xC0␊
2863+␊
2864+#define CHIPSET_NV03 0x0010␊
2865+#define CHIPSET_NV04 0x0020␊
2866+#define CHIPSET_NV10 0x0100␊
2867+#define CHIPSET_NV11 0x0110␊
2868+#define CHIPSET_NV15 0x0150␊
2869+#define CHIPSET_NV17 0x0170␊
2870+#define CHIPSET_NV18 0x0180␊
2871+#define CHIPSET_NFORCE 0x01A0␊
2872+#define CHIPSET_NFORCE2 0x01F0␊
2873+#define CHIPSET_NV20 0x0200␊
2874+#define CHIPSET_NV25 0x0250␊
2875+#define CHIPSET_NV28 0x0280␊
2876+#define CHIPSET_NV30 0x0300␊
2877+#define CHIPSET_NV31 0x0310␊
2878+#define CHIPSET_NV34 0x0320␊
2879+#define CHIPSET_NV35 0x0330␊
2880+#define CHIPSET_NV36 0x0340␊
2881+#define CHIPSET_NV40 0x0040␊
2882+#define CHIPSET_NV41 0x00C0␊
2883+#define CHIPSET_NV43 0x0140␊
2884+#define CHIPSET_NV44 0x0160␊
2885+#define CHIPSET_NV44A 0x0220␊
2886+#define CHIPSET_NV45 0x0210␊
2887+#define CHIPSET_NV50 0x0190␊
2888+#define CHIPSET_NV84 0x0400␊
2889+#define CHIPSET_MISC_BRIDGED 0x00F0␊
2890+#define CHIPSET_G70 0x0090␊
2891+#define CHIPSET_G71 0x0290␊
2892+#define CHIPSET_G72 0x01D0␊
2893+#define CHIPSET_G73 0x0390␊
2894 ␊
2895 // integrated GeForces (6100, 6150)␊
2896-#define CHIPSET_C51 0x0240␊
2897+#define CHIPSET_C51 0x0240␊
2898 ␊
2899 // variant of C51, seems based on a G70 design␊
2900-#define CHIPSET_C512 0x03D0␊
2901-#define CHIPSET_G73_BRIDGED 0x02E0␊
2902+#define CHIPSET_C512 0x03D0␊
2903+#define CHIPSET_G73_BRIDGED 0x02E0␊
2904 ␊
2905 #endif /* !__LIBSAIO_NVIDIA_H */␊
2906

Archive Download this file

Attachment to issue 262

Created: 11 years 10 months ago by ErmaC