Chameleon

Chameleon Commit Details

Date:2012-05-06 19:06:20 (11 years 11 months ago)
Author:ErmaC
Commit:1936
Parents: 1935
Message:Improvements and update.
Changes:
A/branches/ErmaC/Trunk/i386/libsaio/lzss.c
M/branches/ErmaC/Trunk/i386/libsaio/spd.c
M/branches/ErmaC/Trunk/i386/libsaio/cpu.c
M/branches/ErmaC/Trunk/i386/libsaio/md5c.c
M/branches/ErmaC/Trunk/i386/libsaio/smbios_getters.c
M/branches/ErmaC/Trunk/i386/libsaio/platform.h
M/branches/ErmaC/Trunk/i386/libsaio/smbios.c
M/branches/ErmaC/Trunk/i386/libsaio/saio_internal.h
M/branches/ErmaC/Trunk/i386/libsaio/Makefile
M/branches/ErmaC/Trunk/package/Resources/distribution/background.tiff
M/branches/ErmaC/Trunk/i386/libsa/strtol.c
M/branches/ErmaC/Trunk/i386/cdboot/cdboothdd.s
M/branches/ErmaC/Trunk/i386/libsaio/console.c
M/branches/ErmaC/Trunk/i386/libsaio/gma.c
M/branches/ErmaC/Trunk/package/buildpkg.sh
M/branches/ErmaC/Trunk/i386/libsaio/io_inline.h
M/branches/ErmaC/Trunk/i386/libsaio/nvidia.c
M/branches/ErmaC/Trunk/i386/boot2/boot.h
M/branches/ErmaC/Trunk/i386/libsaio/pci.c
M/branches/ErmaC/Trunk/i386/libsaio/ati.c
M/branches/ErmaC/Trunk/i386/libsaio/pci_root.c
M/branches/ErmaC/Trunk/i386/libsaio/load.c
M/branches/ErmaC/Trunk/i386/libsaio/hfs.c
M/branches/ErmaC/Trunk/i386/libsaio/pci.h
M/branches/ErmaC/Trunk/i386/cdboot/cdboot.s
M/branches/ErmaC/Trunk/Chameleon.xcodeproj/project.pbxproj
M/branches/ErmaC/Trunk/i386/boot2/prompt.c

File differences

branches/ErmaC/Trunk/Chameleon.xcodeproj/project.pbxproj
32033203
32043204
32053205
3206
3207
3208
3209
3210
3211
32063212
32073213
3208
3209
32103214
32113215
32123216
␉␉␉␉B0056D3F11F3868000754B65 /* fake_efi.c */,␊
␉␉␉␉B0056D4011F3868000754B65 /* fake_efi.h */,␊
␉␉␉␉B0056D4111F3868000754B65 /* fdisk.h */,␊
␉␉␉␉B495AC9B1551EA7B00B5E8A6 /* freebsd.c */,␊
␉␉␉␉B495AC9C1551EA7B00B5E8A6 /* freebsd.h */,␊
␉␉␉␉B495AC981551EA5D00B5E8A6 /* gma.c */,␊
␉␉␉␉B495AC991551EA5D00B5E8A6 /* gma.h */,␊
␉␉␉␉B0056D4411F3868000754B65 /* hfs_CaseTables.h */,␊
␉␉␉␉B0056D4511F3868000754B65 /* hfs_compare.c */,␊
␉␉␉␉B0056D4211F3868000754B65 /* hfs.c */,␊
␉␉␉␉B0056D4311F3868000754B65 /* hfs.h */,␊
␉␉␉␉B0056D4411F3868000754B65 /* hfs_CaseTables.h */,␊
␉␉␉␉B0056D4511F3868000754B65 /* hfs_compare.c */,␊
␉␉␉␉B0056D4611F3868000754B65 /* hpet.c */,␊
␉␉␉␉B0056D4711F3868000754B65 /* hpet.h */,␊
␉␉␉␉B0056D4811F3868000754B65 /* io_inline.h */,␊
branches/ErmaC/Trunk/i386/libsaio/console.c
9191
9292
9393
94
94
9595
9696
9797
␉msgbuf = malloc(BOOTER_LOG_SIZE);␊
␉bzero(msgbuf, BOOTER_LOG_SIZE);␊
␉cursor = msgbuf;␊
␉msglog("%s\n", "ErmaC (Trunk) r" I386BOOT_CHAMELEONREVISION ")" " [" I386BOOT_BUILDDATE "]");␊
␉msglog("%s\n", "Enoch by ErmaC r" I386BOOT_CHAMELEONREVISION ")" " [" I386BOOT_BUILDDATE "]");␊
}␊
␊
void msglog(const char * fmt, ...)␊
branches/ErmaC/Trunk/i386/libsaio/io_inline.h
7979
8080
8181
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
82105
__OUT(w, short) /* outw() */␊
__OUT(l, long) /* outl() */␊
␊
␊
static inline void cmos_write_byte (int loc, int val)␊
{␊
␉outb (0x70, loc);␊
␉outb (0x71, val);␊
}␊
␊
static inline unsigned cmos_read_byte (int loc)␊
{␊
␉outb (0x70, loc);␊
␉return inb (0x71);␊
}␊
␊
#define CMOS_WRITE_BYTE(x, y)␉cmos_write_byte(x, y)␊
#define CMOS_READ_BYTE(x)␉cmos_read_byte(x)␊
␊
static inline void cli() {␊
␉asm("cli");␊
}␊
static inline void sti() {␊
␉asm("sti");␊
}␊
␊
#endif /* !__LIBSAIO_IO_INLINE_H */␊
branches/ErmaC/Trunk/i386/libsaio/hfs.c
774774
775775
776776
777
777
778778
779779
780780
......
793793
794794
795795
796
796
797797
798798
799799
......
805805
806806
807807
808
808
809809
810
810
811811
812812
813813
......
816816
817817
818818
819
819
820820
821821
822822
......
883883
884884
885885
886
886
887887
888888
889889
890890
891891
892
892
893893
894894
895895
896896
897897
898
898
899899
900900
901901
......
926926
927927
928928
929
929
930930
931931
932932
......
959959
960960
961961
962
962
963963
964964
965
965
966966
967967
968968
......
994994
995995
996996
997
997
998998
999999
1000
1000
10011001
10021002
10031003
......
10301030
10311031
10321032
1033
1033
10341034
10351035
1036
1036
10371037
10381038
1039
1039
10401040
10411041
10421042
curNode = SWAP_BE32( *((long *)recordData) );␊
} else break;␊
}␊
␊
␊
// Return error if the file was not found.␊
if (result != 0) { free(nodeBuf); return -1; }␊
␊
if (gIsHFSPlus) entrySize = sizeof(HFSPlusExtentRecord);␊
else entrySize = sizeof(HFSExtentRecord);␊
}␊
␊
␊
bcopy(recordData, entry, entrySize);␊
␊
// Update dirIndex.␊
}␊
*dirIndex = (long long) curNode * nodeSize + index;␊
}␊
␊
␊
free(nodeBuf);␊
␊
␊
return 0;␊
}␊
␊
{␊
long keySize;␊
long recordOffset;␊
␊
␊
recordOffset = SWAP_BE16(*((short *)(nodeBuffer + (nodeSize - 2 * index - 2))));␊
*key = nodeBuffer + recordOffset;␊
if (gIsHFSPlus) {␊
currentExtent = extentBuffer + sizeofExtent * (nextExtent % extentDensity);␊
break;␊
}␊
␊
␊
countedBlocks += currentExtentSize;␊
}␊
␊
readOffset = ((blockNumber - countedBlocks) * gBlockSize) +␊
(offset % gBlockSize);␊
␊
␊
␉␉// MacWen: fix overflow in multiplication by forcing 64bit multiplication␊
readSize = (long long)GetExtentSize(currentExtent, 0) * gBlockSize - readOffset;␊
if (readSize > (size - sizeRead)) readSize = size - sizeRead;␊
␊
readOffset += (long long)GetExtentStart(currentExtent, 0) * gBlockSize;␊
␊
␊
CacheRead(gCurrentIH, bufferPos, gAllocationOffset + readOffset,␊
readSize, cache);␊
␊
long size;␊
HFSExtentDescriptor *hfsExtents = extents;␊
HFSPlusExtentDescriptor *hfsPlusExtents = extents;␊
␊
␊
if (gIsHFSPlus) size = SWAP_BE32(hfsPlusExtents[index].blockCount);␊
else size = SWAP_BE16(hfsExtents[index].blockCount);␊
␊
{␊
HFSPlusCatalogKey *searchKey, *trialKey;␊
long result, searchParentID, trialParentID;␊
␊
␊
searchKey = key;␊
trialKey = testKey;␊
␊
␊
searchParentID = SWAP_BE32(searchKey->parentID);␊
trialParentID = SWAP_BE32(trialKey->parentID);␊
␊
{␊
HFSExtentKey *searchKey, *trialKey;␊
long result;␊
␊
␊
searchKey = key;␊
trialKey = testKey;␊
␊
␊
// assume searchKey < trialKey␊
result = -1; ␊
␊
{␊
HFSPlusExtentKey *searchKey, *trialKey;␊
long result;␊
␊
␊
searchKey = key;␊
trialKey = testKey;␊
␊
␊
// assume searchKey < trialKey␊
result = -1; ␊
␊
␊
if (searchKey->fileID == trialKey->fileID) {␊
// FileNum's are equal; compare fork types␊
if (searchKey->forkType == trialKey->forkType) {␊
branches/ErmaC/Trunk/i386/libsaio/spd.c
371371
372372
373373
374
375
374
375
376
377
376378
377379
378380
␉{0x8086, 0x2930, "ICH9",␉␉read_smb_intel },␉␊
␉{0x8086, 0x3A30, "ICH10R",␉␉read_smb_intel },␊
␉{0x8086, 0x3A60, "ICH10B",␉␉read_smb_intel },␊
␉{0x8086, 0x3B30, "5 Series",␉read_smb_intel },␊
␉{0x8086, 0x1C22, "6 Series",␉read_smb_intel },␊
␉{0x8086, 0x3B30, "5 Series",␉␉read_smb_intel },␊
␉{0x8086, 0x1C22, "6 Series",␉␉read_smb_intel },␊
␉{0x8086, 0x1E22, "7 Series",␉␉read_smb_intel },␊
␉{0x8086, 0x1D70, "X79",␉␉␉read_smb_intel },␊
␉{0x8086, 0x5032, "EP80579",␉␉read_smb_intel }␊
␊
};␊
branches/ErmaC/Trunk/i386/libsaio/Makefile
3939
4040
4141
42
42
4343
4444
4545
␉fake_efi.o ext2fs.o \␊
␉hpet.o dram_controllers.o spd.o usb.o pci_setup.o \␊
␉device_inject.o nvidia.o ati.o gma.o pci_root.o \␊
␉convert.o aml_generator.o console.o exfat.o␊
␉convert.o aml_generator.o console.o exfat.o lzss.o␊
␊
SAIO_OBJS := $(addprefix $(OBJROOT)/, $(SAIO_OBJS))␊
␊
branches/ErmaC/Trunk/i386/libsaio/gma.c
2222
2323
2424
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
4749
4850
4951
......
111113
112114
113115
114
115
116
117
118
116
117
118
119
120
121
122
123
119124
120125
121126
122
127
123128
124129
125130
126131
127
128
129
130
131
132
133
134
135
136
137
138
132
133
134
135
136
137
138
139
140
141
142
143
139144
140145
141146
......
202207
203208
204209
205
210
206211
207212
208
209
213
214
210215
211
212
213
214
215
216
217
218
219
216
217
218
219
220
221
222
223
224
220225
221
222
223
224
225
226
227
226
227
228
229
230
231
232
228233
229234
230235
#endif␊
␊
␊
uint8_t GMAX3100_vals[22][4] = {␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x08 },␊
␉{ 0x64,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x08 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x20,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x20,0x03,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x08,0x52,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x01,0x00,0x00,0x00 },␊
␉{ 0x3B,0x00,0x00,0x00 },␊
␉{ 0x00,0x00,0x00,0x00 }␊
uint8_t GMAX3100_vals[23][4] = {␊
␉{ 0x01,0x00,0x00,0x00 },␉//0 "AAPL,HasPanel"␊
␉{ 0x01,0x00,0x00,0x00 },␉//1 "AAPL,SelfRefreshSupported"␊
␉{ 0x01,0x00,0x00,0x00 },␉//2 "AAPL,aux-power-connected"␊
␉{ 0x01,0x00,0x00,0x08 },␉//3 "AAPL,backlight-control"␊
␉{ 0x00,0x00,0x00,0x00 },␉//4 "AAPL00,blackscreen-preferences"␊
␉{ 0x56,0x00,0x00,0x08 },␉//5 "AAPL01,BacklightIntensity"␊
␉{ 0x00,0x00,0x00,0x00 },␉//6 "AAPL01,blackscreen-preferences"␊
␉{ 0x01,0x00,0x00,0x00 },␉//7 "AAPL01,DataJustify"␊
␉{ 0x20,0x00,0x00,0x00 },␉//8 "AAPL01,Depth"␊
␉{ 0x01,0x00,0x00,0x00 },␉//9 "AAPL01,Dither"␊
␉{ 0x20,0x03,0x00,0x00 },␉//10 "AAPL01,Height"␊
␉{ 0x00,0x00,0x00,0x00 },␉//11 "AAPL01,Interlace"␊
␉{ 0x00,0x00,0x00,0x00 },␉//12 "AAPL01,Inverter"␊
␉{ 0x08,0x52,0x00,0x00 },␉//13 "AAPL01,InverterCurrent"␊
␉{ 0x00,0x00,0x00,0x00 },␉//14 "AAPL01,LinkFormat"␊
␉{ 0x00,0x00,0x00,0x00 },␉//15 "AAPL01,LinkType"␊
␉{ 0x01,0x00,0x00,0x00 },␉//16 "AAPL01,Pipe"␊
␉{ 0x01,0x00,0x00,0x00 },␉//17 "AAPL01,PixelFormat"␊
␉{ 0x01,0x00,0x00,0x00 },␉//18 "AAPL01,Refresh"␊
␉{ 0x3B,0x00,0x00,0x00 },␉//19 "AAPL01,Stretch"␊
␉{ 0xc8,0x95,0x00,0x00 },␉//20 "AAPL01,InverterFrequency"␊
␉{ 0x6B,0x10,0x00,0x00 },␉//21 "subsystem-vendor-id"␊
␉{ 0xA2,0x00,0x00,0x00 },␉//22 "subsystem-id"};␊
};␊
␊
uint8_t HD2000_vals[16][4] = {␊
␊
static struct gma_gpu_t KnownGPUS[] = {␊
␉{ 0x00000000, "Unknown"␉␉␉},␊
␉{ 0x80860042, "Desktop Graphics" },␊
␉{ 0x80860046, "Mobile Graphics" },␊
␉{ 0x808627A2, "Mobile GMA950"␉},␊
␉{ 0x808627AE, "Mobile GMA950"␉},␊
␉{ 0x808627A6, "Mobile GMA950"␉},␊
␉{ 0x80860042, "HD2000" },␊
//␉{ 0x80860044, "HD2000" }, //host bridge␊
␉{ 0x80860046, "HD2000" },␊
␉{ 0x80862582, "GMA 915"␉},␊
␉{ 0x80862592, "GMA 915"␉},␊
␉{ 0x808627A2, "GMA950"␉},␊
␉{ 0x808627AE, "GMA950"␉},␊
//␉{ 0x808627A6, "Mobile GMA950"␉},␊
␉{ 0x8086A011, "Mobile GMA3150"␉},␊
␉{ 0x8086A012, "Mobile GMA3150"␉},␊
␉{ 0x80862772, "Desktop GMA950"␉},␊
␉{ 0x80862776, "Desktop GMA950"␉},␊
//␉{ 0x80862776, "Desktop GMA950"␉},␊
//␉{ 0x8086A001, "Desktop GMA3150" },␊
␉{ 0x8086A001, "Mobile GMA3150"␉},␊
␉{ 0x8086A002, "Desktop GMA3150" },␊
␊
␉{ 0x80862A02, "GMAX3100"␉␉},␊
␉{ 0x80862A03, "GMAX3100"␉␉},␊
␉{ 0x80862A12, "GMAX3100"␉␉},␊
␉{ 0x80862A13, "GMAX3100"␉␉},␊
␉{ 0x80862A42, "GMAX3100"␉␉},␊
␉{ 0x80862A43, "GMAX3100"␉␉},␊
␉{ 0x80860102, "Intel HD Graphics 2000"␉␉␉},␊
␉{ 0x80860106, "Intel HD Graphics 2000 Mobile"␉},␊
␉{ 0x80860112, "Intel HD Graphics 3000"␉␉␉},␊
␉{ 0x80860116, "Intel HD Graphics 3000 Mobile"␉},␊
␉{ 0x80860122, "Intel HD Graphics 3000"␉␉␉},␊
␉{ 0x80860126, "Intel HD Graphics 3000 Mobile"␉},␊
␉{ 0x80862A02, "GMAX3100"},␊
␉{ 0x80862A03, "GMAX3100"},␊
␉{ 0x80862A12, "GMAX3100"},␊
␉{ 0x80862A13, "GMAX3100"},␊
␉{ 0x80862A42, "GMAX3100"},␊
␉{ 0x80862A43, "GMAX3100"},␊
␉{ 0x80860102, "HD2000"␉},␊
␉{ 0x80860106, "HD2000"␉},␊
␉{ 0x80860112, "HD3000"␉},␊
␉{ 0x80860116, "HD3000"␉},␊
␉{ 0x80860122, "HD3000"␉},␊
␉{ 0x80860126, "HD3000"␉},␊
};␊
␊
char *get_gma_model(uint32_t id) {␊
␉}␊
␉else if (strcmp("GMAX3100",model) == 0)␊
␉{␊
␉␉devprop_add_value(device, "AAPL,HasPanel",␉␉␉␉␉GMAX3100_vals[0], 4);␊
␉␉devprop_add_value(device, "AAPL,HasPanel",␉␉␉GMAX3100_vals[0], 4);␊
␉␉devprop_add_value(device, "AAPL,SelfRefreshSupported",␉␉GMAX3100_vals[1], 4);␊
␉␉devprop_add_value(device, "AAPL,aux-power-connected",␉␉GMAX3100_vals[2], 4);␊
␉␉devprop_add_value(device, "AAPL,backlight-control",␉␉␉GMAX3100_vals[3], 4);␊
␉␉devprop_add_value(device, "AAPL00,blackscreen-preferences", GMAX3100_vals[4], 4);␊
␉␉devprop_add_value(device, "AAPL,backlight-control",␉␉GMAX3100_vals[3], 4);␊
␉␉devprop_add_value(device, "AAPL00,blackscreen-preferences",␉GMAX3100_vals[4], 4);␊
␉␉devprop_add_value(device, "AAPL01,BacklightIntensity",␉␉GMAX3100_vals[5], 4);␊
␉␉devprop_add_value(device, "AAPL01,blackscreen-preferences", GMAX3100_vals[6], 4);␊
␉␉devprop_add_value(device, "AAPL01,DataJustify",␉␉␉␉GMAX3100_vals[7], 4);␊
␉␉devprop_add_value(device, "AAPL01,Depth",␉␉␉␉␉GMAX3100_vals[8], 4);␊
␉␉devprop_add_value(device, "AAPL01,Dither",␉␉␉␉␉GMAX3100_vals[9], 4);␊
␉␉devprop_add_value(device, "AAPL01,DualLink",␉␉␉␉GMAX3100_vals[10], 4);␊
␉␉devprop_add_value(device, "AAPL01,Height",␉␉␉␉␉GMAX3100_vals[11], 4);␊
␉␉devprop_add_value(device, "AAPL01,Interlace",␉␉␉␉GMAX3100_vals[12], 4);␊
␉␉devprop_add_value(device, "AAPL01,Inverter",␉␉␉␉GMAX3100_vals[13], 4);␊
␉␉devprop_add_value(device, "AAPL01,InverterCurrent",␉␉␉GMAX3100_vals[14], 4);␊
␉␉devprop_add_value(device, "AAPL01,blackscreen-preferences",␉GMAX3100_vals[6], 4);␊
␉␉devprop_add_value(device, "AAPL01,DataJustify",␉␉␉GMAX3100_vals[7], 4);␊
␉␉devprop_add_value(device, "AAPL01,Depth",␉␉␉GMAX3100_vals[8], 4);␊
␉␉devprop_add_value(device, "AAPL01,Dither",␉␉␉GMAX3100_vals[9], 4);␊
␉␉devprop_add_value(device, "AAPL01,DualLink",␉␉␉GMAX3100_vals[10], 4);␊
␉␉devprop_add_value(device, "AAPL01,Height",␉␉␉GMAX3100_vals[10], 4);␊
␉␉devprop_add_value(device, "AAPL01,Interlace",␉␉␉GMAX3100_vals[11], 4);␊
␉␉devprop_add_value(device, "AAPL01,Inverter",␉␉␉GMAX3100_vals[12], 4);␊
␉␉devprop_add_value(device, "AAPL01,InverterCurrent",␉␉GMAX3100_vals[13], 4);␊
␉␉devprop_add_value(device, "AAPL01,InverterCurrency",␉␉GMAX3100_vals[15], 4);␊
␉␉devprop_add_value(device, "AAPL01,LinkFormat",␉␉␉␉GMAX3100_vals[16], 4);␊
␉␉devprop_add_value(device, "AAPL01,LinkType",␉␉␉␉GMAX3100_vals[17], 4);␊
␉␉devprop_add_value(device, "AAPL01,Pipe",␉␉␉␉␉GMAX3100_vals[18], 4);␊
␉␉devprop_add_value(device, "AAPL01,PixelFormat",␉␉␉␉GMAX3100_vals[19], 4);␊
␉␉devprop_add_value(device, "AAPL01,Refresh",␉␉␉␉␉GMAX3100_vals[20], 4);␊
␉␉devprop_add_value(device, "AAPL01,Stretch",␉␉␉␉␉GMAX3100_vals[21], 4);␊
␉␉devprop_add_value(device, "class-code",␉␉␉␉␉␉ClassFix, 4);␊
␉␉devprop_add_value(device, "AAPL01,LinkFormat",␉␉␉GMAX3100_vals[14], 4);␊
␉␉devprop_add_value(device, "AAPL01,LinkType",␉␉␉GMAX3100_vals[15], 4);␊
␉␉devprop_add_value(device, "AAPL01,Pipe",␉␉␉GMAX3100_vals[16], 4);␊
␉␉devprop_add_value(device, "AAPL01,PixelFormat",␉␉␉GMAX3100_vals[17], 4);␊
␉␉devprop_add_value(device, "AAPL01,Refresh",␉␉␉GMAX3100_vals[18], 4);␊
␉␉devprop_add_value(device, "AAPL01,Stretch",␉␉␉GMAX3100_vals[19], 4);␊
␉␉devprop_add_value(device, "class-code",␉␉␉␉ClassFix, 4);␊
␉}␊
␉else if (model == (char *)"Intel HD Graphics 2000 Mobile")␊
␉{␊
branches/ErmaC/Trunk/i386/libsaio/pci_root.c
7575
7676
7777
78
78
7979
8080
8181
␉␉goto out;␊
␉}␊
␊
␉␊
␊
␉// Try using the file specified with the DSDT option␊
␉if (getValueForKey(kDSDT, &dsdt_filename, &len, &bootInfo->chameleonConfig))␊
␉{␊
branches/ErmaC/Trunk/i386/libsaio/nvidia.c
110110
111111
112112
113
113
114114
115115
116116
117
118
119
120
121
122
123
124
125
126
127
117
118
119
120
121
122
123
124
125
126
127
128128
129129
130130
131131
132132
133
134
135
136
137
138
139
140
133
134
135
136
137
138
139
140
141141
142142
143143
144
145
146
147
148
149
150
151
152
144
145
146
147
148
149
150
151
152
153153
154154
155155
156
157
158
159
160
161
162
163
156
157
158
159
160
161
162
163
164164
165165
166166
167167
168168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184184
185185
186
187
188
189
190
191
192
193
194
195
196
197
198
186
187
188
189
190
191
192
193
194
195
196
197
198
199199
200200
201201
202
203
204
205
206
207
202
203
204
205
206
207
208208
209209
210210
211211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226226
227227
228
228
229229
230230
231
232
233
234
231
232
233
234
235235
236
237
238
236
237
238
239239
240240
241
242
243
244
245
246
247
241
242
243
244
245
246
247
248248
249
249
250250
251251
252252
253253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268268
269269
270270
271271
272272
273
274
275
276
277
273
274
275
276
277
278278
279279
280
281
282
283
280
281
282
283
284284
285
286
287
288
289
290
285
286
287
288
289
290
291291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306306
307
308
309
310
311
312
313
307
308
309
310
311
312
313
314314
315
316
317
318
319
320
321
322
323
324
325
326
315
316
317
318
319
320
321
322
323
324
325
326
327327
328328
329329
330330
331
331
332332
333
334
335
336
337
338
339
340
341
342
343
344
345
333
334
335
336
337
338
339
340
341
342
343
344
345
346346
347347
348348
349349
350
351
352
353
354
350
351
352
353
354
355355
356356
357357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374374
375
375
376376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393393
394394
395395
......
400400
401401
402402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419419
420420
421421
......
423423
424424
425425
426
427
428
429
430
431
426
427
428
429
430
431
432432
433433
434434
......
440440
441441
442442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492492
493
494
495
496
497
498
499
493
494
495
496
497
498
499
500500
501
501
502502
503503
504504
......
510510
511511
512512
513
514
515
516
517
518
519
513
514
515
516
517
518
519
520520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554554
555
556
557
558
559
560
561
562
563
564
565
566
567
555
556
557
558
559
560
561
562
563
564
565
566
567
568568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585585
586586
587587
588588
589589
590
590
591591
592
592
593593
594
595
596
597
598
594
595
596
597
598
599599
600600
601
601
602602
603603
604
604
605605
606606
607607
608608
609609
610610
611
612
613
614
615
616
617
618
611
612
613
614
615
616
617
618
619619
620620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653653
654654
655655
......
665665
666666
667667
668
669
670
671
672
668
669
670
671
672
673673
674674
675675
676676
677677
678678
679
680
681
682
683
684
685
686
687
688
689
690
679
680
681
682
683
684
685
686
687
688
689
690
691691
692692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708708
709
710
711
712
713
714
715
716
717
718
709
710
711
712
713
714
715
716
717
718
719719
720720
721721
722
723
724
725
726
727
722
723
724
725
726
727
728728
729
730
731
732
729
730
731
732
733733
734734
735735
......
751751
752752
753753
754
754
755755
756
756
757757
758
759
760
761
762
763
764
765
766
767
768
769
758
759
760
761
762
763
764
765
766
767
768
769
770770
771
772
773
774
775
776
777
778
771
772
773
774
775
776
777
778
779779
780780
781781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812812
813813
814814
......
844844
845845
846846
847
848
849
850
851
852
853
854
855
856
857
858
847
848
849
850
851
852
853
854
855
856
857
858
859859
860
861
862
860
861
862
863863
864864
865865
......
877877
878878
879879
880
881
882
883
884
885
886
887
888
889
890
880
881
882
883
884
885
886
887
888
889
890
891891
892
893
894
895
896
897
898
899
900
892
893
894
895
896
897
898
899
900
901901
902
903
904
905
906
907
908
909
910
911
912
913
914
902
903
904
905
906
907
908
909
910
911
912
913
914
915915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930930
931931
932932
933
934
935
936
937
938
933
934
935
936
937
938
939939
940
941
942
943
944
945
946
947
940
941
942
943
944
945
946
947
948948
949949
950950
......
971971
972972
973973
974
975
976
977
974
975
976
977
978978
979979
980980
......
982982
983983
984984
985
986
987
988
989
985
986
987
988
989
990990
991
992
993
994
995
996
997
998
999
1000
991
992
993
994
995
996
997
998
999
1000
10011001
10021002
1003
1004
1005
1003
1004
1005
10061006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
10191019
1020
1021
1022
1023
1024
1025
1020
1021
1022
1023
1024
1025
10261026
10271027
10281028
1029
1030
1031
1032
1029
1030
1031
1032
10331033
1034
1034
10351035
10361036
10371037
......
10391039
10401040
10411041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
10531053
10541054
10551055
10561056
1057
1057
1058
1059
10581060
10591061
10601062
......
10631065
10641066
10651067
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
10891091
10901092
10911093
......
13941396
13951397
13961398
1397
1399
13981400
13991401
14001402
......
15041506
15051507
15061508
1507
1509
15081510
15091511
15101512
#define NVPM_LEN ( sizeof(default_NVPM) / sizeof(uint8_t) )␊
␊
static struct nv_chipsets_t NVKnownChipsets[] = {␊
␉{ 0x00000000,␉/*0x00000000,*/␉"Unknown" },␊
␉{ 0x00000000,␉"Unknown" },␊
//========================================␊
␉// 0000 - 0040␉␊
␉// 0040 - 004F␉␊
␉{ 0x10DE0040,␉/*0x00000000,*/␉"GeForce 6800 Ultra" },␊
␉{ 0x10DE0041,␉/*0x00000000,*/␉"GeForce 6800" },␊
␉{ 0x10DE0042,␉/*0x00000000,*/␉"GeForce 6800 LE" },␊
␉{ 0x10DE0043,␉/*0x00000000,*/␉"GeForce 6800 XE" },␊
␉{ 0x10DE0044,␉/*0x00000000,*/␉"GeForce 6800 XT" },␊
␉{ 0x10DE0045,␉/*0x00000000,*/␉"GeForce 6800 GT" },␊
␉{ 0x10DE0046,␉/*0x00000000,*/␉"GeForce 6800 GT" },␊
␉{ 0x10DE0047,␉/*0x00000000,*/␉"GeForce 6800 GS" },␊
␉{ 0x10DE0048,␉/*0x00000000,*/␉"GeForce 6800 XT" },␊
␉{ 0x10DE004D,␉/*0x00000000,*/␉"Quadro FX 3400" },␊
␉{ 0x10DE004E,␉/*0x00000000,*/␉"Quadro FX 4000" },␊
␉{ 0x10DE0040,␉"GeForce 6800 Ultra" },␊
␉{ 0x10DE0041,␉"GeForce 6800" },␊
␉{ 0x10DE0042,␉"GeForce 6800 LE" },␊
␉{ 0x10DE0043,␉"GeForce 6800 XE" },␊
␉{ 0x10DE0044,␉"GeForce 6800 XT" },␊
␉{ 0x10DE0045,␉"GeForce 6800 GT" },␊
␉{ 0x10DE0046,␉"GeForce 6800 GT" },␊
␉{ 0x10DE0047,␉"GeForce 6800 GS" },␊
␉{ 0x10DE0048,␉"GeForce 6800 XT" },␊
␉{ 0x10DE004D,␉"Quadro FX 3400" },␊
␉{ 0x10DE004E,␉"Quadro FX 4000" },␊
␉// 0050 - 005F␊
␉// 0060 - 006F␊
␉// 0070 - 007F␊
␉// 0080 - 008F␊
␉// 0090 - 009F␊
␉{ 0x10DE0090,␉/*0x00000000,*/␉"GeForce 7800 GTX" },␊
␉{ 0x10DE0091,␉/*0x00000000,*/␉"GeForce 7800 GTX" },␊
␉{ 0x10DE0092,␉/*0x00000000,*/␉"GeForce 7800 GT" },␊
␉{ 0x10DE0093,␉/*0x00000000,*/␉"GeForce 7800 GS" },␊
␉{ 0x10DE0095,␉/*0x00000000,*/␉"GeForce 7800 SLI" },␊
␉{ 0x10DE0098,␉/*0x00000000,*/␉"GeForce Go 7800" },␊
␉{ 0x10DE0099,␉/*0x00000000,*/␉"GeForce Go 7800 GTX" },␊
␉{ 0x10DE009D,␉/*0x00000000,*/␉"Quadro FX 4500" },␊
␉{ 0x10DE0090,␉"GeForce 7800 GTX" },␊
␉{ 0x10DE0091,␉"GeForce 7800 GTX" },␊
␉{ 0x10DE0092,␉"GeForce 7800 GT" },␊
␉{ 0x10DE0093,␉"GeForce 7800 GS" },␊
␉{ 0x10DE0095,␉"GeForce 7800 SLI" },␊
␉{ 0x10DE0098,␉"GeForce Go 7800" },␊
␉{ 0x10DE0099,␉"GeForce Go 7800 GTX" },␊
␉{ 0x10DE009D,␉"Quadro FX 4500" },␊
␉// 00A0 - 00AF␉␊
␉// 00B0 - 00BF␉␊
␉// 00C0 - 00CF␉␊
␉{ 0x10DE00C0,␉/*0x00000000,*/␉"GeForce 6800 GS" },␊
␉{ 0x10DE00C1,␉/*0x00000000,*/␉"GeForce 6800" },␊
␉{ 0x10DE00C2,␉/*0x00000000,*/␉"GeForce 6800 LE" },␊
␉{ 0x10DE00C3,␉/*0x00000000,*/␉"GeForce 6800 XT" },␊
␉{ 0x10DE00C8,␉/*0x00000000,*/␉"GeForce Go 6800" },␊
␉{ 0x10DE00C9,␉/*0x00000000,*/␉"GeForce Go 6800 Ultra" },␊
␉{ 0x10DE00CC,␉/*0x00000000,*/␉"Quadro FX Go1400" },␊
␉{ 0x10DE00CD,␉/*0x00000000,*/␉"Quadro FX 3450/4000 SDI" },␊
␉{ 0x10DE00CE,␉/*0x00000000,*/␉"Quadro FX 1400" },␊
␉{ 0x10DE00C0,␉"GeForce 6800 GS" },␊
␉{ 0x10DE00C1,␉"GeForce 6800" },␊
␉{ 0x10DE00C2,␉"GeForce 6800 LE" },␊
␉{ 0x10DE00C3,␉"GeForce 6800 XT" },␊
␉{ 0x10DE00C8,␉"GeForce Go 6800" },␊
␉{ 0x10DE00C9,␉"GeForce Go 6800 Ultra" },␊
␉{ 0x10DE00CC,␉"Quadro FX Go1400" },␊
␉{ 0x10DE00CD,␉"Quadro FX 3450/4000 SDI" },␊
␉{ 0x10DE00CE,␉"Quadro FX 1400" },␊
␉// 00D0 - 00DF␉␊
␉// 00E0 - 00EF␉␊
␉// 00F0 - 00FF␉␊
␉{ 0x10DE00F1,␉/*0x00000000,*/␉"GeForce 6600 GT" },␊
␉{ 0x10DE00F2,␉/*0x00000000,*/␉"GeForce 6600" },␊
␉{ 0x10DE00F3,␉/*0x00000000,*/␉"GeForce 6200" },␊
␉{ 0x10DE00F4,␉/*0x00000000,*/␉"GeForce 6600 LE" },␊
␉{ 0x10DE00F5,␉/*0x00000000,*/␉"GeForce 7800 GS" },␊
␉{ 0x10DE00F6,␉/*0x00000000,*/␉"GeForce 6800 GS/XT" },␊
␉{ 0x10DE00F8,␉/*0x00000000,*/␉"Quadro FX 3400/4400" },␊
␉{ 0x10DE00F9,␉/*0x00000000,*/␉"GeForce 6800 Series GPU" },␊
␉{ 0x10DE00F1,␉"GeForce 6600 GT" },␊
␉{ 0x10DE00F2,␉"GeForce 6600" },␊
␉{ 0x10DE00F3,␉"GeForce 6200" },␊
␉{ 0x10DE00F4,␉"GeForce 6600 LE" },␊
␉{ 0x10DE00F5,␉"GeForce 7800 GS" },␊
␉{ 0x10DE00F6,␉"GeForce 6800 GS/XT" },␊
␉{ 0x10DE00F8,␉"Quadro FX 3400/4400" },␊
␉{ 0x10DE00F9,␉"GeForce 6800 Series GPU" },␊
␉// 0100 - 010F␉␊
␉// 0110 - 011F␉␊
␉// 0120 - 012F␉␊
␉// 0130 - 013F␉␊
␉// 0140 - 014F␉␊
␉{ 0x10DE0140,␉/*0x00000000,*/␉"GeForce 6600 GT" },␊
␉{ 0x10DE0141,␉/*0x00000000,*/␉"GeForce 6600" },␊
␉{ 0x10DE0142,␉/*0x00000000,*/␉"GeForce 6600 LE" },␊
␉{ 0x10DE0143,␉/*0x00000000,*/␉"GeForce 6600 VE" },␊
␉{ 0x10DE0144,␉/*0x00000000,*/␉"GeForce Go 6600" },␊
␉{ 0x10DE0145,␉/*0x00000000,*/␉"GeForce 6610 XL" },␊
␉{ 0x10DE0146,␉/*0x00000000,*/␉"GeForce Go 6600 TE/6200 TE" },␊
␉{ 0x10DE0147,␉/*0x00000000,*/␉"GeForce 6700 XL" },␊
␉{ 0x10DE0148,␉/*0x00000000,*/␉"GeForce Go 6600" },␊
␉{ 0x10DE0149,␉/*0x00000000,*/␉"GeForce Go 6600 GT" },␊
␉{ 0x10DE014A,␉/*0x00000000,*/␉"Quadro NVS 440" },␊
␉{ 0x10DE014C,␉/*0x00000000,*/␉"Quadro FX 550" },␊
␉{ 0x10DE014D,␉/*0x00000000,*/␉"Quadro FX 550" },␊
␉{ 0x10DE014E,␉/*0x00000000,*/␉"Quadro FX 540" },␊
␉{ 0x10DE014F,␉/*0x00000000,*/␉"GeForce 6200" },␊
␉{ 0x10DE0140,␉"GeForce 6600 GT" },␊
␉{ 0x10DE0141,␉"GeForce 6600" },␊
␉{ 0x10DE0142,␉"GeForce 6600 LE" },␊
␉{ 0x10DE0143,␉"GeForce 6600 VE" },␊
␉{ 0x10DE0144,␉"GeForce Go 6600" },␊
␉{ 0x10DE0145,␉"GeForce 6610 XL" },␊
␉{ 0x10DE0146,␉"GeForce Go 6600 TE/6200 TE" },␊
␉{ 0x10DE0147,␉"GeForce 6700 XL" },␊
␉{ 0x10DE0148,␉"GeForce Go 6600" },␊
␉{ 0x10DE0149,␉"GeForce Go 6600 GT" },␊
␉{ 0x10DE014A,␉"Quadro NVS 440" },␊
␉{ 0x10DE014C,␉"Quadro FX 550" },␊
␉{ 0x10DE014D,␉"Quadro FX 550" },␊
␉{ 0x10DE014E,␉"Quadro FX 540" },␊
␉{ 0x10DE014F,␉"GeForce 6200" },␊
␉// 0150 - 015F␉␊
␉// 0160 - 016F␉␊
␉{ 0x10DE0160,␉/*0x00000000,*/␉"GeForce 6500" },␊
␉{ 0x10DE0161,␉/*0x00000000,*/␉"GeForce 6200 TurboCache(TM)" },␊
␉{ 0x10DE0162,␉/*0x00000000,*/␉"GeForce 6200SE TurboCache(TM)" },␊
␉{ 0x10DE0163,␉/*0x00000000,*/␉"GeForce 6200 LE" },␊
␉{ 0x10DE0164,␉/*0x00000000,*/␉"GeForce Go 6200" },␊
␉{ 0x10DE0165,␉/*0x00000000,*/␉"Quadro NVS 285" },␊
␉{ 0x10DE0166,␉/*0x00000000,*/␉"GeForce Go 6400" },␊
␉{ 0x10DE0167,␉/*0x00000000,*/␉"GeForce Go 6200" },␊
␉{ 0x10DE0168,␉/*0x00000000,*/␉"GeForce Go 6400" },␊
␉{ 0x10DE0169,␉/*0x00000000,*/␉"GeForce 6250" },␊
␉{ 0x10DE016A,␉/*0x00000000,*/␉"GeForce 7100 GS" },␊
␉{ 0x10DE016C,␉/*0x00000000,*/␉"NVIDIA NV44GLM" },␊
␉{ 0x10DE016D,␉/*0x00000000,*/␉"NVIDIA NV44GLM" },␊
␉{ 0x10DE0160,␉"GeForce 6500" },␊
␉{ 0x10DE0161,␉"GeForce 6200 TurboCache(TM)" },␊
␉{ 0x10DE0162,␉"GeForce 6200SE TurboCache(TM)" },␊
␉{ 0x10DE0163,␉"GeForce 6200 LE" },␊
␉{ 0x10DE0164,␉"GeForce Go 6200" },␊
␉{ 0x10DE0165,␉"Quadro NVS 285" },␊
␉{ 0x10DE0166,␉"GeForce Go 6400" },␊
␉{ 0x10DE0167,␉"GeForce Go 6200" },␊
␉{ 0x10DE0168,␉"GeForce Go 6400" },␊
␉{ 0x10DE0169,␉"GeForce 6250" },␊
␉{ 0x10DE016A,␉"GeForce 7100 GS" },␊
␉{ 0x10DE016C,␉"NVIDIA NV44GLM" },␊
␉{ 0x10DE016D,␉"NVIDIA NV44GLM" },␊
␉// 0170 - 017F␉␊
␉// 0180 - 018F␉␊
␉// 0190 - 019F␉␉␊
␉{ 0x10DE0191,␉/*0x00000000,*/␉"GeForce 8800 GTX" },␊
␉{ 0x10DE0193,␉/*0x00000000,*/␉"GeForce 8800 GTS" },␊
␉{ 0x10DE0194,␉/*0x00000000,*/␉"GeForce 8800 Ultra" },␊
␉{ 0x10DE0197,␉/*0x00000000,*/␉"Tesla C870" },␊
␉{ 0x10DE019D,␉/*0x00000000,*/␉"Quadro FX 5600" },␊
␉{ 0x10DE019E,␉/*0x00000000,*/␉"Quadro FX 4600" },␊
␉{ 0x10DE0191,␉"GeForce 8800 GTX" },␊
␉{ 0x10DE0193,␉"GeForce 8800 GTS" },␊
␉{ 0x10DE0194,␉"GeForce 8800 Ultra" },␊
␉{ 0x10DE0197,␉"Tesla C870" },␊
␉{ 0x10DE019D,␉"Quadro FX 5600" },␊
␉{ 0x10DE019E,␉"Quadro FX 4600" },␊
␉// 01A0 - 01AF␊
␉// 01B0 - 01BF␊
␉// 01C0 - 01CF␊
␉// 01D0 - 01DF␊
␉{ 0x10DE01D0,␉/*0x00000000,*/␉"GeForce 7350 LE" },␊
␉{ 0x10DE01D1,␉/*0x00000000,*/␉"GeForce 7300 LE" },␊
␉{ 0x10DE01D2,␉/*0x00000000,*/␉"GeForce 7550 LE" },␊
␉{ 0x10DE01D3,␉/*0x00000000,*/␉"GeForce 7300 SE/7200 GS" },␊
␉{ 0x10DE01D6,␉/*0x00000000,*/␉"GeForce Go 7200" },␊
␉{ 0x10DE01D7,␉/*0x00000000,*/␉"GeForce Go 7300" },␊
␉{ 0x10DE01D8,␉/*0x00000000,*/␉"GeForce Go 7400" },␊
␉{ 0x10DE01D9,␉/*0x00000000,*/␉"GeForce Go 7400 GS" },␊
␉{ 0x10DE01DA,␉/*0x00000000,*/␉"Quadro NVS 110M" },␊
␉{ 0x10DE01DB,␉/*0x00000000,*/␉"Quadro NVS 120M" },␊
␉{ 0x10DE01DC,␉/*0x00000000,*/␉"Quadro FX 350M" },␊
␉{ 0x10DE01DD,␉/*0x00000000,*/␉"GeForce 7500 LE" },␊
␉{ 0x10DE01DE,␉/*0x00000000,*/␉"Quadro FX 350" },␊
␉{ 0x10DE01DF,␉/*0x00000000,*/␉"GeForce 7300 GS" },␊
␉{ 0x10DE01D0,␉"GeForce 7350 LE" },␊
␉{ 0x10DE01D1,␉"GeForce 7300 LE" },␊
␉{ 0x10DE01D2,␉"GeForce 7550 LE" },␊
␉{ 0x10DE01D3,␉"GeForce 7300 SE/7200 GS" },␊
␉{ 0x10DE01D6,␉"GeForce Go 7200" },␊
␉{ 0x10DE01D7,␉"GeForce Go 7300" },␊
␉{ 0x10DE01D8,␉"GeForce Go 7400" },␊
␉{ 0x10DE01D9,␉"GeForce Go 7400 GS" },␊
␉{ 0x10DE01DA,␉"Quadro NVS 110M" },␊
␉{ 0x10DE01DB,␉"Quadro NVS 120M" },␊
␉{ 0x10DE01DC,␉"Quadro FX 350M" },␊
␉{ 0x10DE01DD,␉"GeForce 7500 LE" },␊
␉{ 0x10DE01DE,␉"Quadro FX 350" },␊
␉{ 0x10DE01DF,␉"GeForce 7300 GS" },␊
␉// 01E0 - 01EF␉␊
␉// 01F0 - 01FF␊
␉{ 0x10DE01F0,␉/*0x00000000,*/␉"GeForce4 MX" },␊
␉{ 0x10DE01F0,␉"GeForce4 MX" },␊
␉// 0200 - 020F␉␊
␉// 0210 - 021F␉␊
␉{ 0x10DE0211,␉/*0x00000000,*/␉"GeForce 6800" },␊
␉{ 0x10DE0212,␉/*0x00000000,*/␉"GeForce 6800 LE" },␊
␉{ 0x10DE0215,␉/*0x00000000,*/␉"GeForce 6800 GT" },␊
␉{ 0x10DE0218,␉/*0x00000000,*/␉"GeForce 6800 XT" },␊
␉{ 0x10DE0211,␉"GeForce 6800" },␊
␉{ 0x10DE0212,␉"GeForce 6800 LE" },␊
␉{ 0x10DE0215,␉"GeForce 6800 GT" },␊
␉{ 0x10DE0218,␉"GeForce 6800 XT" },␊
␉// 0220 - 022F␊
␉{ 0x10DE0221,␉/*0x00000000,*/␉"GeForce 6200" },␊
␉{ 0x10DE0222,␉/*0x00000000,*/␉"GeForce 6200 A-LE" },␊
␉{ 0x10DE0228,␉/*0x00000000,*/␉"NVIDIA NV44M" },␊
␉{ 0x10DE0221,␉"GeForce 6200" },␊
␉{ 0x10DE0222,␉"GeForce 6200 A-LE" },␊
␉{ 0x10DE0228,␉"NVIDIA NV44M" },␊
␉// 0230 - 023F␊
␉// 0240 - 024F␊
␉{ 0x10DE0240,␉/*0x00000000,*/␉"GeForce 6150" },␊
␉{ 0x10DE0241,␉/*0x00000000,*/␉"GeForce 6150 LE" },␊
␉{ 0x10DE0242,␉/*0x00000000,*/␉"GeForce 6100" },␊
␉{ 0x10DE0243,␉/*0x00000000,*/␉"NVIDIA C51" },␊
␉{ 0x10DE0244,␉/*0x00000000,*/␉"GeForce Go 6150" },␊
␉{ 0x10DE0245,␉/*0x00000000,*/␉"Quadro NVS 210S / GeForce 6150LE" },␊
␉{ 0x10DE0247,␉/*0x00000000,*/␉"GeForce Go 6100" },␊
␉{ 0x10DE0240,␉"GeForce 6150" },␊
␉{ 0x10DE0241,␉"GeForce 6150 LE" },␊
␉{ 0x10DE0242,␉"GeForce 6100" },␊
␉{ 0x10DE0243,␉"NVIDIA C51" },␊
␉{ 0x10DE0244,␉"GeForce Go 6150" },␊
␉{ 0x10DE0245,␉"Quadro NVS 210S / GeForce 6150LE" },␊
␉{ 0x10DE0247,␉"GeForce Go 6100" },␊
␉// 0250 - 025F␊
␉{ 0x10DE025B,␉/*0x00000000,*/␉"Quadro4 700 XGL" },␊
␉{ 0x10DE025B,␉"Quadro4 700 XGL" },␊
␉// 0260 - 026F␊
␉// 0270 - 027F␊
␉// 0280 - 028F␊
␉// 0290 - 029F␊
␉{ 0x10DE0290,␉/*0x00000000,*/␉"GeForce 7900 GTX" },␊
␉{ 0x10DE0291,␉/*0x00000000,*/␉"GeForce 7900 GT/GTO" },␊
␉{ 0x10DE0292,␉/*0x00000000,*/␉"GeForce 7900 GS" },␊
␉{ 0x10DE0293,␉/*0x00000000,*/␉"GeForce 7950 GX2" },␊
␉{ 0x10DE0294,␉/*0x00000000,*/␉"GeForce 7950 GX2" },␊
␉{ 0x10DE0295,␉/*0x00000000,*/␉"GeForce 7950 GT" },␊
␉{ 0x10DE0298,␉/*0x00000000,*/␉"GeForce Go 7900 GS" },␊
␉{ 0x10DE0299,␉/*0x00000000,*/␉"GeForce Go 7900 GTX" },␊
␉{ 0x10DE029A,␉/*0x00000000,*/␉"Quadro FX 2500M" },␊
␉{ 0x10DE029B,␉/*0x00000000,*/␉"Quadro FX 1500M" },␊
␉{ 0x10DE029C,␉/*0x00000000,*/␉"Quadro FX 5500" },␊
␉{ 0x10DE029D,␉/*0x00000000,*/␉"Quadro FX 3500" },␊
␉{ 0x10DE029E,␉/*0x00000000,*/␉"Quadro FX 1500" },␊
␉{ 0x10DE029F,␉/*0x00000000,*/␉"Quadro FX 4500 X2" },␊
␉{ 0x10DE0290,␉"GeForce 7900 GTX" },␊
␉{ 0x10DE0291,␉"GeForce 7900 GT/GTO" },␊
␉{ 0x10DE0292,␉"GeForce 7900 GS" },␊
␉{ 0x10DE0293,␉"GeForce 7950 GX2" },␊
␉{ 0x10DE0294,␉"GeForce 7950 GX2" },␊
␉{ 0x10DE0295,␉"GeForce 7950 GT" },␊
␉{ 0x10DE0298,␉"GeForce Go 7900 GS" },␊
␉{ 0x10DE0299,␉"GeForce Go 7900 GTX" },␊
␉{ 0x10DE029A,␉"Quadro FX 2500M" },␊
␉{ 0x10DE029B,␉"Quadro FX 1500M" },␊
␉{ 0x10DE029C,␉"Quadro FX 5500" },␊
␉{ 0x10DE029D,␉"Quadro FX 3500" },␊
␉{ 0x10DE029E,␉"Quadro FX 1500" },␊
␉{ 0x10DE029F,␉"Quadro FX 4500 X2" },␊
␉// 02A0 - 02AF␊
␉// 02B0 - 02BF␊
␉// 02C0 - 02CF␊
␉// 02D0 - 02DF␊
␉// 02E0 - 02EF␊
␉{ 0x10DE02E0,␉/*0x00000000,*/␉"GeForce 7600 GT" },␊
␉{ 0x10DE02E1,␉/*0x00000000,*/␉"GeForce 7600 GS" },␊
␉{ 0x10DE02E2,␉/*0x00000000,*/␉"GeForce 7300 GT" },␊
␉{ 0x10DE02E3,␉/*0x00000000,*/␉"GeForce 7900 GS" },␊
␉{ 0x10DE02E4,␉/*0x00000000,*/␉"GeForce 7950 GT" },␊
␉{ 0x10DE02E0,␉"GeForce 7600 GT" },␊
␉{ 0x10DE02E1,␉"GeForce 7600 GS" },␊
␉{ 0x10DE02E2,␉"GeForce 7300 GT" },␊
␉{ 0x10DE02E3,␉"GeForce 7900 GS" },␊
␉{ 0x10DE02E4,␉"GeForce 7950 GT" },␊
␉// 02F0 - 02FF␊
␉// 0300 - 030F␊
␉{ 0x10DE0301,␉/*0x00000000,*/␉"GeForce FX 5800 Ultra" },␊
␉{ 0x10DE0302,␉/*0x00000000,*/␉"GeForce FX 5800" },␊
␉{ 0x10DE0308,␉/*0x00000000,*/␉"Quadro FX 2000" },␊
␉{ 0x10DE0309,␉/*0x00000000,*/␉"Quadro FX 1000" },␊
␉{ 0x10DE0301,␉"GeForce FX 5800 Ultra" },␊
␉{ 0x10DE0302,␉"GeForce FX 5800" },␊
␉{ 0x10DE0308,␉"Quadro FX 2000" },␊
␉{ 0x10DE0309,␉"Quadro FX 1000" },␊
␉// 0310 - 031F␊
␉{ 0x10DE0311,␉/*0x00000000,*/␉"GeForce FX 5600 Ultra" },␊
␉{ 0x10DE0312,␉/*0x00000000,*/␉"GeForce FX 5600" },␊
␉{ 0x10DE0314,␉/*0x00000000,*/␉"GeForce FX 5600XT" },␊
␉{ 0x10DE031A,␉/*0x00000000,*/␉"GeForce FX Go5600" },␊
␉{ 0x10DE031B,␉/*0x00000000,*/␉"GeForce FX Go5650" },␊
␉{ 0x10DE031C,␉/*0x00000000,*/␉"Quadro FX Go700" },␊
␉{ 0x10DE0311,␉"GeForce FX 5600 Ultra" },␊
␉{ 0x10DE0312,␉"GeForce FX 5600" },␊
␉{ 0x10DE0314,␉"GeForce FX 5600XT" },␊
␉{ 0x10DE031A,␉"GeForce FX Go5600" },␊
␉{ 0x10DE031B,␉"GeForce FX Go5650" },␊
␉{ 0x10DE031C,␉"Quadro FX Go700" },␊
␉// 0320 - 032F␊
␉{ 0x10DE0320,␉/*0x00000000,*/␉"GeForce FX 5200" },␊
␉{ 0x10DE0321,␉/*0x00000000,*/␉"GeForce FX 5200 Ultra" },␊
␉{ 0x10DE0322,␉/*0x00000000,*/␉"GeForce FX 5200" },␊
␉{ 0x10DE0323,␉/*0x00000000,*/␉"GeForce FX 5200 LE" },␊
␉{ 0x10DE0324,␉/*0x00000000,*/␉"GeForce FX Go5200" },␊
␉{ 0x10DE0325,␉/*0x00000000,*/␉"GeForce FX Go5250" },␊
␉{ 0x10DE0326,␉/*0x00000000,*/␉"GeForce FX 5500" },␊
␉{ 0x10DE0328,␉/*0x00000000,*/␉"GeForce FX Go5200 32M/64M" },␊
␉{ 0x10DE0329,␉/*0x00000000,*/␉"GeForce FX Go5200" },␊
␉{ 0x10DE032A,␉/*0x00000000,*/␉"Quadro NVS 55/280 PCI" },␊
␉{ 0x10DE032B,␉/*0x00000000,*/␉"Quadro FX 500/600 PCI" },␊
␉{ 0x10DE032C,␉/*0x00000000,*/␉"GeForce FX Go53xx Series" },␊
␉{ 0x10DE032D,␉/*0x00000000,*/␉"GeForce FX Go5100" },␊
␉// { 0x10DE032F,␉/*0x00000000,*/␉"NVIDIA NV34GL" },␊
␉{ 0x10DE0320,␉"GeForce FX 5200" },␊
␉{ 0x10DE0321,␉"GeForce FX 5200 Ultra" },␊
␉{ 0x10DE0322,␉"GeForce FX 5200" },␊
␉{ 0x10DE0323,␉"GeForce FX 5200 LE" },␊
␉{ 0x10DE0324,␉"GeForce FX Go5200" },␊
␉{ 0x10DE0325,␉"GeForce FX Go5250" },␊
␉{ 0x10DE0326,␉"GeForce FX 5500" },␊
␉{ 0x10DE0328,␉"GeForce FX Go5200 32M/64M" },␊
␉{ 0x10DE0329,␉"GeForce FX Go5200" },␊
␉{ 0x10DE032A,␉"Quadro NVS 55/280 PCI" },␊
␉{ 0x10DE032B,␉"Quadro FX 500/600 PCI" },␊
␉{ 0x10DE032C,␉"GeForce FX Go53xx Series" },␊
␉{ 0x10DE032D,␉"GeForce FX Go5100" },␊
␉// { 0x10DE032F,␉"NVIDIA NV34GL" },␊
␉// 0330 - 033F␊
␉{ 0x10DE0330,␉/*0x00000000,*/␉"GeForce FX 5900 Ultra" },␊
␉{ 0x10DE0331,␉/*0x00000000,*/␉"GeForce FX 5900" },␊
␉{ 0x10DE0332,␉/*0x00000000,*/␉"GeForce FX 5900XT" },␊
␉{ 0x10DE0333,␉/*0x00000000,*/␉"GeForce FX 5950 Ultra" },␊
␉{ 0x10DE0334,␉/*0x00000000,*/␉"GeForce FX 5900ZT" },␊
␉{ 0x10DE0338,␉/*0x00000000,*/␉"Quadro FX 3000" },␊
␉{ 0x10DE033F,␉/*0x00000000,*/␉"Quadro FX 700" },␊
␉{ 0x10DE0330,␉"GeForce FX 5900 Ultra" },␊
␉{ 0x10DE0331,␉"GeForce FX 5900" },␊
␉{ 0x10DE0332,␉"GeForce FX 5900XT" },␊
␉{ 0x10DE0333,␉"GeForce FX 5950 Ultra" },␊
␉{ 0x10DE0334,␉"GeForce FX 5900ZT" },␊
␉{ 0x10DE0338,␉"Quadro FX 3000" },␊
␉{ 0x10DE033F,␉"Quadro FX 700" },␊
␉// 0340 - 034F␊
␉{ 0x10DE0341,␉/*0x00000000,*/␉"GeForce FX 5700 Ultra" },␊
␉{ 0x10DE0342,␉/*0x00000000,*/␉"GeForce FX 5700" },␊
␉{ 0x10DE0343,␉/*0x00000000,*/␉"GeForce FX 5700LE" },␊
␉{ 0x10DE0344,␉/*0x00000000,*/␉"GeForce FX 5700VE" },␊
␉// { 0x10DE0345,␉/*0x00000000,*/␉"NVIDIA NV36.5" },␊
␉{ 0x10DE0347,␉/*0x00000000,*/␉"GeForce FX Go5700" },␊
␉{ 0x10DE0348,␉/*0x00000000,*/␉"GeForce FX Go5700" },␊
␉// { 0x10DE0349,␉/*0x00000000,*/␉"NVIDIA NV36M Pro" },␊
␉// { 0x10DE034B,␉/*0x00000000,*/␉"NVIDIA NV36MAP" },␊
␉{ 0x10DE034C,␉/*0x00000000,*/␉"Quadro FX Go1000" },␊
␉{ 0x10DE034E,␉/*0x00000000,*/␉"Quadro FX 1100" },␊
␉// { 0x10DE034F,␉/*0x00000000,*/␉"NVIDIA NV36GL" },␊
␉{ 0x10DE0341,␉"GeForce FX 5700 Ultra" },␊
␉{ 0x10DE0342,␉"GeForce FX 5700" },␊
␉{ 0x10DE0343,␉"GeForce FX 5700LE" },␊
␉{ 0x10DE0344,␉"GeForce FX 5700VE" },␊
␉// { 0x10DE0345,␉"NVIDIA NV36.5" },␊
␉{ 0x10DE0347,␉"GeForce FX Go5700" },␊
␉{ 0x10DE0348,␉"GeForce FX Go5700" },␊
␉// { 0x10DE0349,␉"NVIDIA NV36M Pro" },␊
␉// { 0x10DE034B,␉"NVIDIA NV36MAP" },␊
␉{ 0x10DE034C,␉"Quadro FX Go1000" },␊
␉{ 0x10DE034E,␉"Quadro FX 1100" },␊
␉// { 0x10DE034F,␉"NVIDIA NV36GL" },␊
␉// 0350 - 035F␊
␉// 0360 - 036F␊
␉// 0370 - 037F␊
␉// 0380 - 038F␊
␉{ 0x10DE038B,␉/*0x00000000,*/␉"GeForce 7650 GS" },␊
␉{ 0x10DE038B,␉"GeForce 7650 GS" },␊
␉// 0390 - 039F␊
␉{ 0x10DE0390,␉/*0x00000000,*/␉"GeForce 7650 GS" },␊
␉{ 0x10DE0391,␉/*0x00000000,*/␉"GeForce 7600 GT" },␊
␉{ 0x10DE0392,␉/*0x00000000,*/␉"GeForce 7600 GS" },␊
␉{ 0x10DE0393,␉/*0x00000000,*/␉"GeForce 7300 GT" },␊
␉{ 0x10DE0394,␉/*0x00000000,*/␉"GeForce 7600 LE" },␊
␉{ 0x10DE0395,␉/*0x00000000,*/␉"GeForce 7300 GT" },␊
␉{ 0x10DE0397,␉/*0x00000000,*/␉"GeForce Go 7700" },␊
␉{ 0x10DE0398,␉/*0x00000000,*/␉"GeForce Go 7600" },␊
␉{ 0x10DE0399,␉/*0x00000000,*/␉"GeForce Go 7600 GT"},␊
␉{ 0x10DE039A,␉/*0x00000000,*/␉"Quadro NVS 300M" },␊
␉{ 0x10DE039B,␉/*0x00000000,*/␉"GeForce Go 7900 SE" },␊
␉{ 0x10DE039C,␉/*0x00000000,*/␉"Quadro FX 560M" },␊
␉{ 0x10DE039E,␉/*0x00000000,*/␉"Quadro FX 560" },␊
␉{ 0x10DE0390,␉"GeForce 7650 GS" },␊
␉{ 0x10DE0391,␉"GeForce 7600 GT" },␊
␉{ 0x10DE0392,␉"GeForce 7600 GS" },␊
␉{ 0x10DE0393,␉"GeForce 7300 GT" },␊
␉{ 0x10DE0394,␉"GeForce 7600 LE" },␊
␉{ 0x10DE0395,␉"GeForce 7300 GT" },␊
␉{ 0x10DE0397,␉"GeForce Go 7700" },␊
␉{ 0x10DE0398,␉"GeForce Go 7600" },␊
␉{ 0x10DE0399,␉"GeForce Go 7600 GT"},␊
␉{ 0x10DE039A,␉"Quadro NVS 300M" },␊
␉{ 0x10DE039B,␉"GeForce Go 7900 SE" },␊
␉{ 0x10DE039C,␉"Quadro FX 560M" },␊
␉{ 0x10DE039E,␉"Quadro FX 560" },␊
␉// 03A0 - 03AF␊
␉// 03B0 - 03BF␊
␉// 03C0 - 03CF␊
␉// 03D0 - 03DF␊
␉{ 0x10DE03D0,␉/*0x00000000,*/␉"GeForce 6150SE nForce 430" },␊
␉{ 0x10DE03D1,␉/*0x00000000,*/␉"GeForce 6100 nForce 405" },␊
␉{ 0x10DE03D2,␉/*0x00000000,*/␉"GeForce 6100 nForce 400" },␊
␉{ 0x10DE03D5,␉/*0x00000000,*/␉"GeForce 6100 nForce 420" },␊
␉{ 0x10DE03D6,␉/*0x00000000,*/␉"GeForce 7025 / nForce 630a" },␊
␉{ 0x10DE03D0,␉"GeForce 6150SE nForce 430" },␊
␉{ 0x10DE03D1,␉"GeForce 6100 nForce 405" },␊
␉{ 0x10DE03D2,␉"GeForce 6100 nForce 400" },␊
␉{ 0x10DE03D5,␉"GeForce 6100 nForce 420" },␊
␉{ 0x10DE03D6,␉"GeForce 7025 / nForce 630a" },␊
␉// 03E0 - 03EF␊
␉// 03F0 - 03FF␊
␉// 0400 - 040F␊
␉{ 0x10DE0400,␉/*0x00000000,*/␉"GeForce 8600 GTS" },␊
␉{ 0x10DE0401,␉/*0x00000000,*/␉"GeForce 8600 GT" },␊
␉{ 0x10DE0402,␉/*0x00000000,*/␉"GeForce 8600 GT" },␊
␉{ 0x10DE0403,␉/*0x00000000,*/␉"GeForce 8600 GS" },␊
␉{ 0x10DE0404,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE0405,␉/*0x00000000,*/␉"GeForce 9500M GS" },␊
␉{ 0x10DE0406,␉/*0x00000000,*/␉"GeForce 8300 GS" },␊
␉{ 0x10DE0407,␉/*0x00000000,*/␉"GeForce 8600M GT" },␊
␉{ 0x10DE0408,␉/*0x00000000,*/␉"GeForce 9650M GS" },␊
␉{ 0x10DE0409,␉/*0x00000000,*/␉"GeForce 8700M GT" },␊
␉{ 0x10DE040A,␉/*0x00000000,*/␉"Quadro FX 370" },␊
␉{ 0x10DE040B,␉/*0x00000000,*/␉"Quadro NVS 320M" },␊
␉{ 0x10DE040C,␉/*0x00000000,*/␉"Quadro FX 570M" },␊
␉{ 0x10DE040D,␉/*0x00000000,*/␉"Quadro FX 1600M" },␊
␉{ 0x10DE040E,␉/*0x00000000,*/␉"Quadro FX 570" },␊
␉{ 0x10DE040F,␉/*0x00000000,*/␉"Quadro FX 1700" },␊
␉{ 0x10DE0400,␉"GeForce 8600 GTS" },␊
␉{ 0x10DE0401,␉"GeForce 8600 GT" },␊
␉{ 0x10DE0402,␉"GeForce 8600 GT" },␊
␉{ 0x10DE0403,␉"GeForce 8600 GS" },␊
␉{ 0x10DE0404,␉"GeForce 8400 GS" },␊
␉{ 0x10DE0405,␉"GeForce 9500M GS" },␊
␉{ 0x10DE0406,␉"GeForce 8300 GS" },␊
␉{ 0x10DE0407,␉"GeForce 8600M GT" },␊
␉{ 0x10DE0408,␉"GeForce 9650M GS" },␊
␉{ 0x10DE0409,␉"GeForce 8700M GT" },␊
␉{ 0x10DE040A,␉"Quadro FX 370" },␊
␉{ 0x10DE040B,␉"Quadro NVS 320M" },␊
␉{ 0x10DE040C,␉"Quadro FX 570M" },␊
␉{ 0x10DE040D,␉"Quadro FX 1600M" },␊
␉{ 0x10DE040E,␉"Quadro FX 570" },␊
␉{ 0x10DE040F,␉"Quadro FX 1700" },␊
␉// 0410 - 041F␊
␉{ 0x10DE0410,␉/*0x00000000,*/␉"GeForce GT 330" },␊
␉{ 0x10DE0410,␉"GeForce GT 330" },␊
␉// 0420 - 042F␊
␉{ 0x10DE0420,␉/*0x00000000,*/␉"GeForce 8400 SE" },␊
␉{ 0x10DE0421,␉/*0x00000000,*/␉"GeForce 8500 GT" },␊
␉{ 0x10DE0422,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE0423,␉/*0x00000000,*/␉"GeForce 8300 GS" },␊
␉{ 0x10DE0424,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE0425,␉/*0x00000000,*/␉"GeForce 8600M GS" },␊
␉{ 0x10DE0426,␉/*0x00000000,*/␉"GeForce 8400M GT" },␊
␉{ 0x10DE0427,␉/*0x00000000,*/␉"GeForce 8400M GS" },␊
␉{ 0x10DE0428,␉/*0x00000000,*/␉"GeForce 8400M G" },␊
␉{ 0x10DE0429,␉/*0x00000000,*/␉"Quadro NVS 140M" },␊
␉{ 0x10DE042A,␉/*0x00000000,*/␉"Quadro NVS 130M" },␊
␉{ 0x10DE042B,␉/*0x00000000,*/␉"Quadro NVS 135M" },␊
␉{ 0x10DE042C,␉/*0x00000000,*/␉"GeForce 9400 GT" },␊
␉{ 0x10DE042D,␉/*0x00000000,*/␉"Quadro FX 360M" },␊
␉{ 0x10DE042E,␉/*0x00000000,*/␉"GeForce 9300M G" },␊
␉{ 0x10DE042F,␉/*0x00000000,*/␉"Quadro NVS 290" },␊
␉{ 0x10DE0420,␉"GeForce 8400 SE" },␊
␉{ 0x10DE0421,␉"GeForce 8500 GT" },␊
␉{ 0x10DE0422,␉"GeForce 8400 GS" },␊
␉{ 0x10DE0423,␉"GeForce 8300 GS" },␊
␉{ 0x10DE0424,␉"GeForce 8400 GS" },␊
␉{ 0x10DE0425,␉"GeForce 8600M GS" },␊
␉{ 0x10DE0426,␉"GeForce 8400M GT" },␊
␉{ 0x10DE0427,␉"GeForce 8400M GS" },␊
␉{ 0x10DE0428,␉"GeForce 8400M G" },␊
␉{ 0x10DE0429,␉"Quadro NVS 140M" },␊
␉{ 0x10DE042A,␉"Quadro NVS 130M" },␊
␉{ 0x10DE042B,␉"Quadro NVS 135M" },␊
␉{ 0x10DE042C,␉"GeForce 9400 GT" },␊
␉{ 0x10DE042D,␉"Quadro FX 360M" },␊
␉{ 0x10DE042E,␉"GeForce 9300M G" },␊
␉{ 0x10DE042F,␉"Quadro NVS 290" },␊
␉// 0430 - 043F␊
␉// 0440 - 044F␊
␉// 0450 - 045F␊
␉// 04A0 - 04AF␊
␉// 04B0 - 04BF␊
␉// 04C0 - 04CF␊
␉{ 0x10DE04C0,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C1,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C2,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C3,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C4,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C5,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C6,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C7,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C8,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C9,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CA,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CB,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CC,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CD,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CE,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04CF,␉/*0x00000000,*/␉"NVIDIA G78" },␊
␉{ 0x10DE04C0,␉"NVIDIA G78" },␊
␉{ 0x10DE04C1,␉"NVIDIA G78" },␊
␉{ 0x10DE04C2,␉"NVIDIA G78" },␊
␉{ 0x10DE04C3,␉"NVIDIA G78" },␊
␉{ 0x10DE04C4,␉"NVIDIA G78" },␊
␉{ 0x10DE04C5,␉"NVIDIA G78" },␊
␉{ 0x10DE04C6,␉"NVIDIA G78" },␊
␉{ 0x10DE04C7,␉"NVIDIA G78" },␊
␉{ 0x10DE04C8,␉"NVIDIA G78" },␊
␉{ 0x10DE04C9,␉"NVIDIA G78" },␊
␉{ 0x10DE04CA,␉"NVIDIA G78" },␊
␉{ 0x10DE04CB,␉"NVIDIA G78" },␊
␉{ 0x10DE04CC,␉"NVIDIA G78" },␊
␉{ 0x10DE04CD,␉"NVIDIA G78" },␊
␉{ 0x10DE04CE,␉"NVIDIA G78" },␊
␉{ 0x10DE04CF,␉"NVIDIA G78" },␊
␉// 04D0 - 04DF␊
␉// 04E0 - 04EF␊
␉// 04F0 - 04FF␊
␉// 0510 - 051F␊
␉// 0520 - 052F␊
␉// 0530 - 053F␊
␉{ 0x10DE0530,␉/*0x00000000,*/␉"GeForce 7190M / nForce 650M" },␊
␉{ 0x10DE0531,␉/*0x00000000,*/␉"GeForce 7150M / nForce 630M" },␊
␉{ 0x10DE0533,␉/*0x00000000,*/␉"GeForce 7000M / nForce 610M" },␊
␉{ 0x10DE053A,␉/*0x00000000,*/␉"GeForce 7050 PV / nForce 630a" },␊
␉{ 0x10DE053B,␉/*0x00000000,*/␉"GeForce 7050 PV / nForce 630a" },␊
␉{ 0x10DE053E,␉/*0x00000000,*/␉"GeForce 7025 / nForce 630a" },␊
␉{ 0x10DE0530,␉"GeForce 7190M / nForce 650M" },␊
␉{ 0x10DE0531,␉"GeForce 7150M / nForce 630M" },␊
␉{ 0x10DE0533,␉"GeForce 7000M / nForce 610M" },␊
␉{ 0x10DE053A,␉"GeForce 7050 PV / nForce 630a" },␊
␉{ 0x10DE053B,␉"GeForce 7050 PV / nForce 630a" },␊
␉{ 0x10DE053E,␉"GeForce 7025 / nForce 630a" },␊
␉// 0540 - 054F␊
␉// 0550 - 055F␊
␉// 0560 - 056F␊
␉// 05C0 - 05CF␊
␉// 05D0 - 05DF␊
␉// 05E0 - 05EF␊
␉{ 0x10DE05E0,␉/*0x00000000,*/␉"GeForce GTX 295" },␊
␉{ 0x10DE05E1,␉/*0x00000000,*/␉"GeForce GTX 280" },␊
␉{ 0x10DE05E2,␉/*0x00000000,*/␉"GeForce GTX 260" },␊
␉{ 0x10DE05E3,␉/*0x00000000,*/␉"GeForce GTX 285" },␊
␉{ 0x10DE05E4,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05E5,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05E6,␉/*0x00000000,*/␉"GeForce GTX 275" },␊
␉{ 0x10DE05E7,␉/*0x00000000,*/␉"Tesla C1060" },␊
␉{ 0x10DE05E8,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05E9,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05EA,␉/*0x00000000,*/␉"GeForce GTX 260" },␊
␉{ 0x10DE05EB,␉/*0x00000000,*/␉"GeForce GTX 295" },␊
␉{ 0x10DE05EC,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05ED,␉/*0x00000000,*/␉"Quadroplex 2200 D2" },␊
␉{ 0x10DE05EE,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05EF,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05E0,␉"GeForce GTX 295" },␊
␉{ 0x10DE05E1,␉"GeForce GTX 280" },␊
␉{ 0x10DE05E2,␉"GeForce GTX 260" },␊
␉{ 0x10DE05E3,␉"GeForce GTX 285" },␊
␉{ 0x10DE05E4,␉"NVIDIA GT200" },␊
␉{ 0x10DE05E5,␉"NVIDIA GT200" },␊
␉{ 0x10DE05E6,␉"GeForce GTX 275" },␊
␉{ 0x10DE05E7,␉"Tesla C1060" },␊
␉{ 0x10DE05E8,␉"NVIDIA GT200" },␊
␉{ 0x10DE05E9,␉"NVIDIA GT200" },␊
␉{ 0x10DE05EA,␉"GeForce GTX 260" },␊
␉{ 0x10DE05EB,␉"GeForce GTX 295" },␊
␉{ 0x10DE05EC,␉"NVIDIA GT200" },␊
␉{ 0x10DE05ED,␉"Quadroplex 2200 D2" },␊
␉{ 0x10DE05EE,␉"NVIDIA GT200" },␊
␉{ 0x10DE05EF,␉"NVIDIA GT200" },␊
␉// 05F0 - 05FF␊
␉{ 0x10DE05F0,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F1,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F2,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F3,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F4,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F5,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F6,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F7,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05F8,␉/*0x00000000,*/␉"Quadroplex 2200 S4" },␊
␉{ 0x10DE05F9,␉/*0x00000000,*/␉"Quadro CX" },␊
␉{ 0x10DE05FA,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05FB,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05FC,␉/*0x00000000,*/␉"NVIDIA GT200" },␊
␉{ 0x10DE05FD,␉/*0x00000000,*/␉"Quadro FX 5800" },␊
␉{ 0x10DE05FE,␉/*0x00000000,*/␉"Quadro FX 4800" },␊
␉{ 0x10DE05FF,␉/*0x00000000,*/␉"Quadro FX 3800" },␊
␉{ 0x10DE05F0,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F1,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F2,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F3,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F4,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F5,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F6,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F7,␉"NVIDIA GT200" },␊
␉{ 0x10DE05F8,␉"Quadroplex 2200 S4" },␊
␉{ 0x10DE05F9,␉"Quadro CX" },␊
␉{ 0x10DE05FA,␉"NVIDIA GT200" },␊
␉{ 0x10DE05FB,␉"NVIDIA GT200" },␊
␉{ 0x10DE05FC,␉"NVIDIA GT200" },␊
␉{ 0x10DE05FD,␉"Quadro FX 5800" },␊
␉{ 0x10DE05FE,␉"Quadro FX 4800" },␊
␉{ 0x10DE05FF,␉"Quadro FX 3800" },␊
␉// 0600 - 060F␊
␉{ 0x10DE0600,␉/*0x00000000,*/␉"GeForce 8800 GTS 512" },␊
␉{ 0x10DE0601,␉/*0x00000000,*/␉"GeForce 9800 GT" },␊
␉{ 0x10DE0602,␉/*0x00000000,*/␉"GeForce 8800 GT" },␊
␉{ 0x10DE0603,␉/*0x00000000,*/␉"GeForce GT 230" },␊
␉{ 0x10DE0604,␉/*0x00000000,*/␉"GeForce 9800 GX2" },␊
␉{ 0x10DE0605,␉/*0x00000000,*/␉"GeForce 9800 GT" },␊
␉{ 0x10DE0606,␉/*0x00000000,*/␉"GeForce 8800 GS" },␊
␉{ 0x10DE0607,␉/*0x00000000,*/␉"GeForce GTS 240" },␊
␉{ 0x10DE0608,␉/*0x00000000,*/␉"GeForce 9800M GTX" },␊
␉{ 0x10DE0609,␉/*0x00000000,*/␉"GeForce 8800M GTS" },␊
␉{ 0x10DE060A,␉/*0x00000000,*/␉"GeForce GTX 280M" },␊
␉{ 0x10DE060B,␉/*0x00000000,*/␉"GeForce 9800M GT" },␊
␉{ 0x10DE060C,␉/*0x00000000,*/␉"GeForce 8800M GTX" },␊
␉{ 0x10DE060D,␉/*0x00000000,*/␉"GeForce 8800 GS" },␊
␉{ 0x10DE060F,␉/*0x00000000,*/␉"GeForce GTX 285M" },␊
␉{ 0x10DE0600,␉"GeForce 8800 GTS 512" },␊
␉{ 0x10DE0601,␉"GeForce 9800 GT" },␊
␉{ 0x10DE0602,␉"GeForce 8800 GT" },␊
␉{ 0x10DE0603,␉"GeForce GT 230" },␊
␉{ 0x10DE0604,␉"GeForce 9800 GX2" },␊
␉{ 0x10DE0605,␉"GeForce 9800 GT" },␊
␉{ 0x10DE0606,␉"GeForce 8800 GS" },␊
␉{ 0x10DE0607,␉"GeForce GTS 240" },␊
␉{ 0x10DE0608,␉"GeForce 9800M GTX" },␊
␉{ 0x10DE0609,␉"GeForce 8800M GTS" },␊
␉{ 0x10DE060A,␉"GeForce GTX 280M" },␊
␉{ 0x10DE060B,␉"GeForce 9800M GT" },␊
␉{ 0x10DE060C,␉"GeForce 8800M GTX" },␊
␉{ 0x10DE060D,␉"GeForce 8800 GS" },␊
␉{ 0x10DE060F,␉"GeForce GTX 285M" },␊
␉// 0610 - 061F␊
␉{ 0x10DE0610,␉/*0x00000000,*/␉"GeForce 9600 GSO" },␊
␉{ 0x10DE0611,␉/*0x00000000,*/␉"GeForce 8800 GT" },␊
␉{ 0x10DE0612,␉/*0x00000000,*/␉"GeForce 9800 GTX" },␊
␉{ 0x10DE0613,␉/*0x00000000,*/␉"GeForce 9800 GTX+" },␊
␉{ 0x10DE0614,␉/*0x00000000,*/␉"GeForce 9800 GT" },␊
␉{ 0x10DE0615,␉/*0x00000000,*/␉"GeForce GTS 250" },␊
␉{ 0x10DE0617,␉/*0x00000000,*/␉"GeForce 9800M GTX" },␊
␉{ 0x10DE0610,␉"GeForce 9600 GSO" },␊
␉{ 0x10DE0611,␉"GeForce 8800 GT" },␊
␉{ 0x10DE0612,␉"GeForce 9800 GTX" },␊
␉{ 0x10DE0613,␉"GeForce 9800 GTX+" },␊
␉{ 0x10DE0614,␉"GeForce 9800 GT" },␊
␉{ 0x10DE0615,␉"GeForce GTS 250" },␊
␉{ 0x10DE0617,␉"GeForce 9800M GTX" },␊
␉/* START */␊
␉{ 0x10DE0618,␉/*0x00000000,*/␉"GeForce GTX 260M" },␊
␉{ 0x10DE0618,␉"GeForce GTX 260M" },␊
␉// { 0x10DE0618,␉0x1025028E,␉"GeForce GTX 260M" },␊
␉// { 0x10DE0618,␉0x102802A1,␉"GeForce GTX 260M" },␊
␉// { 0x10DE0618,␉0x102802A2,␉"GeForce GTX 260M" },␊
␉// { 0x10DE0618,␉0x15580577,␉"GeForce GTX 260M" },␊
␉// { 0x10DE0618,␉0x15580860,␉"GeForce GTX 260M" },␊
␉/* END */␊
␉{ 0x10DE0619,␉/*0x00000000,*/␉"Quadro FX 4700 X2" },␊
␉{ 0x10DE061A,␉/*0x00000000,*/␉"Quadro FX 3700" },␊
␉{ 0x10DE061B,␉/*0x00000000,*/␉"Quadro VX 200" },␊
␉{ 0x10DE061C,␉/*0x00000000,*/␉"Quadro FX 3600M" },␊
␉{ 0x10DE061D,␉/*0x00000000,*/␉"Quadro FX 2800M" },␊
␉{ 0x10DE061E,␉/*0x00000000,*/␉"Quadro FX 3700M" },␊
␉{ 0x10DE061F,␉/*0x00000000,*/␉"Quadro FX 3800M" },␊
␉{ 0x10DE0619,␉"Quadro FX 4700 X2" },␊
␉{ 0x10DE061A,␉"Quadro FX 3700" },␊
␉{ 0x10DE061B,␉"Quadro VX 200" },␊
␉{ 0x10DE061C,␉"Quadro FX 3600M" },␊
␉{ 0x10DE061D,␉"Quadro FX 2800M" },␊
␉{ 0x10DE061E,␉"Quadro FX 3700M" },␊
␉{ 0x10DE061F,␉"Quadro FX 3800M" },␊
␉// 0620 - 062F␊
␉{ 0x10DE0620,␉/*0x00000000,*/␉"NVIDIA G94" }, // GeForce 8100/8200/8300␊
␉{ 0x10DE0621,␉/*0x00000000,*/␉"GeForce GT 230" },␊
␉{ 0x10DE0622,␉/*0x00000000,*/␉"GeForce 9600 GT" },␊
␉{ 0x10DE0623,␉/*0x00000000,*/␉"GeForce 9600 GS" },␊
␉{ 0x10DE0624,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0625,␉/*0x00000000,*/␉"GeForce 9600 GSO 512"},␊
␉{ 0x10DE0626,␉/*0x00000000,*/␉"GeForce GT 130" },␊
␉{ 0x10DE0627,␉/*0x00000000,*/␉"GeForce GT 140" },␊
␉{ 0x10DE0628,␉/*0x00000000,*/␉"GeForce 9800M GTS" },␊
␉{ 0x10DE0629,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE062A,␉/*0x00000000,*/␉"GeForce 9700M GTS" },␊
␉{ 0x10DE062B,␉/*0x00000000,*/␉"GeForce 9800M GS" },␊
␉{ 0x10DE062C,␉/*0x00000000,*/␉"GeForce 9800M GTS" },␊
␉{ 0x10DE062D,␉/*0x00000000,*/␉"GeForce 9600 GT" },␊
␉{ 0x10DE062E,␉/*0x00000000,*/␉"GeForce 9600 GT" },␊
␉{ 0x10DE062F,␉/*0x00000000,*/␉"GeForce 9800 S" },␊
␉{ 0x10DE0620,␉"NVIDIA G94" }, // GeForce 8100/8200/8300␊
␉{ 0x10DE0621,␉"GeForce GT 230" },␊
␉{ 0x10DE0622,␉"GeForce 9600 GT" },␊
␉{ 0x10DE0623,␉"GeForce 9600 GS" },␊
␉{ 0x10DE0624,␉"NVIDIA G94" },␊
␉{ 0x10DE0625,␉"GeForce 9600 GSO 512"},␊
␉{ 0x10DE0626,␉"GeForce GT 130" },␊
␉{ 0x10DE0627,␉"GeForce GT 140" },␊
␉{ 0x10DE0628,␉"GeForce 9800M GTS" },␊
␉{ 0x10DE0629,␉"NVIDIA G94" },␊
␉{ 0x10DE062A,␉"GeForce 9700M GTS" },␊
␉{ 0x10DE062B,␉"GeForce 9800M GS" },␊
␉{ 0x10DE062C,␉"GeForce 9800M GTS" },␊
␉{ 0x10DE062D,␉"GeForce 9600 GT" },␊
␉{ 0x10DE062E,␉"GeForce 9600 GT" },␊
␉{ 0x10DE062F,␉"GeForce 9800 S" },␊
␉// 0630 - 063F␊
␉{ 0x10DE0630,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0631,␉/*0x00000000,*/␉"GeForce GTS 160M" },␊
␉{ 0x10DE0632,␉/*0x00000000,*/␉"GeForce GTS 150M" },␊
␉{ 0x10DE0633,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0634,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0635,␉/*0x00000000,*/␉"GeForce 9600 GSO" },␊
␉{ 0x10DE0636,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0637,␉/*0x00000000,*/␉"GeForce 9600 GT" },␊
␉{ 0x10DE0638,␉/*0x00000000,*/␉"Quadro FX 1800" },␊
␉{ 0x10DE0639,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE063A,␉/*0x00000000,*/␉"Quadro FX 2700M" },␊
␉{ 0x10DE063B,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE063C,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE063D,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE063E,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE063F,␉/*0x00000000,*/␉"NVIDIA G94" },␊
␉{ 0x10DE0630,␉"NVIDIA G94" },␊
␉{ 0x10DE0631,␉"GeForce GTS 160M" },␊
␉{ 0x10DE0632,␉"GeForce GTS 150M" },␊
␉{ 0x10DE0633,␉"NVIDIA G94" },␊
␉{ 0x10DE0634,␉"NVIDIA G94" },␊
␉{ 0x10DE0635,␉"GeForce 9600 GSO" },␊
␉{ 0x10DE0636,␉"NVIDIA G94" },␊
␉{ 0x10DE0637,␉"GeForce 9600 GT" },␊
␉{ 0x10DE0638,␉"Quadro FX 1800" },␊
␉{ 0x10DE0639,␉"NVIDIA G94" },␊
␉{ 0x10DE063A,␉"Quadro FX 2700M" },␊
␉{ 0x10DE063B,␉"NVIDIA G94" },␊
␉{ 0x10DE063C,␉"NVIDIA G94" },␊
␉{ 0x10DE063D,␉"NVIDIA G94" },␊
␉{ 0x10DE063E,␉"NVIDIA G94" },␊
␉{ 0x10DE063F,␉"NVIDIA G94" },␊
␉// 0640 - 064F␊
␉{ 0x10DE0640,␉/*0x00000000,*/␉"GeForce 9500 GT" },␊
␉{ 0x10DE0641,␉/*0x00000000,*/␉"GeForce 9400 GT" },␊
␉{ 0x10DE0642,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE0643,␉/*0x00000000,*/␉"GeForce 9500 GT" },␊
␉{ 0x10DE0644,␉/*0x00000000,*/␉"GeForce 9500 GS" },␊
␉{ 0x10DE0645,␉/*0x00000000,*/␉"GeForce 9500 GS" },␊
␉{ 0x10DE0646,␉/*0x00000000,*/␉"GeForce GT 120" },␊
␉{ 0x10DE0647,␉/*0x00000000,*/␉"GeForce 9600M GT" },␊
␉{ 0x10DE0648,␉/*0x00000000,*/␉"GeForce 9600M GS" },␊
␉{ 0x10DE0649,␉/*0x00000000,*/␉"GeForce 9600M GT" },␊
␉{ 0x10DE064A,␉/*0x00000000,*/␉"GeForce 9700M GT" },␊
␉{ 0x10DE064B,␉/*0x00000000,*/␉"GeForce 9500M G" },␊
␉{ 0x10DE064C,␉/*0x00000000,*/␉"GeForce 9650M GT" },␊
␉{ 0x10DE0640,␉"GeForce 9500 GT" },␊
␉{ 0x10DE0641,␉"GeForce 9400 GT" },␊
␉{ 0x10DE0642,␉"GeForce 8400 GS" },␊
␉{ 0x10DE0643,␉"GeForce 9500 GT" },␊
␉{ 0x10DE0644,␉"GeForce 9500 GS" },␊
␉{ 0x10DE0645,␉"GeForce 9500 GS" },␊
␉{ 0x10DE0646,␉"GeForce GT 120" },␊
␉{ 0x10DE0647,␉"GeForce 9600M GT" },␊
␉{ 0x10DE0648,␉"GeForce 9600M GS" },␊
␉{ 0x10DE0649,␉"GeForce 9600M GT" },␊
␉{ 0x10DE064A,␉"GeForce 9700M GT" },␊
␉{ 0x10DE064B,␉"GeForce 9500M G" },␊
␉{ 0x10DE064C,␉"GeForce 9650M GT" },␊
␉// 0650 - 065F␊
␉{ 0x10DE0650,␉/*0x00000000,*/␉"NVIDIA G96-825" },␊
␉{ 0x10DE0651,␉/*0x00000000,*/␉"GeForce G 110M" },␊
␉{ 0x10DE0652,␉/*0x00000000,*/␉"GeForce GT 130M" },␊
␉{ 0x10DE0653,␉/*0x00000000,*/␉"GeForce GT 120M" },␊
␉{ 0x10DE0654,␉/*0x00000000,*/␉"GeForce GT 220M" },␊
␉{ 0x10DE0655,␉/*0x00000000,*/␉"GeForce GT 120" },␊
␉{ 0x10DE0656,␉/*0x00000000,*/␉"GeForce 9650 S" },␊
␉{ 0x10DE0657,␉/*0x00000000,*/␉"NVIDIA G96" },␊
␉{ 0x10DE0658,␉/*0x00000000,*/␉"Quadro FX 380" },␊
␉{ 0x10DE0659,␉/*0x00000000,*/␉"Quadro FX 580" },␊
␉{ 0x10DE065A,␉/*0x00000000,*/␉"Quadro FX 1700M" },␊
␉{ 0x10DE065B,␉/*0x00000000,*/␉"GeForce 9400 GT" },␊
␉{ 0x10DE065C,␉/*0x00000000,*/␉"Quadro FX 770M" },␊
␉{ 0x10DE065D,␉/*0x00000000,*/␉"NVIDIA G96" },␊
␉{ 0x10DE065E,␉/*0x00000000,*/␉"NVIDIA G96" },␊
␉{ 0x10DE065F,␉/*0x00000000,*/␉"GeForce G210" },␊
␉{ 0x10DE0650,␉"NVIDIA G96-825" },␊
␉{ 0x10DE0651,␉"GeForce G 110M" },␊
␉{ 0x10DE0652,␉"GeForce GT 130M" },␊
␉{ 0x10DE0653,␉"GeForce GT 120M" },␊
␉{ 0x10DE0654,␉"GeForce GT 220M" },␊
␉{ 0x10DE0655,␉"GeForce GT 120" },␊
␉{ 0x10DE0656,␉"GeForce 9650 S" },␊
␉{ 0x10DE0657,␉"NVIDIA G96" },␊
␉{ 0x10DE0658,␉"Quadro FX 380" },␊
␉{ 0x10DE0659,␉"Quadro FX 580" },␊
␉{ 0x10DE065A,␉"Quadro FX 1700M" },␊
␉{ 0x10DE065B,␉"GeForce 9400 GT" },␊
␉{ 0x10DE065C,␉"Quadro FX 770M" },␊
␉{ 0x10DE065D,␉"NVIDIA G96" },␊
␉{ 0x10DE065E,␉"NVIDIA G96" },␊
␉{ 0x10DE065F,␉"GeForce G210" },␊
␉// 0660 - 066F␊
␉// 0670 - 067F␊
␉// 0680 - 068F␊
␉// 0690 - 069F␊
␉// 06A0 - 06AF␊
␉{ 0x10DE06A0,␉/*0x00000000,*/␉"NVIDIA GT214" },␊
␉{ 0x10DE06A0,␉"NVIDIA GT214" },␊
␉// 06B0 - 06BF␊
␉{ 0x10DE06B0,␉/*0x00000000,*/␉"NVIDIA GT214" },␊
␉{ 0x10DE06B0,␉"NVIDIA GT214" },␊
␉// 06C0 - 06CF␊
␉{ 0x10DE06C0,␉/*0x00000000,*/␉"GeForce GTX 480" },␊
␉{ 0x10DE06C3,␉/*0x00000000,*/␉"GeForce GTX D12U" },␊
␉{ 0x10DE06C4,␉/*0x00000000,*/␉"GeForce GTX 465" },␊
␉{ 0x10DE06CA,␉/*0x00000000,*/␉"GeForce GTX 480M" },␊
␉{ 0x10DE06CD,␉/*0x00000000,*/␉"GeForce GTX 470" },␊
␉{ 0x10DE06C0,␉"GeForce GTX 480" },␊
␉{ 0x10DE06C3,␉"GeForce GTX D12U" },␊
␉{ 0x10DE06C4,␉"GeForce GTX 465" },␊
␉{ 0x10DE06CA,␉"GeForce GTX 480M" },␊
␉{ 0x10DE06CD,␉"GeForce GTX 470" },␊
␉// 06D0 - 06DF␊
␉/* START */␊
␉{ 0x10DE06D1,␉/*0x00000000,*/␉"Tesla C2050 / C2070" },␊
␉{ 0x10DE06D1,␉"Tesla C2050 / C2070" },␊
␉// { 0x10DE06D1,␉0x10DE0771,␉"Tesla C2050" },␊
␉// { 0x10DE06D1,␉0x10DE0772,␉"Tesla C2070" },␊
␉{ 0x10DE06D2,␉/*0x00000000,*/␉"Tesla M2070 / X2070" },␊
␉{ 0x10DE06D2,␉"Tesla M2070 / X2070" },␊
␉// { 0x10DE06D2,␉0x10DE0774,␉"Tesla M2070" },␊
␉// { 0x10DE06D2,␉0x10DE0830,␉"Tesla M2070" },␊
␉// { 0x10DE06D2,␉0x10DE0842,␉"Tesla M2070" },␊
␉// { 0x10DE06D2,␉0x10DE088F,␉"Tesla X2070" },␊
␉// { 0x10DE06D2,␉0x10DE0908,␉"Tesla M2070" },␊
␉/* END */␊
␉{ 0x10DE06D8,␉/*0x00000000,*/␉"Quadro 6000" },␊
␉{ 0x10DE06D9,␉/*0x00000000,*/␉"Quadro 5000" },␊
␉{ 0x10DE06DA,␉/*0x00000000,*/␉"Quadro 5000M" },␊
␉{ 0x10DE06DC,␉/*0x00000000,*/␉"Quadro 6000" },␊
␉{ 0x10DE06DD,␉/*0x00000000,*/␉"Quadro 4000" },␊
␉{ 0x10DE06DE,␉/*0x00000000,*/␉"Tesla M2050" },␉// TODO: sub-device id: 0x0846␊
␉{ 0x10DE06DE,␉/*0x00000000,*/␉"Tesla M2070" },␉// TODO: sub-device id: ?␉␊
␉{ 0x10DE06DF,␉/*0x00000000,*/␉"Tesla M2070-Q" },␊
␉{ 0x10DE06D8,␉"Quadro 6000" },␊
␉{ 0x10DE06D9,␉"Quadro 5000" },␊
␉{ 0x10DE06DA,␉"Quadro 5000M" },␊
␉{ 0x10DE06DC,␉"Quadro 6000" },␊
␉{ 0x10DE06DD,␉"Quadro 4000" },␊
␉{ 0x10DE06DE,␉"Tesla M2050" },␉// TODO: sub-device id: 0x0846␊
␉{ 0x10DE06DE,␉"Tesla M2070" },␉// TODO: sub-device id: ?␉␊
␉{ 0x10DE06DF,␉"Tesla M2070-Q" },␊
␉// 0x10DE06DE also applies to misc S2050, X2070, M2050, M2070␊
␉// 06E0 - 06EF␊
␉{ 0x10DE06E0,␉/*0x00000000,*/␉"GeForce 9300 GE" },␊
␉{ 0x10DE06E1,␉/*0x00000000,*/␉"GeForce 9300 GS" },␊
␉{ 0x10DE06E2,␉/*0x00000000,*/␉"GeForce 8400" },␊
␉{ 0x10DE06E3,␉/*0x00000000,*/␉"GeForce 8400 SE" },␊
␉{ 0x10DE06E4,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE06E5,␉/*0x00000000,*/␉"GeForce 9300M GS" },␊
␉{ 0x10DE06E6,␉/*0x00000000,*/␉"GeForce G100" },␊
␉{ 0x10DE06E7,␉/*0x00000000,*/␉"GeForce 9300 SE" },␊
␉{ 0x10DE06E8,␉/*0x00000000,*/␉"GeForce 9200M GS" },␊
␉{ 0x10DE06E9,␉/*0x00000000,*/␉"GeForce 9300M GS" },␊
␉{ 0x10DE06EA,␉/*0x00000000,*/␉"Quadro NVS 150M" },␊
␉{ 0x10DE06EB,␉/*0x00000000,*/␉"Quadro NVS 160M" },␊
␉{ 0x10DE06EC,␉/*0x00000000,*/␉"GeForce G 105M" },␊
␉{ 0x10DE06ED,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06EF,␉/*0x00000000,*/␉"GeForce G 103M" },␊
␉{ 0x10DE06E0,␉"GeForce 9300 GE" },␊
␉{ 0x10DE06E1,␉"GeForce 9300 GS" },␊
␉{ 0x10DE06E2,␉"GeForce 8400" },␊
␉{ 0x10DE06E3,␉"GeForce 8400 SE" },␊
␉{ 0x10DE06E4,␉"GeForce 8400 GS" },␊
␉{ 0x10DE06E5,␉"GeForce 9300M GS" },␊
␉{ 0x10DE06E6,␉"GeForce G100" },␊
␉{ 0x10DE06E7,␉"GeForce 9300 SE" },␊
␉{ 0x10DE06E8,␉"GeForce 9200M GS" },␊
␉{ 0x10DE06E9,␉"GeForce 9300M GS" },␊
␉{ 0x10DE06EA,␉"Quadro NVS 150M" },␊
␉{ 0x10DE06EB,␉"Quadro NVS 160M" },␊
␉{ 0x10DE06EC,␉"GeForce G 105M" },␊
␉{ 0x10DE06ED,␉"NVIDIA G98" },␊
␉{ 0x10DE06EF,␉"GeForce G 103M" },␊
␉// 06F0 - 06FF␊
␉{ 0x10DE06F0,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F1,␉/*0x00000000,*/␉"GeForce G105M" },␊
␉{ 0x10DE06F2,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F3,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F4,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F5,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F6,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F7,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06F8,␉/*0x00000000,*/␉"Quadro NVS 420" },␊
␉{ 0x10DE06F9,␉/*0x00000000,*/␉"Quadro FX 370 LP" },␊
␉{ 0x10DE06FA,␉/*0x00000000,*/␉"Quadro NVS 450" },␊
␉{ 0x10DE06FB,␉/*0x00000000,*/␉"Quadro FX 370M" },␊
␉{ 0x10DE06FC,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06FD,␉/*0x00000000,*/␉"Quadro NVS 295" },␊
␉{ 0x10DE06FE,␉/*0x00000000,*/␉"NVIDIA G98" },␊
␉{ 0x10DE06FF,␉/*0x00000000,*/␉"HICx16 + Graphics" },␊
␉{ 0x10DE06F0,␉"NVIDIA G98" },␊
␉{ 0x10DE06F1,␉"GeForce G105M" },␊
␉{ 0x10DE06F2,␉"NVIDIA G98" },␊
␉{ 0x10DE06F3,␉"NVIDIA G98" },␊
␉{ 0x10DE06F4,␉"NVIDIA G98" },␊
␉{ 0x10DE06F5,␉"NVIDIA G98" },␊
␉{ 0x10DE06F6,␉"NVIDIA G98" },␊
␉{ 0x10DE06F7,␉"NVIDIA G98" },␊
␉{ 0x10DE06F8,␉"Quadro NVS 420" },␊
␉{ 0x10DE06F9,␉"Quadro FX 370 LP" },␊
␉{ 0x10DE06FA,␉"Quadro NVS 450" },␊
␉{ 0x10DE06FB,␉"Quadro FX 370M" },␊
␉{ 0x10DE06FC,␉"NVIDIA G98" },␊
␉{ 0x10DE06FD,␉"Quadro NVS 295" },␊
␉{ 0x10DE06FE,␉"NVIDIA G98" },␊
␉{ 0x10DE06FF,␉"HICx16 + Graphics" },␊
␉// 0700 - 070F␊
␉// 0710 - 071F␊
␉// 0720 - 072F␊
␉// 07C0 - 07CF␊
␉// 07D0 - 07DF␊
␉// 07E0 - 07EF␊
␉{ 0x10DE07E0,␉/*0x00000000,*/␉"GeForce 7150 / nForce 630i" },␊
␉{ 0x10DE07E1,␉/*0x00000000,*/␉"GeForce 7100 / nForce 630i" },␊
␉{ 0x10DE07E2,␉/*0x00000000,*/␉"GeForce 7050 / nForce 630i" },␊
␉{ 0x10DE07E3,␉/*0x00000000,*/␉"GeForce 7050 / nForce 610i" },␊
␉{ 0x10DE07E5,␉/*0x00000000,*/␉"GeForce 7050 / nForce 620i" },␊
␉{ 0x10DE07E0,␉"GeForce 7150 / nForce 630i" },␊
␉{ 0x10DE07E1,␉"GeForce 7100 / nForce 630i" },␊
␉{ 0x10DE07E2,␉"GeForce 7050 / nForce 630i" },␊
␉{ 0x10DE07E3,␉"GeForce 7050 / nForce 610i" },␊
␉{ 0x10DE07E5,␉"GeForce 7050 / nForce 620i" },␊
␉// 07F0 - 07FF␊
␉// 0800 - 080F␊
␉// 0810 - 081F␊
␉// 0820 - 082F␊
␉// 0830 - 083F␊
␉// 0840 - 084F␊
␉{ 0x10DE0840,␉/*0x00000000,*/␉"GeForce 8200M" },␊
␉{ 0x10DE0844,␉/*0x00000000,*/␉"GeForce 9100M G" },␊
␉{ 0x10DE0845,␉/*0x00000000,*/␉"GeForce 8200M G" },␊
␉{ 0x10DE0846,␉/*0x00000000,*/␉"GeForce 9200" },␊
␉{ 0x10DE0847,␉/*0x00000000,*/␉"GeForce 9100" },␊
␉{ 0x10DE0848,␉/*0x00000000,*/␉"GeForce 8300" },␊
␉{ 0x10DE0849,␉/*0x00000000,*/␉"GeForce 8200" },␊
␉{ 0x10DE084A,␉/*0x00000000,*/␉"nForce 730a" },␊
␉{ 0x10DE084B,␉/*0x00000000,*/␉"GeForce 9200" },␊
␉{ 0x10DE084C,␉/*0x00000000,*/␉"nForce 980a/780a SLI" },␊
␉{ 0x10DE084D,␉/*0x00000000,*/␉"nForce 750a SLI" },␊
␉{ 0x10DE084F,␉/*0x00000000,*/␉"GeForce 8100 / nForce 720a" },␊
␉{ 0x10DE0840,␉"GeForce 8200M" },␊
␉{ 0x10DE0844,␉"GeForce 9100M G" },␊
␉{ 0x10DE0845,␉"GeForce 8200M G" },␊
␉{ 0x10DE0846,␉"GeForce 9200" },␊
␉{ 0x10DE0847,␉"GeForce 9100" },␊
␉{ 0x10DE0848,␉"GeForce 8300" },␊
␉{ 0x10DE0849,␉"GeForce 8200" },␊
␉{ 0x10DE084A,␉"nForce 730a" },␊
␉{ 0x10DE084B,␉"GeForce 9200" },␊
␉{ 0x10DE084C,␉"nForce 980a/780a SLI" },␊
␉{ 0x10DE084D,␉"nForce 750a SLI" },␊
␉{ 0x10DE084F,␉"GeForce 8100 / nForce 720a" },␊
␉// 0850 - 085F␊
␉// 0860 - 086F␊
␉{ 0x10DE0860,␉/*0x00000000,*/␉"GeForce 9300" },␊
␉{ 0x10DE0861,␉/*0x00000000,*/␉"GeForce 9400" },␊
␉{ 0x10DE0862,␉/*0x00000000,*/␉"GeForce 9400M G" },␊
␉{ 0x10DE0863,␉/*0x00000000,*/␉"GeForce 9400M" },␊
␉{ 0x10DE0864,␉/*0x00000000,*/␉"GeForce 9300" },␊
␉{ 0x10DE0865,␉/*0x00000000,*/␉"GeForce 9300" },␊
␉{ 0x10DE0866,␉/*0x00000000,*/␉"GeForce 9400M G" },␊
␉{ 0x10DE0867,␉/*0x00000000,*/␉"GeForce 9400" },␊
␉{ 0x10DE0868,␉/*0x00000000,*/␉"nForce 760i SLI" },␊
␉{ 0x10DE0869,␉/*0x00000000,*/␉"GeForce 9400" },␊
␉{ 0x10DE086A,␉/*0x00000000,*/␉"GeForce 9400" },␊
␉{ 0x10DE086C,␉/*0x00000000,*/␉"GeForce 9300 / nForce 730i" },␊
␉{ 0x10DE086D,␉/*0x00000000,*/␉"GeForce 9200" },␊
␉{ 0x10DE086E,␉/*0x00000000,*/␉"GeForce 9100M G" },␊
␉{ 0x10DE086F,␉/*0x00000000,*/␉"GeForce 8200M G" },␊
␉{ 0x10DE0860,␉"GeForce 9300" },␊
␉{ 0x10DE0861,␉"GeForce 9400" },␊
␉{ 0x10DE0862,␉"GeForce 9400M G" },␊
␉{ 0x10DE0863,␉"GeForce 9400M" },␊
␉{ 0x10DE0864,␉"GeForce 9300" },␊
␉{ 0x10DE0865,␉"GeForce 9300" },␊
␉{ 0x10DE0866,␉"GeForce 9400M G" },␊
␉{ 0x10DE0867,␉"GeForce 9400" },␊
␉{ 0x10DE0868,␉"nForce 760i SLI" },␊
␉{ 0x10DE0869,␉"GeForce 9400" },␊
␉{ 0x10DE086A,␉"GeForce 9400" },␊
␉{ 0x10DE086C,␉"GeForce 9300 / nForce 730i" },␊
␉{ 0x10DE086D,␉"GeForce 9200" },␊
␉{ 0x10DE086E,␉"GeForce 9100M G" },␊
␉{ 0x10DE086F,␉"GeForce 8200M G" },␊
␉// 0870 - 087F␊
␉{ 0x10DE0870,␉/*0x00000000,*/␉"GeForce 9400M" },␊
␉{ 0x10DE0871,␉/*0x00000000,*/␉"GeForce 9200" },␊
␉{ 0x10DE0872,␉/*0x00000000,*/␉"GeForce G102M" },␊
␉{ 0x10DE0873,␉/*0x00000000,*/␉"GeForce G102M" },␊
␉{ 0x10DE0874,␉/*0x00000000,*/␉"ION 9300M" },␉␊
␉{ 0x10DE0876,␉/*0x00000000,*/␉"ION 9400M" }, //␊
␉{ 0x10DE087A,␉/*0x00000000,*/␉"GeForce 9400" },␊
␉{ 0x10DE087D,␉/*0x00000000,*/␉"ION 9400M" },␊
␉{ 0x10DE087E,␉/*0x00000000,*/␉"ION LE" },␊
␉{ 0x10DE087F,␉/*0x00000000,*/␉"ION LE" },␊
␉{ 0x10DE0870,␉"GeForce 9400M" },␊
␉{ 0x10DE0871,␉"GeForce 9200" },␊
␉{ 0x10DE0872,␉"GeForce G102M" },␊
␉{ 0x10DE0873,␉"GeForce G102M" },␊
␉{ 0x10DE0874,␉"ION 9300M" },␉␊
␉{ 0x10DE0876,␉"ION 9400M" },␊
␉{ 0x10DE087A,␉"GeForce 9400" },␊
␉{ 0x10DE087D,␉"ION 9400M" },␊
␉{ 0x10DE087E,␉"ION LE" },␊
␉{ 0x10DE087F,␉"ION LE" },␊
␉// 0880 - 088F␊
␉// 0890 - 089F␊
␉// 08A0 - 08AF␊
␉{ 0x10DE08A0,␉/*0x00000000,*/␉"GeForce 320M" },␊
␉// { 0x10DE08A1,␉/*0x00000000,*/␉"NVIDIA MCP89-MZT" },␊
␉// { 0x10DE08A2,␉/*0x00000000,*/␉"NVIDIA MCP89-EPT" },␊
␉{ 0x10DE08A3,␉/*0x00000000,*/␉"GeForce 320M" },␊
␉{ 0x10DE08A4,␉/*0x00000000,*/␉"GeForce 320M" },␊
␉{ 0x10DE08A5,␉/*0x00000000,*/␉"GeForce 320M" },␊
␉{ 0x10DE08A0,␉"GeForce 320M" },␊
␉// { 0x10DE08A1,␉"NVIDIA MCP89-MZT" },␊
␉// { 0x10DE08A2,␉"NVIDIA MCP89-EPT" },␊
␉{ 0x10DE08A3,␉"GeForce 320M" },␊
␉{ 0x10DE08A4,␉"GeForce 320M" },␊
␉{ 0x10DE08A5,␉"GeForce 320M" },␊
␉// 08B0 - 08BF␊
␉// { 0x10DE08B0,␉/*0x00000000,*/␉"MCP83 MMD" },␊
␉{ 0x10DE08B1,␉/*0x00000000,*/␉"GeForce 300M" },␊
␉// { 0x10DE08B2,␉/*0x00000000,*/␉"NVIDIA MCP83-MJ" },␊
␉// { 0x10DE08B3,␉/*0x00000000,*/␉"NVIDIA MCP89 MM9" },␊
␉// { 0x10DE08B0,␉"MCP83 MMD" },␊
␉{ 0x10DE08B1,␉"GeForce 300M" },␊
␉// { 0x10DE08B2,␉"NVIDIA MCP83-MJ" },␊
␉// { 0x10DE08B3,␉"NVIDIA MCP89 MM9" },␊
␉// 08C0 - 08CF␊
␉// 08D0 - 08DF␊
␉// 08E0 - 08EF␊
␉// 09E0 - 09EF␊
␉// 09F0 - 09FF␊
␉// 0A00 - 0A0F␊
␉// { 0x10DE0A00,␉/*0x00000000,*/␉"NVIDIA GT212" },␊
␉// { 0x10DE0A00,␉"NVIDIA GT212" },␊
␉// 0A10 - 0A1F␊
␉// { 0x10DE0A10,␉/*0x00000000,*/␉"NVIDIA GT212" },␊
␉// { 0x10DE0A10,␉"NVIDIA GT212" },␊
␉// 0A20 - 0A2F␊
␉{ 0x10DE0A20,␉/*0x00000000,*/␉"GeForce GT 220" }, // subsystem 10de:0a20:1043:8311␊
␉// { 0x10DE0A21,␉/*0x00000000,*/␉"NVIDIA D10M2-20" },␊
␉{ 0x10DE0A22,␉/*0x00000000,*/␉"GeForce 315" },␊
␉{ 0x10DE0A23,␉/*0x00000000,*/␉"GeForce 210" },␊
␉{ 0x10DE0A26,␉/*0x00000000,*/␉"GeForce 405" },␊
␉{ 0x10DE0A27,␉/*0x00000000,*/␉"GeForce 405" },␊
␉{ 0x10DE0A28,␉/*0x00000000,*/␉"GeForce GT 230M" },␊
␉{ 0x10DE0A29,␉/*0x00000000,*/␉"GeForce GT 330M" },␊
␉{ 0x10DE0A2A,␉/*0x00000000,*/␉"GeForce GT 230M" },␊
␉{ 0x10DE0A2B,␉/*0x00000000,*/␉"GeForce GT 330M" },␊
␉{ 0x10DE0A2C,␉/*0x00000000,*/␉"NVS 5100M" },␊
␉{ 0x10DE0A2D,␉/*0x00000000,*/␉"GeForce GT 320M" },␉␊
␉{ 0x10DE0A20,␉"GeForce GT 220" },␊
␉// { 0x10DE0A21,␉"NVIDIA D10M2-20" },␊
␉{ 0x10DE0A22,␉"GeForce 315" },␊
␉{ 0x10DE0A23,␉"GeForce 210" },␊
␉{ 0x10DE0A26,␉"GeForce 405" },␊
␉{ 0x10DE0A27,␉"GeForce 405" },␊
␉{ 0x10DE0A28,␉"GeForce GT 230M" },␊
␉{ 0x10DE0A29,␉"GeForce GT 330M" },␊
␉{ 0x10DE0A2A,␉"GeForce GT 230M" },␊
␉{ 0x10DE0A2B,␉"GeForce GT 330M" },␊
␉{ 0x10DE0A2C,␉"NVS 5100M" },␊
␉{ 0x10DE0A2D,␉"GeForce GT 320M" },␉␊
␉// 0A30 - 0A3F␊
␉// { 0x10DE0A30,␉/*0x00000000,*/␉"NVIDIA GT216" },␊
␉{ 0x10DE0A32,␉/*0x00000000,*/␉"GeForce GT 415" },␊
␉{ 0x10DE0A34,␉/*0x00000000,*/␉"GeForce GT 240M" },␊
␉{ 0x10DE0A35,␉/*0x00000000,*/␉"GeForce GT 325M" },␊
␉{ 0x10DE0A38,␉/*0x00000000,*/␉"Quadro 400" },␊
␉{ 0x10DE0A3C,␉/*0x00000000,*/␉"Quadro FX 880M" },␊
␉// { 0x10DE0A3D,␉/*0x00000000,*/␉"NVIDIA N10P-ES" },␊
␉// { 0x10DE0A3F,␉/*0x00000000,*/␉"NVIDIA GT216-INT" },␊
␉// { 0x10DE0A30,␉"NVIDIA GT216" },␊
␉{ 0x10DE0A32,␉"GeForce GT 415" },␊
␉{ 0x10DE0A34,␉"GeForce GT 240M" },␊
␉{ 0x10DE0A35,␉"GeForce GT 325M" },␊
␉{ 0x10DE0A38,␉"Quadro 400" },␊
␉{ 0x10DE0A3C,␉"Quadro FX 880M" },␊
␉// { 0x10DE0A3D,␉"NVIDIA N10P-ES" },␊
␉// { 0x10DE0A3F,␉"NVIDIA GT216-INT" },␊
␉// 0A40 - 0A4F␊
␉// 0A50 - 0A5F␊
␉// 0A60 - 0A6F␊
␉{ 0x10DE0A60,␉/*0x00000000,*/␉"GeForce G210" },␊
␉// { 0x10DE0A61,␉/*0x00000000,*/␉"NVIDIA NVS 2100" },␊
␉{ 0x10DE0A62,␉/*0x00000000,*/␉"GeForce 205" },␊
␉{ 0x10DE0A63,␉/*0x00000000,*/␉"GeForce 310" },␊
␉{ 0x10DE0A64,␉/*0x00000000,*/␉"ION" },␊
␉{ 0x10DE0A65,␉/*0x00000000,*/␉"GeForce 210" }, // subsystem 10de:0a65:1043:8334␊
␉{ 0x10DE0A66,␉/*0x00000000,*/␉"GeForce 310" },␊
␉{ 0x10DE0A67,␉/*0x00000000,*/␉"GeForce 315" },␊
␉{ 0x10DE0A68,␉/*0x00000000,*/␉"GeForce G105M" },␊
␉{ 0x10DE0A69,␉/*0x00000000,*/␉"GeForce G105M" },␊
␉{ 0x10DE0A6A,␉/*0x00000000,*/␉"NVS 2100M" },␊
␉{ 0x10DE0A6C,␉/*0x00000000,*/␉"NVS 3100M" }, // subsystem 10de:0a6c:1028:040b & 10de:0a6c:17aa:2142␊
␉{ 0x10DE0A6E,␉/*0x00000000,*/␉"GeForce 305M" },␊
␉{ 0x10DE0A6F,␉/*0x00000000,*/␉"ION" },␉␊
␉{ 0x10DE0A60,␉"GeForce G210" },␊
␉// { 0x10DE0A61,␉"NVIDIA NVS 2100" },␊
␉{ 0x10DE0A62,␉"GeForce 205" },␊
␉{ 0x10DE0A63,␉"GeForce 310" },␊
␉{ 0x10DE0A64,␉"ION" },␊
␉{ 0x10DE0A65,␉"GeForce 210" },␊
␉{ 0x10DE0A66,␉"GeForce 310" },␊
␉{ 0x10DE0A67,␉"GeForce 315" },␊
␉{ 0x10DE0A68,␉"GeForce G105M" },␊
␉{ 0x10DE0A69,␉"GeForce G105M" },␊
␉{ 0x10DE0A6A,␉"NVS 2100M" },␊
␉{ 0x10DE0A6C,␉"NVS 3100M" },␊
␉{ 0x10DE0A6E,␉"GeForce 305M" },␊
␉{ 0x10DE0A6F,␉"ION" },␉␊
␉// 0A70 - 0A7F␊
␉{ 0x10DE0A70,␉/*0x00000000,*/␉"GeForce 310M" },␊
␉{ 0x10DE0A71,␉/*0x00000000,*/␉"GeForce 305M" },␊
␉{ 0x10DE0A72,␉/*0x00000000,*/␉"GeForce 310M" },␊
␉{ 0x10DE0A73,␉/*0x00000000,*/␉"GeForce 305M" },␊
␉{ 0x10DE0A74,␉/*0x00000000,*/␉"GeForce G210M" },␊
␉{ 0x10DE0A75,␉/*0x00000000,*/␉"GeForce G310M" },␊
␉{ 0x10DE0A76,␉/*0x00000000,*/␉"ION" },␊
␉{ 0x10DE0A78,␉/*0x00000000,*/␉"Quadro FX 380 LP" },␊
␉// { 0x10DE0A79,␉/*0x00000000,*/␉"N12M-NS-S" },␊
␉{ 0x10DE0A7A,␉/*0x00000000,*/␉"GeForce 315M" },␊
␉{ 0x10DE0A7B,␉/*0x00000000,*/␉"GeForce 505" },␊
␉{ 0x10DE0A7C,␉/*0x00000000,*/␉"Quadro FX 380M" },␊
␉// { 0x10DE0A7D,␉/*0x00000000,*/␉"NVIDIA GT218-ES" },␊
␉// { 0x10DE0A7E,␉/*0x00000000,*/␉"NVIDIA GT218-INT-S" },␊
␉// { 0x10DE0A7F,␉/*0x00000000,*/␉"NVIDIA GT218-INT-B" },␊
␉{ 0x10DE0A70,␉"GeForce 310M" },␊
␉{ 0x10DE0A71,␉"GeForce 305M" },␊
␉{ 0x10DE0A72,␉"GeForce 310M" },␊
␉{ 0x10DE0A73,␉"GeForce 305M" },␊
␉{ 0x10DE0A74,␉"GeForce G210M" },␊
␉{ 0x10DE0A75,␉"GeForce G310M" },␊
␉{ 0x10DE0A76,␉"ION" },␊
␉{ 0x10DE0A78,␉"Quadro FX 380 LP" },␊
␉// { 0x10DE0A79,␉"N12M-NS-S" },␊
␉{ 0x10DE0A7A,␉"GeForce 315M" },␊
␉{ 0x10DE0A7B,␉"GeForce 505" },␊
␉{ 0x10DE0A7C,␉"Quadro FX 380M" },␊
␉// { 0x10DE0A7D,␉"NVIDIA GT218-ES" },␊
␉// { 0x10DE0A7E,␉"NVIDIA GT218-INT-S" },␊
␉// { 0x10DE0A7F,␉"NVIDIA GT218-INT-B" },␊
␉// 0A80 - 0A8F␊
␉// 0A90 - 0A9F␊
␉// 0AA0 - 0AAF␊
␉// 0C80 - 0C8F␊
␉// 0C90 - 0C9F␊
␉// 0CA0 - 0CAF␊
␉{ 0x10DE0CA0,␉/*0x00000000,*/␉"GeForce GT 330 " },␊
␉{ 0x10DE0CA2,␉/*0x00000000,*/␉"GeForce GT 320" },␊
␉{ 0x10DE0CA3,␉/*0x00000000,*/␉"GeForce GT 240" },␊
␉{ 0x10DE0CA4,␉/*0x00000000,*/␉"GeForce GT 340" },␊
␉{ 0x10DE0CA5,␉/*0x00000000,*/␉"GeForce GT 220" },␊
␉{ 0x10DE0CA7,␉/*0x00000000,*/␉"GeForce GT 330" },␊
␉{ 0x10DE0CA8,␉/*0x00000000,*/␉"GeForce GTS 260M" },␊
␉{ 0x10DE0CA9,␉/*0x00000000,*/␉"GeForce GTS 250M" },␊
␉{ 0x10DE0CAC,␉/*0x00000000,*/␉"GeForce GT 220" },␊
␉// { 0x10DE0CAD,␉/*0x00000000,*/␉"NVIDIA N10E-ES" },␊
␉// { 0x10DE0CAE,␉/*0x00000000,*/␉"NVIDIA GT215-INT" },␊
␉{ 0x10DE0CAF,␉/*0x00000000,*/␉"GeForce GT 335M" },␊
␉{ 0x10DE0CA0,␉"GeForce GT 330 " },␊
␉{ 0x10DE0CA2,␉"GeForce GT 320" },␊
␉{ 0x10DE0CA3,␉"GeForce GT 240" },␊
␉{ 0x10DE0CA4,␉"GeForce GT 340" },␊
␉{ 0x10DE0CA5,␉"GeForce GT 220" },␊
␉{ 0x10DE0CA7,␉"GeForce GT 330" },␊
␉{ 0x10DE0CA8,␉"GeForce GTS 260M" },␊
␉{ 0x10DE0CA9,␉"GeForce GTS 250M" },␊
␉{ 0x10DE0CAC,␉"GeForce GT 220" },␊
␉// { 0x10DE0CAD,␉"NVIDIA N10E-ES" },␊
␉// { 0x10DE0CAE,␉"NVIDIA GT215-INT" },␊
␉{ 0x10DE0CAF,␉"GeForce GT 335M" },␊
␉// 0CB0 - 0CBF␉␊
␉{ 0x10DE0CB0,␉/*0x00000000,*/␉"GeForce GTS 350M" },␊
␉{ 0x10DE0CB1,␉/*0x00000000,*/␉"GeForce GTS 360M" },␊
␉{ 0x10DE0CBC,␉/*0x00000000,*/␉"Quadro FX 1800M" },␊
␉{ 0x10DE0CB0,␉"GeForce GTS 350M" },␊
␉{ 0x10DE0CB1,␉"GeForce GTS 360M" },␊
␉{ 0x10DE0CBC,␉"Quadro FX 1800M" },␊
␉// 0CC0 - 0CCF␊
␉// 0CD0 - 0CDF␊
␉// 0CE0 - 0CEF␊
␉// 0DA0 - 0DAF␊
␉// 0DB0 - 0DBF␊
␉// 0DC0 - 0DCF␊
␉{ 0x10DE0DC0,␉/*0x00000000,*/␉"GeForce GT 440" },␊
␉// { 0x10DE0DC1,␉/*0x00000000,*/␉"D12-P1-35" },␊
␉// { 0x10DE0DC2,␉/*0x00000000,*/␉"D12-P1-35" },␊
␉{ 0x10DE0DC4,␉/*0x00000000,*/␉"GeForce GTS 450" },␊
␉{ 0x10DE0DC5,␉/*0x00000000,*/␉"GeForce GTS 450" },␊
␉{ 0x10DE0DC6,␉/*0x00000000,*/␉"GeForce GTS 450" },␊
␉// { 0x10DE0DCA,␉/*0x00000000,*/␉"GF10x" },␊
␉// { 0x10DE0DCC,␉/*0x00000000,*/␉"N12E-GS" },␊
␉{ 0x10DE0DCD,␉/*0x00000000,*/␉"GeForce GT 555M" },␊
␉{ 0x10DE0DCE,␉/*0x00000000,*/␉"GeForce GT 555M" },␊
␉// { 0x10DE0DCF,␉/*0x00000000,*/␉"N12P-GT-B" },␊
␉{ 0x10DE0DC0,␉"GeForce GT 440" },␊
␉// { 0x10DE0DC1,␉"D12-P1-35" },␊
␉// { 0x10DE0DC2,␉"D12-P1-35" },␊
␉{ 0x10DE0DC4,␉"GeForce GTS 450" },␊
␉{ 0x10DE0DC5,␉"GeForce GTS 450" },␊
␉{ 0x10DE0DC6,␉"GeForce GTS 450" },␊
␉// { 0x10DE0DCA,␉"GF10x" },␊
␉// { 0x10DE0DCC,␉"N12E-GS" },␊
␉{ 0x10DE0DCD,␉"GeForce GT 555M" },␊
␉{ 0x10DE0DCE,␉"GeForce GT 555M" },␊
␉// { 0x10DE0DCF,␉"N12P-GT-B" },␊
␉// 0DD0 - 0DDF␉␊
␉// { 0x10DE0DD0,␉/*0x00000000,*/␉"N11E-GT" },␊
␉{ 0x10DE0DD1,␉/*0x00000000,*/␉"GeForce GTX 460M" }, // subsystem 10de:0dd1:1558:8687␊
␉{ 0x10DE0DD2,␉/*0x00000000,*/␉"GeForce GT 445M" },␊
␉{ 0x10DE0DD3,␉/*0x00000000,*/␉"GeForce GT 435M" },␊
␉{ 0x10DE0DD6,␉/*0x00000000,*/␉"GeForce GT 550M" },␊
␉{ 0x10DE0DD8,␉/*0x00000000,*/␉"Quadro 2000" },␊
␉{ 0x10DE0DDA,␉/*0x00000000,*/␉"Quadro 2000M" },␊
␉// { 0x10DE0DDE,␉/*0x00000000,*/␉"GF106-ES" },␊
␉// { 0x10DE0DDF,␉/*0x00000000,*/␉"GF106-INT" },␊
␉// { 0x10DE0DD0,␉"N11E-GT" },␊
␉{ 0x10DE0DD1,␉"GeForce GTX 460M" },␊
␉{ 0x10DE0DD2,␉"GeForce GT 445M" },␊
␉{ 0x10DE0DD3,␉"GeForce GT 435M" },␊
␉{ 0x10DE0DD6,␉"GeForce GT 550M" },␊
␉{ 0x10DE0DD8,␉"Quadro 2000" },␊
␉{ 0x10DE0DDA,␉"Quadro 2000M" },␊
␉// { 0x10DE0DDE,␉"GF106-ES" },␊
␉// { 0x10DE0DDF,␉"GF106-INT" },␊
␉// 0DE0 - 0DEF␊
␉{ 0x10DE0DE0,␉/*0x00000000,*/␉"GeForce GT 440" },␊
␉{ 0x10DE0DE1,␉/*0x00000000,*/␉"GeForce GT 430" }, // subsystem 10de:0de1:3842:1430␊
␉{ 0x10DE0DE2,␉/*0x00000000,*/␉"GeForce GT 420" },␊
␉{ 0x10DE0DE4,␉/*0x00000000,*/␉"GeForce GT 520" },␊
␉{ 0x10DE0DE5,␉/*0x00000000,*/␉"GeForce GT 530" },␊
␉{ 0x10DE0DE8,␉/*0x00000000,*/␉"GeForce GT 620M" },␊
␉{ 0x10DE0DE9,␉/*0x00000000,*/␉"GeForce GT 630M" },␊
␉{ 0x10DE0DEA,␉/*0x00000000,*/␉"GeForce GT 610M" },␊
␉{ 0x10DE0DEB,␉/*0x00000000,*/␉"GeForce GT 555M" },␊
␉{ 0x10DE0DEC,␉/*0x00000000,*/␉"GeForce GT 525M" },␊
␉{ 0x10DE0DED,␉/*0x00000000,*/␉"GeForce GT 520M" },␊
␉{ 0x10DE0DEE,␉/*0x00000000,*/␉"GeForce GT 415M" },␊
␉// { 0x10DE0DEF,␉/*0x00000000,*/␉"N13P-NS1-A1" },␊
␉{ 0x10DE0DE0,␉"GeForce GT 440" },␊
␉{ 0x10DE0DE1,␉"GeForce GT 430" },␊
␉{ 0x10DE0DE2,␉"GeForce GT 420" },␊
␉{ 0x10DE0DE4,␉"GeForce GT 520" },␊
␉{ 0x10DE0DE5,␉"GeForce GT 530" },␊
␉{ 0x10DE0DE8,␉"GeForce GT 620M" },␊
␉{ 0x10DE0DE9,␉"GeForce GT 630M" },␊
␉{ 0x10DE0DEA,␉"GeForce GT 610M" },␊
␉{ 0x10DE0DEB,␉"GeForce GT 555M" },␊
␉{ 0x10DE0DEC,␉"GeForce GT 525M" },␊
␉{ 0x10DE0DED,␉"GeForce GT 520M" },␊
␉{ 0x10DE0DEE,␉"GeForce GT 415M" },␊
␉// { 0x10DE0DEF,␉"N13P-NS1-A1" },␊
␉// 0DF0 - 0DFF␉␊
␉{ 0x10DE0DF0,␉/*0x00000000,*/␉"GeForce GT 425M" },␊
␉{ 0x10DE0DF1,␉/*0x00000000,*/␉"GeForce GT 420M" },␊
␉{ 0x10DE0DF2,␉/*0x00000000,*/␉"GeForce GT 435M" },␊
␉{ 0x10DE0DF3,␉/*0x00000000,*/␉"GeForce GT 420M" },␊
␉{ 0x10DE0DF4,␉/*0x00000000,*/␉"GeForce GT 540M" },␊
␉{ 0x10DE0DF5,␉/*0x00000000,*/␉"GeForce GT 525M" },␊
␉{ 0x10DE0DF6,␉/*0x00000000,*/␉"GeForce GT 550M" },␊
␉{ 0x10DE0DF7,␉/*0x00000000,*/␉"GeForce GT 520M" },␊
␉{ 0x10DE0DF8,␉/*0x00000000,*/␉"Quadro 600" },␊
␉{ 0x10DE0DF9,␉/*0x00000000,*/␉"Quadro 500M" },␊
␉{ 0x10DE0DFA,␉/*0x00000000,*/␉"Quadro 1000M" },␊
␉{ 0x10DE0DFC,␉/*0x00000000,*/␉"NVS 5200M" },␊
␉// { 0x10DE0DFE,␉/*0x00000000,*/␉"GF108 ES" },␊
␉// { 0x10DE0DFF,␉/*0x00000000,*/␉"GF108 INT" },␊
␉{ 0x10DE0DF0,␉"GeForce GT 425M" },␊
␉{ 0x10DE0DF1,␉"GeForce GT 420M" },␊
␉{ 0x10DE0DF2,␉"GeForce GT 435M" },␊
␉{ 0x10DE0DF3,␉"GeForce GT 420M" },␊
␉{ 0x10DE0DF4,␉"GeForce GT 540M" },␊
␉{ 0x10DE0DF5,␉"GeForce GT 525M" },␊
␉{ 0x10DE0DF6,␉"GeForce GT 550M" },␊
␉{ 0x10DE0DF7,␉"GeForce GT 520M" },␊
␉{ 0x10DE0DF8,␉"Quadro 600" },␊
␉{ 0x10DE0DF9,␉"Quadro 500M" },␊
␉{ 0x10DE0DFA,␉"Quadro 1000M" },␊
␉{ 0x10DE0DFC,␉"NVS 5200M" },␊
␉// { 0x10DE0DFE,␉"GF108 ES" },␊
␉// { 0x10DE0DFF,␉"GF108 INT" },␊
␉// 0E00 - 0E0F␊
␉// 0E10 - 0E1F␊
␉// 0E20 - 0E2F␊
␉{ 0x10DE0E21,␉/*0x00000000,*/␉"D12U-25" },␊
␉{ 0x10DE0E22,␉/*0x00000000,*/␉"GeForce GTX 460" }, // subsystem 10de:0e22:1462:2322␊
␉{ 0x10DE0E23,␉/*0x00000000,*/␉"GeForce GTX 460 SE" },␊
␉{ 0x10DE0E24,␉/*0x00000000,*/␉"GeForce GTX 460" },␊
␉// { 0x10DE0E25,␉/*0x00000000,*/␉"D12U-50" },␊
␉{ 0x10DE0E28,␉/*0x00000000,*/␉"GeForce GTX 460" },␊
␉{ 0x10DE0E21,␉"D12U-25" },␊
␉{ 0x10DE0E22,␉"GeForce GTX 460" },␊
␉{ 0x10DE0E23,␉"GeForce GTX 460 SE" },␊
␉{ 0x10DE0E24,␉"GeForce GTX 460" },␊
␉// { 0x10DE0E25,␉"D12U-50" },␊
␉{ 0x10DE0E28,␉"GeForce GTX 460" },␊
␉// 0E30 - 0E3F␊
␉{ 0x10DE0E30,␉/*0x00000000,*/␉"GeForce GTX 470M" },␊
␉{ 0x10DE0E31,␉/*0x00000000,*/␉"GeForce GTX 485M" },␊
␉// { 0x10DE0E32,␉/*0x00000000,*/␉"N12E-GT" },␊
␉{ 0x10DE0E38,␉/*0x00000000,*/␉"GF104GL" },␊
␉{ 0x10DE0E3A,␉/*0x00000000,*/␉"Quadro 3000M" },␊
␉{ 0x10DE0E3B,␉/*0x00000000,*/␉"Quadro 4000M" },␊
␉// { 0x10DE0E3E,␉/*0x00000000,*/␉"GF104-ES" },␊
␉// { 0x10DE0E3F,␉/*0x00000000,*/␉"GF104-INT" },␊
␉{ 0x10DE0E30,␉"GeForce GTX 470M" },␊
␉{ 0x10DE0E31,␉"GeForce GTX 485M" },␊
␉// { 0x10DE0E32,␉"N12E-GT" },␊
␉{ 0x10DE0E38,␉"GF104GL" },␊
␉{ 0x10DE0E3A,␉"Quadro 3000M" },␊
␉{ 0x10DE0E3B,␉"Quadro 4000M" },␊
␉// { 0x10DE0E3E,␉"GF104-ES" },␊
␉// { 0x10DE0E3F,␉"GF104-INT" },␊
␉// 0E40 - 0E4F␊
␉// 0E50 - 0E5F␊
␉// 0E60 - 0E6F␊
␉// 0FB0 - 0FBF␊
␉// 0FC0 - 0FCF␊
␉// 0FD0 - 0FDF␊
␉{ 0x10DE0FD1,␉/*0x00000000,*/␉"GeForce GT 650M" },␊
␉{ 0x10DE0FD2,␉/*0x00000000,*/␉"GeForce GT 640M" },␊
␉{ 0x10DE0FD4,␉/*0x00000000,*/␉"GeForce GTX 660M" },␊
␉// { 0x10DE0FDB,␉/*0x00000000,*/␉"GK107-ESP-A1" },␊
␉{ 0x10DE0FD1,␉"GeForce GT 650M" },␊
␉{ 0x10DE0FD2,␉"GeForce GT 640M" },␊
␉{ 0x10DE0FD4,␉"GeForce GTX 660M" },␊
␉// { 0x10DE0FDB,␉"GK107-ESP-A1" },␊
␉// 0FE0 - 0FEF␊
␉// 0FF0 - 0FFF␊
␉// 1000 - 100F␊
␉// 1020 - 102F␊
␉// 1030 - 103F␊
␉// 1040 - 104F␊
␉{ 0x10DE1040,␉/*0x00000000,*/␉"GeForce GT 520" },␊
␉// { 0x10DE1041,␉/*0x00000000,*/␉"D13M1-45" },␊
␉{ 0x10DE1042,␉/*0x00000000,*/␉"GeForce 510" },␊
␉{ 0x10DE1048,␉/*0x00000000,*/␉"GeForce 605" },␊
␉{ 0x10DE1049,␉/*0x00000000,*/␉"GeForce GT 620" },␊
␉{ 0x10DE1040,␉"GeForce GT 520" },␊
␉// { 0x10DE1041,␉"D13M1-45" },␊
␉{ 0x10DE1042,␉"GeForce 510" },␊
␉{ 0x10DE1048,␉"GeForce 605" },␊
␉{ 0x10DE1049,␉"GeForce GT 620" },␊
␉// 1050 - 105F␊
␉{ 0x10DE1050,␉/*0x00000000,*/␉"GeForce GT 520M" },␊
␉{ 0x10DE1051,␉/*0x00000000,*/␉"GeForce GT 520MX" },␊
␉{ 0x10DE1052,␉/*0x00000000,*/␉"GeForce GT 520M" },␊
␉{ 0x10DE1054,␉/*0x00000000,*/␉"GeForce GT 410M" },␊
␉{ 0x10DE1055,␉/*0x00000000,*/␉"GeForce 410M" },␊
␉{ 0x10DE1056,␉/*0x00000000,*/␉"Quadro NVS 4200M" },␊
␉{ 0x10DE1057,␉/*0x00000000,*/␉"Quadro NVS 4200M" },␊
␉{ 0x10DE1058,␉/*0x00000000,*/␉"GeForce 610M" },␊
␉{ 0x10DE1059,␉/*0x00000000,*/␉"GeForce 610M" },␊
␉{ 0x10DE105A,␉/*0x00000000,*/␉"GeForce 610M" },␊
␉{ 0x10DE1050,␉"GeForce GT 520M" },␊
␉{ 0x10DE1051,␉"GeForce GT 520MX" },␊
␉{ 0x10DE1052,␉"GeForce GT 520M" },␊
␉{ 0x10DE1054,␉"GeForce GT 410M" },␊
␉{ 0x10DE1055,␉"GeForce 410M" },␊
␉{ 0x10DE1056,␉"Quadro NVS 4200M" },␊
␉{ 0x10DE1057,␉"Quadro NVS 4200M" },␊
␉{ 0x10DE1058,␉"GeForce 610M" },␊
␉{ 0x10DE1059,␉"GeForce 610M" },␊
␉{ 0x10DE105A,␉"GeForce 610M" },␊
␉// 1060 - 106F␊
␉// 1070 - 107F␊
␉// { 0x10DE107D,␉/*0x00000000,*/␉"GF119" },␊
␉// { 0x10DE107E,␉/*0x00000000,*/␉"GF119-INT" },␊
␉// { 0x10DE107F,␉/*0x00000000,*/␉"GF119-ES" },␊
␉// { 0x10DE107D,␉"GF119" },␊
␉// { 0x10DE107E,␉"GF119-INT" },␊
␉// { 0x10DE107F,␉"GF119-ES" },␊
␉// 1080 - 108F␊
␉{ 0x10DE1080,␉/*0x00000000,*/␉"GeForce GTX 580" },␊
␉{ 0x10DE1081,␉/*0x00000000,*/␉"GeForce GTX 570" }, // subsystem 10de:1081:10de:087e␊
␉{ 0x10DE1082,␉/*0x00000000,*/␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1083,␉/*0x00000000,*/␉"D13U" },␊
␉{ 0x10DE1084,␉/*0x00000000,*/␉"GeForce GTX 560" },␊
␉{ 0x10DE1086,␉/*0x00000000,*/␉"GeForce GTX 570" },␊
␉{ 0x10DE1087,␉/*0x00000000,*/␉"GeForce GTX 560 Ti-448" },␊
␉{ 0x10DE1088,␉/*0x00000000,*/␉"GeForce GTX 590" },␊
␉{ 0x10DE1089,␉/*0x00000000,*/␉"GeForce GTX 580" },␊
␉{ 0x10DE108B,␉/*0x00000000,*/␉"GeForce GTX 590" },␊
␉// { 0x10DE108C,␉/*0x00000000,*/␉"D13U" },␊
␉{ 0x10DE108E,␉/*0x00000000,*/␉"Tesla C2090" },␊
␉{ 0x10DE1080,␉"GeForce GTX 580" },␊
␉{ 0x10DE1081,␉"GeForce GTX 570" },␊
␉{ 0x10DE1082,␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1083,␉"D13U" },␊
␉{ 0x10DE1084,␉"GeForce GTX 560" },␊
␉{ 0x10DE1086,␉"GeForce GTX 570" },␊
␉{ 0x10DE1087,␉"GeForce GTX 560 Ti-448" },␊
␉{ 0x10DE1088,␉"GeForce GTX 590" },␊
␉{ 0x10DE1089,␉"GeForce GTX 580" },␊
␉{ 0x10DE108B,␉"GeForce GTX 590" },␊
␉// { 0x10DE108C,␉"D13U" },␊
␉{ 0x10DE108E,␉"Tesla C2090" },␊
␉// 1090 - 109F␊
␉{ 0x10DE1091,␉/*0x00000000,*/␉"Tesla M2090" },␊
␉{ 0x10DE1094,␉/*0x00000000,*/␉"Tesla M2075 Dual-Slot Computing Processor Module" },␊
␉{ 0x10DE1096,␉/*0x00000000,*/␉"Tesla C2075" },␊
␉// { 0x10DE1098,␉/*0x00000000,*/␉"D13U" },␊
␉{ 0x10DE109A,␉/*0x00000000,*/␉"Quadro 5010M" },␊
␉{ 0x10DE109B,␉/*0x00000000,*/␉"Quadro 7000" },␊
␉{ 0x10DE1091,␉"Tesla M2090" },␊
␉{ 0x10DE1094,␉"Tesla M2075 Dual-Slot Computing Processor Module" },␊
␉{ 0x10DE1096,␉"Tesla C2075" },␊
␉// { 0x10DE1098,␉"D13U" },␊
␉{ 0x10DE109A,␉"Quadro 5010M" },␊
␉{ 0x10DE109B,␉"Quadro 7000" },␊
␉// 10A0 - 10AF␊
␉// 10B0 - 10BF␊
␉// 10C0 - 10CF␊
␉{ 0x10DE10C0,␉/*0x00000000,*/␉"GeForce 9300 GS" },␊
␉{ 0x10DE10C3,␉/*0x00000000,*/␉"GeForce 8400 GS" },␊
␉{ 0x10DE10C4,␉/*0x00000000,*/␉"NVIDIA ION" },␊
␉{ 0x10DE10C5,␉/*0x00000000,*/␉"GeForce 405" },␊
␉{ 0x10DE10C0,␉"GeForce 9300 GS" },␊
␉{ 0x10DE10C3,␉"GeForce 8400 GS" },␊
␉{ 0x10DE10C4,␉"NVIDIA ION" },␊
␉{ 0x10DE10C5,␉"GeForce 405" },␊
␉// 10D0 - 10DF␊
␉{ 0x10DE10D8,␉/*0x00000000,*/␉"NVS 300" },␊
␉{ 0x10DE10D8,␉"NVS 300" },␊
␉// 10E0 - 10EF␊
␉// 10F0 - 10FF␊
␉// 1100 - 110F␊
␉// 1120 - 112F␊
␉// 1130 - 113F␊
␉// 1140 - 114F␊
␉// { 0x10DE1140,␉/*0x00000000,*/␉"GF117" },␊
␉{ 0x10DE1141,␉/*0x00000000,*/␉"GeForce 610M" },␊
␉{ 0x10DE1142,␉/*0x00000000,*/␉"GeForce 620M" },␊
␉// { 0x10DE1143,␉/*0x00000000,*/␉"N13P-GV" },␊
␉// { 0x10DE1144,␉/*0x00000000,*/␉"GF117" },␊
␉// { 0x10DE1145,␉/*0x00000000,*/␉"GF117" },␊
␉// { 0x10DE1146,␉/*0x00000000,*/␉"GF117" },␊
␉// { 0x10DE1147,␉/*0x00000000,*/␉"GF117" },␊
␉// { 0x10DE1149,␉/*0x00000000,*/␉"GF117-ES" },␊
␉// { 0x10DE114A,␉/*0x00000000,*/␉"GF117-INT" },␊
␉// { 0x10DE114B,␉/*0x00000000,*/␉"PCI-GEN3-B" },␊
␉// { 0x10DE1140,␉"GF117" },␊
␉{ 0x10DE1141,␉"GeForce 610M" },␊
␉{ 0x10DE1142,␉"GeForce 620M" },␊
␉// { 0x10DE1143,␉"N13P-GV" },␊
␉// { 0x10DE1144,␉"GF117" },␊
␉// { 0x10DE1145,␉"GF117" },␊
␉// { 0x10DE1146,␉"GF117" },␊
␉// { 0x10DE1147,␉"GF117" },␊
␉// { 0x10DE1149,␉"GF117-ES" },␊
␉// { 0x10DE114A,␉"GF117-INT" },␊
␉// { 0x10DE114B,␉"PCI-GEN3-B" },␊
␉// 1150 - 115F␊
␉// 1160 - 116F␊
␉// 1170 - 117F␊
␉// 1180 - 118F␊
␉{ 0x10DE1180,␉/*0x00000000,*/␉"GeForce GTX 680" },␊
␉{ 0x10DE1180,␉"GeForce GTX 680" },␊
␉{ 0x10DE1188,␉"GeForce GTX 690" }␊
␉{ 0x10DE1189,␉"GeForce GTX 670" }␊
␉// 1190 - 119F␊
␉// 11A0 - 11AF␊
␉// 11B0 - 11BF␊
␉// 11E0 - 11EF␊
␉// 11F0 - 11FF␊
␉// 1200 - 120F␊
␉{ 0x10DE1200,␉/*0x00000000,*/␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1201,␉/*0x00000000,*/␉"GeForce GTX 560" },␊
␉{ 0x10DE1202,␉/*0x00000000,*/␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1203,␉/*0x00000000,*/␉"GeForce GTX 460 SE v2" },␊
␉{ 0x10DE1205,␉/*0x00000000,*/␉"GeForce GTX 460 v2" },␊
␉{ 0x10DE1206,␉/*0x00000000,*/␉"GeForce GTX 555" },␊
␉{ 0x10DE1208,␉/*0x00000000,*/␉"GeForce GTX 560 SE" },␊
␉{ 0x10DE1210,␉/*0x00000000,*/␉"GeForce GTX 570M" },␊
␉{ 0x10DE1211,␉/*0x00000000,*/␉"GeForce GTX 580M" },␊
␉{ 0x10DE1212,␉/*0x00000000,*/␉"GeForce GTX 675M" },␊
␉{ 0x10DE1213,␉/*0x00000000,*/␉"GeForce GTX 670M" },␊
␉{ 0x10DE1240,␉/*0x00000000,*/␉"GeForce GT 620M" },␊
␉{ 0x10DE1241,␉/*0x00000000,*/␉"GeForce GT 545" },␊
␉{ 0x10DE1243,␉/*0x00000000,*/␉"GeForce GT 545" },␊
␉{ 0x10DE1244,␉/*0x00000000,*/␉"GeForce GTX 550 Ti" },␊
␉{ 0x10DE1245,␉/*0x00000000,*/␉"GeForce GTS 450" },␊
␉{ 0x10DE1246,␉/*0x00000000,*/␉"GeForce GTX 550M" },␊
␉{ 0x10DE1247,␉/*0x00000000,*/␉"GeForce GT 635M" }, // Subsystem Id: 1043 212C Asus GeForce GT 635M␊
␉{ 0x10DE1248,␉/*0x00000000,*/␉"GeForce GTX 555M" },␊
␉{ 0x10DE124B,␉/*0x00000000,*/␉"GeForce GT 640" },␊
␉{ 0x10DE124D,␉/*0x00000000,*/␉"GeForce GTX 555M" },␊
␉// { 0x10DE1250,␉/*0x00000000,*/␉"GF116-INT" },␊
␉{ 0x10DE1251,␉/*0x00000000,*/␉"GeForce GTX 560M" },␊
␉{ 0x10DE1200,␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1201,␉"GeForce GTX 560" },␊
␉{ 0x10DE1202,␉"GeForce GTX 560 Ti" },␊
␉{ 0x10DE1203,␉"GeForce GTX 460 SE v2" },␊
␉{ 0x10DE1205,␉"GeForce GTX 460 v2" },␊
␉{ 0x10DE1206,␉"GeForce GTX 555" },␊
␉{ 0x10DE1208,␉"GeForce GTX 560 SE" },␊
␉{ 0x10DE1210,␉"GeForce GTX 570M" },␊
␉{ 0x10DE1211,␉"GeForce GTX 580M" },␊
␉{ 0x10DE1212,␉"GeForce GTX 675M" },␊
␉{ 0x10DE1213,␉"GeForce GTX 670M" },␊
␉{ 0x10DE1240,␉"GeForce GT 620M" },␊
␉{ 0x10DE1241,␉"GeForce GT 545" },␊
␉{ 0x10DE1243,␉"GeForce GT 545" },␊
␉{ 0x10DE1244,␉"GeForce GTX 550 Ti" },␊
␉{ 0x10DE1245,␉"GeForce GTS 450" },␊
␉{ 0x10DE1246,␉"GeForce GTX 550M" },␊
␉{ 0x10DE1247,␉"GeForce GT 635M" }, // Subsystem Id: 1043 212C Asus GeForce GT 635M␊
␉{ 0x10DE1248,␉"GeForce GTX 555M" },␊
␉{ 0x10DE124B,␉"GeForce GT 640" },␊
␉{ 0x10DE124D,␉"GeForce GTX 555M" },␊
␉// { 0x10DE1250,␉"GF116-INT" },␊
␉{ 0x10DE1251,␉"GeForce GTX 560M" },␊
␉// 1260 - 126F␊
␉// 1270 - 127F␊
␉// 1280 - 128F␊
␉ if (!DP_ADD_TEMP_VAL(device, nvidia_device_type_child))␊
␉␉ return 0;␊
␉}␊
␉␊
␊
␉// Rek : Dont use sprintf return, it does not WORK !! our custom sprintf() always return 0!␊
␉// len = sprintf(tmp, "Slot-%x", devices_number);␊
␉sprintf(tmp, "Slot-%x",devices_number);␊
␉videoRam = mem_detect(regs, nvCardType, nvda_dev);␊
␉model = get_nvidia_model((nvda_dev->vendor_id << 16) | nvda_dev->device_id);␊
␉␊
␉verbose("nVidia %s %dMB NV%02x [%04x:%04x] (subsys [%04x:%04x]) :: %s device number: %d\n",␊
␉verbose("%s %dMB NV%02x [%04x:%04x]-[%04x:%04x] :: %s device number: %d\n",␊
␉␉␉model, (uint32_t)(videoRam / 1024 / 1024),␊
␉␉␉(REG32(0) >> 20) & 0x1ff, nvda_dev->vendor_id, nvda_dev->device_id,␊
␉␉␉nvda_dev->subsys_id.subsys.vendor_id, nvda_dev->subsys_id.subsys.device_id,␊
branches/ErmaC/Trunk/i386/libsaio/ati.c
636636
637637
638638
639
639640
640641
641642
......
785786
786787
787788
788
789
789790
790791
791792
......
19471948
19481949
19491950
1950
1951
19511952
19521953
19531954
......
19951996
19961997
19971998
1998
1999
1999
2000
2001
2002
20002003
20012004
2002
2005
20032006
20042007
20052008
20062009
2007
2010
20082011
20092012
20102013
......
20132016
20142017
20152018
2016
2019
20172020
20182021
20192022
......
20222025
20232026
20242027
2025
2028
20262029
20272030
20282031
......
20442047
20452048
20462049
2047
2048
2049
2050
2050
20512051
20522052
20532053
20542054
20552055
20562056
2057
2058
2059
2060
2061
2062
2063
2064
20572065
20582066
20592067
......
20782086
20792087
20802088
2081
2082
2083
2089
2090
20842091
20852092
2093
20862094
20872095
20882096
␉{ 0x68D8,␉0x56701545, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5690", kNull␉␉},␊
␉{ 0x68D8,␉0x5690174B, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5690", kNull␉␉},␊
␉{ 0x68D8,␉0x5730174B, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5730", kNull␉␉},␊
␉{ 0x68D8,␉0x68E01028, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670", kBaboon␉␉},␊
␉{ 0x68D8,␉0xE151174B, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670", kEulemur␉},␊
␉{ 0x68D8,␉0xE155174B, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670", kNull␉␉},␊
␉{ 0x68D8,␉0xE166174B, CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670", kUakari␉␉},␊
␉{ 0x6738,␉0x67381002, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6870", kDuckweed␉},␊
␉{ 0x6738,␉0xE178174B, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6870", kDuckweed␉},␊
␊
␉{ 0x6739,␉0x03B41043, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6850", kDuckweed␉},␊
␉{ 0x6739,␉0x03B41043, CHIP_FAMILY_BARTS,␉␉"ASUS EAH6850 DirectCU", kDuckweed␉},␊
␉{ 0x6739,␉0x174B174B, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6850", kDuckweed␉},␊
␉{ 0x6739,␉0x200F1787, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6850", kDuckweed␉},␊
␉{ 0x6739,␉0x21F81458, CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6850", kBulrushes␉},␊
␉if (!card->info->device_id)␊
␉{␊
␉␉verbose("Unsupported ATI card! Device ID: [%04x:%04x] Subsystem ID: [%08x] \n", ␊
␉␉␉␉pci_dev->vendor_id, pci_dev->device_id, pci_dev->subsys_id);␊
␉␉␉␉pci_dev->vendor_id, pci_dev->device_id, pci_dev->subsys_id.subsys_id);␊
␉␉return false;␊
␉}␊
␉␊
␉{␊
␉␉// use cfg_name on radeon_cards, to retrive the default name from card_configs,␊
␉␉card->cfg_name = card_configs[card->info->cfg_name].name;␊
␉␉// and leave ports alone!␊
//␉␉card->ports = card_configs[card->info->cfg_name].ports;␊
␉␉// Uncommented the following line and added verbose for debugging AtiPorts issues on some cards␊
␉␉card->ports = card_configs[card->info->cfg_name].ports;␊
␉␉// Report number of ports card reports␊
␉␉verbose("Card reported ports: %d\n", card->ports);␊
␉␉␊
␉␉// which means one of the fb's or kNull␊
␉␉verbose("Framebuffer set to device's default: %s\n", card->cfg_name);␊
␉␉verbose("Framebuffer set to: %s using device's default.\n", card->cfg_name);␊
␉}␊
␉else␊
␉{␊
␉␉// else, use the fb name returned by AtiConfig.␊
␉␉verbose("(AtiConfig) Framebuffer set to: %s\n", card->cfg_name);␊
␉␉verbose("Framebuffer set to: %s using AtiConfig=%s\n", card->cfg_name, card->cfg_name);␊
␉}␊
␉␊
␉// Check AtiPorts key for nr of ports,␊
␉if (n_ports > 0)␊
␉{␊
␉␉card->ports = n_ports; // use it.␊
␉␉verbose("(AtiPorts) Nr of ports set to: %d\n", card->ports);␊
␉␉verbose("Number of ports set to: %d using AtiPorts=%d\n", card->ports, card->ports);␊
}␊
␉else// if (card->cfg_name > 0) // do we want 0 ports if fb is kNull or mistyped ?␊
␉{␊
␉␉␉if (strcmp(card->cfg_name, card_configs[i].name) == 0)␊
␉␉␉␉card->ports = card_configs[i].ports; // default␊
␉␉␊
␉␉verbose("Nr of ports set to framebuffer's default: %d\n", card->ports);␊
␉␉verbose("Number of ports set to: %d using framebuffer's default.\n", card->ports);␊
␉}␊
//␉else␊
//␉␉card->ports = 2/1 ?; // set a min if 0 ports ?␊
bool setup_ati_devprop(pci_dt_t *ati_dev)␊
{␊
␉char *devicepath;␊
␉␊
␉if (!init_card(ati_dev))␊
␉␉return false;␊
␉␊
␊
␉// -------------------------------------------------␊
␉// Find a better way to do this (in device_inject.c)␊
␉if (!string)␊
␉␉string = devprop_create_string();␊
␉␊
␉devicepath = get_pci_dev_path(ati_dev);␊
␉if (!devicepath) {␊
␉␉return false;␊
␉}␊
␉verbose("ATI VGA Controller [%04x:%04x] :: %s \n", ␊
␉␉ati_dev->vendor_id, ati_dev->device_id, devicepath);␊
␉if (!init_card(ati_dev))␊
␉␉return false;␊
␊
␉card->device = devprop_add_device(string, devicepath);␊
␉if (!card->device)␊
␉␉return false;␊
␉stringlength = string->length;␊
␉// -------------------------------------------------␊
␉␊
␉verbose("ATI %s %s %dMB (%s) [%04x:%04x] (subsys [%04x:%04x]):: %s\n",␊
␉␉␉chip_family_name[card->info->chip_family], card->info->model_name,␊
␉␉␉(uint32_t)(card->vram_size / (1024 * 1024)), card->cfg_name,␊
␉verbose("%s %dMB [%04x:%04x] (subsys [%04x:%04x]) (%s:%s) :: %s\n",␊
␉␉␉card->info->model_name, (uint32_t)(card->vram_size / (1024 * 1024)),␊
␉␉␉ati_dev->vendor_id, ati_dev->device_id,␊
␉␉␉ati_dev->subsys_id.subsys.vendor_id, ati_dev->subsys_id.subsys.device_id,␊
␉␉␉chip_family_name[card->info->chip_family], card->cfg_name, ␊
␉␉␉devicepath);␊
␉␊
␉free(card);␊
branches/ErmaC/Trunk/i386/libsaio/load.c
5353
5454
5555
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
56
57
58
59
60
61
62
63
64
65
7266
7367
74
75
76
68
7769
78
79
80
81
82
83
84
85
86
87
88
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
8995
9096
9197
......
98104
99105
100106
101
107
102108
103
109
104110
105111
106112
107113
108
114
115
109116
110117
111118
......
114121
115122
116123
117
124
125
118126
119127
120128
......
124132
125133
126134
127
135
128136
129137
130138
......
137145
138146
139147
140
148
141149
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162150
163
164
165
166
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
167177
168178
169179
......
180190
181191
182192
183
193
194
184195
185196
186197
......
243254
244255
245256
246
257
258
247259
248260
249261
uint32_t fapoffset;␊
uint32_t fapsize;␉␊
␊
if (fhp->magic == FAT_MAGIC) {␊
nfat = fhp->nfat_arch;␊
swapped = 0;␊
} else if (fhp->magic == FAT_CIGAM) {␊
nfat = OSSwapInt32(fhp->nfat_arch);␊
swapped = 1;␊
} else {␊
return -1;␊
}␊
␊
for (; nfat > 0; nfat--, fap++) {␊
if (swapped) {␊
fapcputype = OSSwapInt32(fap->cputype);␊
fapoffset = OSSwapInt32(fap->offset);␊
fapsize = OSSwapInt32(fap->size);␊
}␊
␉if (fhp->magic == FAT_MAGIC)␊
␉{␊
␉␉nfat = fhp->nfat_arch;␊
␉␉swapped = 0;␊
␉}␊
␉else if (fhp->magic == FAT_CIGAM)␊
␉{␊
␉␉nfat = OSSwapInt32(fhp->nfat_arch);␊
␉␉swapped = 1;␊
␉}␊
␉else␊
␉{␊
␉␉fapcputype = fap->cputype;␊
␉␉fapoffset = fap->offset;␊
␉␉fapsize = fap->size;␊
␉␉return -1;␊
␉}␊
␊
if (fapcputype == archCpuType) {␊
*binary = (void *) ((unsigned long)*binary + fapoffset);␊
␉ size = fapsize;␊
␉ break;␊
}␊
}␊
␊
if (length != 0) *length = size;␊
␊
return 0;␊
␉for (; nfat > 0; nfat--, fap++)␊
␉{␊
␉␉if (swapped)␊
␉␉{␊
␉␉␉fapcputype = OSSwapInt32(fap->cputype);␊
␉␉␉fapoffset = OSSwapInt32(fap->offset);␊
␉␉␉fapsize = OSSwapInt32(fap->size);␊
␉␉}␊
␉␉else␊
␉␉{␊
␉␉␉fapcputype = fap->cputype;␊
␉␉␉fapoffset = fap->offset;␊
␉␉␉fapsize = fap->size;␊
␉␉}␊
␉␉if (fapcputype == archCpuType)␊
␉␉{␊
␉␉␉*binary = (void *) ((unsigned long)*binary + fapoffset);␊
␉␉␉size = fapsize;␊
␉␉␉break;␊
␉␉}␊
␉}␊
␊
␉if (length != 0) *length = size;␊
␊
␉return 0;␊
}␊
␊
long DecodeMachO(void *binary, entry_t *rentry, char **raddr, int *rsize)␊
unsigned long cnt;␊
long ret = -1;␊
unsigned int entry = 0;␊
␊
␊
gBinaryAddress = (unsigned long)binary;␊
␊
␊
mH = (struct mach_header *)(gBinaryAddress);␊
switch (archCpuType)␊
␉{␊
␉␉case CPU_TYPE_I386:␊
␉␉␉if (mH->magic != MH_MAGIC) {␊
␉␉␉if (mH->magic != MH_MAGIC)␊
␉␉␉{␊
␉␉␉␉error("Mach-O file has bad magic number\n");␊
␉␉␉␉return -1;␊
␉␉␉}␊
␉␉case CPU_TYPE_X86_64:␊
␉␉␉if (mH->magic != MH_MAGIC_64 && mH->magic == MH_MAGIC) ␊
␉␉␉␉return -1;␊
␉␉␉if (mH->magic != MH_MAGIC_64) {␊
␉␉␉if (mH->magic != MH_MAGIC_64)␊
␉␉␉{␊
␉␉␉␉error("Mach-O file has bad magic number\n");␊
␉␉␉␉return -1;␊
␉␉␉}␊
␉␉␉error("Unknown CPU type\n");␊
␉␉␉return -1;␊
␉}␊
␉␉␉␊
␊
cmdBase = cmdstart;␊
␊
#if DEBUG␊
printf("flags: %x\n", (unsigned)mH->flags);␊
getchar();␊
#endif␊
␊
␊
ncmds = mH->ncmds;␊
␊
for (cnt = 0; cnt < ncmds; cnt++) {␊
cmd = ((long *)cmdBase)[0];␊
cmdsize = ((long *)cmdBase)[1];␊
unsigned int load_addr;␊
unsigned int load_size;␊
␊
switch (cmd) {␊
␉case LC_SEGMENT_64: ␊
case LC_SEGMENT:␊
ret = DecodeSegment(cmdBase, &load_addr, &load_size);␊
if (ret == 0 && load_size != 0 && load_addr >= KERNEL_ADDR) {␊
vmaddr = MIN(vmaddr, load_addr);␊
vmend = MAX(vmend, load_addr + load_size);␊
}␊
break;␊
␊
case LC_UNIXTHREAD:␊
ret = DecodeUnixThread(cmdBase, &entry);␊
break;␊
␊
case LC_SYMTAB:␊
break;␊
␊
default:␊
␉for (cnt = 0; cnt < ncmds; cnt++)␊
␉{␊
␉␉cmd = ((long *)cmdBase)[0];␊
␉␉cmdsize = ((long *)cmdBase)[1];␊
␉␉unsigned int load_addr;␊
␉␉unsigned int load_size;␊
␊
␉␉switch (cmd)␊
␉␉{␊
␉␉␉case LC_SEGMENT_64: ␊
␉␉␉case LC_SEGMENT:␊
␉␉␉ret = DecodeSegment(cmdBase, &load_addr, &load_size);␊
␉␉␉if (ret == 0 && load_size != 0 && load_addr >= KERNEL_ADDR)␊
␉␉␉{␊
␉␉␉␉vmaddr = MIN(vmaddr, load_addr);␊
␉␉␉␉vmend = MAX(vmend, load_addr + load_size);␊
␉␉␉}␊
␉␉␉break;␊
␉␉␉case LC_UNIXTHREAD:␊
␉␉␉ret = DecodeUnixThread(cmdBase, &entry);␊
␉␉␉break;␊
␊
␉␉␉case LC_SYMTAB:␊
␉␉␉break;␊
␊
␉␉␉default:␊
#if NOTDEF␊
printf("Ignoring cmd type %d.\n", (unsigned)cmd);␊
#endif␊
*raddr = (char *)vmaddr;␊
␊
cmdBase = cmdstart;␊
for (cnt = 0; cnt < ncmds; cnt++) {␊
for (cnt = 0; cnt < ncmds; cnt++)␊
{␊
␉cmd = ((long *)cmdBase)[0];␊
␉cmdsize = ((long *)cmdBase)[1];␊
␉␉␊
#endif␉ ␊
}␊
␊
if (vmsize == 0 || filesize == 0) {␊
if (vmsize == 0 || filesize == 0)␊
{␊
*load_addr = ~0;␊
*load_size = 0;␊
return 0;␊
branches/ErmaC/Trunk/i386/libsaio/cpu.c
564564
565565
566566
567
567
568568
569
569
570570
571571
572572
␉␉cpuFrequency = tscFrequency;␊
␉␉DBG("0 ! using the default value for FSB !\n");␊
␉}␊
␉␊
␊
␉DBG("cpu freq = 0x%016llxn", timeRDTSC() * 20);␊
␉␊
␊
#endif␊
␉␊
␉p->CPU.MaxCoef = maxcoef;␊
branches/ErmaC/Trunk/i386/libsaio/platform.h
4040
4141
4242
43
43
4444
45
45
4646
4747
4848
#define CPU_MODEL_DALES_32NM␉␉0x25␉␉␉// Clarkdale, Arrandale␊
#define CPU_MODEL_SANDYBRIDGE␉␉0x2A␉␉␉// Sandy Bridge␊
#define CPU_MODEL_WESTMERE␉␉0x2C␉␉␉// Gulftown, Westmere-EP, Westmere-WS␊
#define CPU_MODEL_JAKETOWN␉␉0x2D␉␉␉// Sandy Bridge-E, Sandy Bridge-EP ␊
#define CPU_MODEL_JAKETOWN␉␉0x2D␉␉␉// Sandy Bridge-E, Sandy Bridge-EP␊
#define CPU_MODEL_NEHALEM_EX␉␉0x2E␉␉␉// Beckton␊
#define CPU_MODEL_WESTMERE_EX␉␉0x2F␊
#define CPU_MODEL_WESTMERE_EX␉␉0x2F␉␉␉// Westmere-EX␊
#define CPU_MODEL_IVYBRIDGE␉␉0x3A␉␉␉// Ivy Bridge␊
␊
/* CPU Features */␊
branches/ErmaC/Trunk/i386/libsaio/smbios.c
573573
574574
575575
576
577
578
576579
577580
578581
␉␉␉␉case CPU_MODEL_NEHALEM_EX:␉// Intel Xeon X75xx, Xeon X65xx, Xeon E75xx, Xeon E65x␊
␉␉␉␉case CPU_MODEL_WESTMERE:␉// Intel Core i7, Xeon X56xx, Xeon E56xx, Xeon W36xx LGA1366 (32nm) 6 Core␊
␉␉␉␉case CPU_MODEL_WESTMERE_EX:␉// Intel Xeon E7␊
␉␉␉␉case CPU_MODEL_SANDYBRIDGE:␉// Intel Core i3, i5, i7 LGA1155 (32nm)␊
␉␉␉␉case CPU_MODEL_IVYBRIDGE:␉// Intel Core i3, i5, i7 LGA1155 (22nm)␊
␉␉␉␉case CPU_MODEL_JAKETOWN:␉// Intel Core i7, Xeon E5 LGA2011 (32nm)␊
␉␉␉␉␉break;␊
␊
␉␉␉␉default:␊
branches/ErmaC/Trunk/i386/libsaio/pci.c
7575
7676
7777
78
79
78
79
80
81
8082
8183
82
84
85
8386
8487
8588
89
90
91
92
8693
8794
8895
......
9299
93100
94101
95
102
103
96104
97105
98106
99
107
108
100109
101110
102111
112
113
103114
104115
105116
106117
107
118
119
108120
109121
110122
......
163175
164176
165177
166
178
179
180
167181
168182
169183
......
177191
178192
179193
180
194
195
181196
182197
183198
␉uint8_t␉␉secondary_bus;␊
␉uint8_t␉␉header_type;␊
␊
␉for (dev = 0; dev < 32; dev++) {␊
␉␉for (func = 0; func < 8; func++) {␊
␉for (dev = 0; dev < 32; dev++)␊
␉{␊
␉␉for (func = 0; func < 8; func++)␊
␉␉{␊
␉␉␉pci_addr = PCIADDR(bus, dev, func);␊
␉␉␉id = pci_config_read32(pci_addr, PCI_VENDOR_ID);␊
␉␉␉if (!id || id == 0xffffffff) {␊
␉␉␉if (!id || id == 0xffffffff)␊
␉␉␉{␊
␉␉␉␉continue;␊
␉␉␉}␊
␉␉␉new = (pci_dt_t*)malloc(sizeof(pci_dt_t));␊
␉␉␉if (!new)␊
␉␉␉{␊
␉␉␉␉continue;␊
␉␉␉}␊
␉␉␉bzero(new, sizeof(pci_dt_t));␊
␉␉␉new->dev.addr␉␉␉␉= pci_addr;␊
␉␉␉new->vendor_id␉␉␉␉= id & 0xffff;␊
␉␉␉new->parent␉= start;␊
␊
␉␉␉header_type = pci_config_read8(pci_addr, PCI_HEADER_TYPE);␊
␉␉␉switch (header_type & 0x7f) {␊
␉␉␉switch (header_type & 0x7f)␊
␉␉␉{␊
␉␉␉case PCI_HEADER_TYPE_BRIDGE:␊
␉␉␉case PCI_HEADER_TYPE_CARDBUS:␊
␉␉␉␉secondary_bus = pci_config_read8(pci_addr, PCI_SECONDARY_BUS);␊
␉␉␉␉if (secondary_bus != 0) {␊
␉␉␉␉if (secondary_bus != 0)␊
␉␉␉␉␉{␊
␉␉␉␉␉scan_pci_bus(new, secondary_bus);␊
␉␉␉␉}␊
␉␉␉␉break;␊
␉␉␉␉default:␊
␉␉␉␉␉break;␊
␉␉␉}␊
␉␉␉*current = new;␊
␉␉␉current = &new->next;␊
␊
␉␉␉if ((func == 0) && ((header_type & 0x80) == 0)) {␊
␉␉␉if ((func == 0) && ((header_type & 0x80) == 0))␊
␉␉␉{␊
␉␉␉␉break;␊
␉␉␉}␊
␉␉}␊
␉␉{␊
␉␉␉sprintf(tmp, "PciRoot(0x%x)/Pci(0x%x,0x%x)", uid, ␊
␉␉␉␉current->dev.bits.dev, current->dev.bits.func);␊
␉␉} else {␊
␉␉}␊
␉␉else␊
␉␉{␊
␉␉␉sprintf(tmp, "/Pci(0x%x,0x%x)", ␊
␉␉␉␉current->dev.bits.dev, current->dev.bits.func);␊
␉␉}␊
␉pci_dt_t␉*current;␊
␊
␉current = pci_dt;␊
␉while (current) {␊
␉while (current)␊
␉{␊
␉␉printf("%02x:%02x.%x [%04x] [%04x:%04x] (subsys [%04x:%04x]):: %s\n", ␊
␉␉␉current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, ␊
␉␉␉current->class_id, current->vendor_id, current->device_id, ␊
branches/ErmaC/Trunk/i386/libsaio/pci.h
260260
261261
262262
263
263
264264
265265
266266
......
429429
430430
431431
432
433432
434433
435434
......
768767
769768
770769
770
771771
772772
773773
......
824824
825825
826826
827
827828
828829
829830
......
852853
853854
854855
856
857
858
859
855860
856861
857862
......
860865
861866
862867
868
863869
864870
865871
#define PCI_CB_IO_BASE_1_HI␉␉␉␉␉0x36␊
#define PCI_CB_IO_LIMIT_1␉␉␉␉␉0x38␊
#define PCI_CB_IO_LIMIT_1_HI␉␉␉␉␉0x3a␊
#define␉ PCI_CB_IO_RANGE_MASK␉␉␉␉␉~0x03␊
#define␉PCI_CB_IO_RANGE_MASK␉␉␉␉␉~0x03␊
/* 0x3c-0x3d are same as for htype 0 */␊
#define PCI_CB_BRIDGE_CONTROL␉␉␉␉␉0x3e␊
#define PCI_CB_BRIDGE_CTL_PARITY␉␉␉␉0x01␉␉␉/* Similar to standard bridge control register */␊
#define PCI_PCIX_STATUS_533MHZ␉␉␉␉␉0x80000000␉␉/* 533 MHz capable */␊
#define PCI_PCIX_SIZEOF␉␉␉␉␉␉4␊
␊
␊
/* PCI-X Bridges */␊
#define PCI_PCIX_BRIDGE_SEC_STATUS␉␉␉␉2␉␉␉/* Secondary bus status register offset */␊
#define PCI_PCIX_BRIDGE_SEC_STATUS_64BIT␉␉␉0x0001␊
#define PCI_CLASS_STORAGE_RAID␉␉␉␉␉0x0104␊
#define PCI_CLASS_STORAGE_ATA␉␉␉␉␉0x0105␊
#define PCI_CLASS_STORAGE_SATA␉␉␉␉␉0x0106␊
#define PCI_CLASS_STORAGE_SATA_AHCI␉␉␉␉0x010601␊
#define PCI_CLASS_STORAGE_SAS␉␉␉␉␉0x0107␊
#define PCI_CLASS_STORAGE_OTHER␉␉␉␉␉0x0180␊
␊
#define PCI_CLASS_SYSTEM_TIMER␉␉␉␉␉0x0802␊
#define PCI_CLASS_SYSTEM_RTC␉␉␉␉␉0x0803␊
#define PCI_CLASS_SYSTEM_PCI_HOTPLUG␉␉␉␉0x0804␊
#define PCI_CLASS_SYSTEM_SDHCI␉␉␉␉␉0x0805␊
#define PCI_CLASS_SYSTEM_OTHER␉␉␉␉␉0x0880␊
␊
#define PCI_BASE_CLASS_INPUT␉␉␉␉␉0x09␊
#define PCI_CLASS_SERIAL_ACCESS␉␉␉␉␉0x0c01␊
#define PCI_CLASS_SERIAL_SSA␉␉␉␉␉0x0c02␊
#define PCI_CLASS_SERIAL_USB␉␉␉␉␉0x0c03␊
#define PCI_CLASS_SERIAL_USB_UHCI␉␉␉␉0x0c0300␊
#define PCI_CLASS_SERIAL_USB_OHCI␉␉␉␉0x0c0310␊
#define PCI_CLASS_SERIAL_USB_EHCI␉␉␉␉0x0c0320␊
#define PCI_CLASS_SERIAL_USB_XHCI␉␉␉␉0x0c0330␊
#define PCI_CLASS_SERIAL_FIBER␉␉␉␉␉0x0c04␊
#define PCI_CLASS_SERIAL_SMBUS␉␉␉␉␉0x0c05␊
#define PCI_CLASS_SERIAL_INFINIBAND␉␉␉␉0x0c06␊
#define PCI_CLASS_WIRELESS_IRDA␉␉␉␉␉0x0d00␊
#define PCI_CLASS_WIRELESS_CONSUMER_IR␉␉␉␉0x0d01␊
#define PCI_CLASS_WIRELESS_RF␉␉␉␉␉0x0d10␊
#define PCI_CLASS_WIRELESS_WHCI␉␉␉␉␉0x0d1010␊
#define PCI_CLASS_WIRELESS_OTHER␉␉␉␉0x0d80␊
␊
#define PCI_BASE_CLASS_INTELLIGENT␉␉␉␉0x0e␊
branches/ErmaC/Trunk/i386/libsaio/md5c.c
227227
228228
229229
230
230
231231
232232
233233
......
255255
256256
257257
258
258
259259
260260
261261
␉GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */␊
␉GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */␊
␉GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */␊
␉GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */␊
␉GG (d, a, b, c, x[10], S22, 0x02441453); /* 22 */␊
␉GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */␊
␉GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */␊
␉GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */␊
␉HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */␊
␉HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */␊
␉HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */␊
␉HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */␊
␉HH (b, c, d, a, x[ 6], S34, 0x04881d05); /* 44 */␊
␉HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */␊
␉HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */␊
␉HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */␊
branches/ErmaC/Trunk/i386/libsaio/smbios_getters.c
2222
2323
2424
25
25
2626
2727
2828
......
3030
3131
3232
33
34
33
34
3535
3636
3737
......
4040
4141
4242
43
43
4444
4545
4646
......
114114
115115
116116
117
118
119
120
121
122
123
124
125
117126
118127
119128
......
138147
139148
140149
141
150
142151
143152
144153
......
148157
149158
150159
151
160
152161
153162
154163
......
165174
166175
167176
168
177
169178
170179
171180
......
189198
190199
191200
192
201
193202
194203
195
196
204
205
197206
207
208
209
198210
199211
200212
bool getProcessorInformationExternalClock(returnType *value)␊
{␊
␉if (Platform.CPU.Vendor == CPUID_VENDOR_INTEL) // Intel␊
␉{␉␉␊
␉{␊
␉␉switch (Platform.CPU.Family)␊
␉␉{␊
␉␉␉case 0x06:␊
␉␉␉␉switch (Platform.CPU.Model)␊
␉␉␉␉{␊
␉␉␉␉␉␉// set external clock to 0 for SANDY␊
␉␉␉␉␉␉// removes FSB info from system profiler as on real mac's. ␊
␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE: ␊
␉␉␉␉␉␉// removes FSB info from system profiler as on real mac's.␊
␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE:␊
␉␉␉␉␉case CPU_MODEL_IVYBRIDGE:␊
␉␉␉␉␉␉value->word = 0;␊
␉␉␉␉␉␉break;␊
␉␉␉␉}␊
␉␉␉}␊
␉␉␉␉break;␊
␉␉␉␉␊
␊
␉␉␉default:␊
␉␉␉␉value->word = Platform.CPU.FSBFrequency/1000000;␊
␉␉}␊
␉␉␉␉␉␉value->word = qpibusspeed;␊
␉␉␉␉␉␉return true;␊
␉␉␉␉␉}␊
␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE:␉// Intel Core i3, i5, i7 LGA1155 (32nm)␊
␉␉␉␉␉case CPU_MODEL_IVYBRIDGE:␉// Intel Core i3, i5, i7 LGA1155 (22nm)␊
␉␉␉␉␉case CPU_MODEL_JAKETOWN:␉// Intel Core i7, Xeon E5 LGA2011 (32nm)␊
␉␉␉␉␉{␊
␉␉␉␉␉␉int busspeed;␊
␉␉␉␉␉␉busspeed = 100;␊
␉␉␉␉␉␉value->word = busspeed;␊
␉␉␉␉␉␉return true;␊
␉␉␉␉␉}␊
␉␉␉␉}␊
␉␉␉}␊
␉␉}␊
bool getSMBOemProcessorType(returnType *value)␊
{␊
␉static bool done = false;␉␉␊
␉␉␊
␊
␉value->word = simpleGetSMBOemProcessorType();␊
␊
␉if (Platform.CPU.Vendor == CPUID_VENDOR_INTEL) // Intel␊
␉␉␉verbose("CPU is %s, family 0x%x, model 0x%x\n", Platform.CPU.BrandString, Platform.CPU.Family, Platform.CPU.Model);␊
␉␉␉done = true;␊
␉␉}␊
␉␉␊
␊
␉␉switch (Platform.CPU.Family) ␊
␉␉{␊
␉␉␉case 0x06:␊
␉␉␉␉␉case CPU_MODEL_NEHALEM:␉␉␉␉// Intel Core i7, Xeon W35xx, Xeon X55xx, Xeon E55xx LGA1366 (45nm)␊
␉␉␉␉␉case CPU_MODEL_WESTMERE:␉␉␉// Intel Core i7, Xeon X56xx, Xeon E56xx, Xeon W36xx LGA1366 (32nm) 6 Core␊
␉␉␉␉␉case CPU_MODEL_WESTMERE_EX:␉␉␉// Intel Xeon E7␊
␉␉␉␉␉case CPU_MODEL_JAKETOWN:␉␉␉// Intel Core i7, Xeon E5 LGA2011 (32nm)␊
␉␉␉␉␉case CPU_MODEL_JAKETOWN:␉␉␉// Intel Core i7, Xeon E5-xxxx LGA2011 (32nm)␊
␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Xeon(R)"))␊
␉␉␉␉␉␉␉value->word = 0x0501;␉␉␉// Xeon ␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉␉value->word = 0x0701;␉␉␉// Core i7␊
␉␉␉␉␉␉return true;␊
␊
␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE:␉␉␉// Intel Core i3, i5, i7 LGA1155 (32nm)␊
␉␉␉␉␉case CPU_MODEL_SANDYBRIDGE:␉␉␉// Intel Core i3, i5, i7, Xeon E3-12xx LGA1155 (32nm)␊
␉␉␉␉␉case CPU_MODEL_IVYBRIDGE:␉␉␉// Intel Core i3, i5, i7 LGA1155 (22nm)␊
␉␉␉␉␉case CPU_MODEL_DALES_32NM:␉␉␉// Intel Core i3, i5 LGA1156 (32nm)␊
␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Core(TM) i3"))␊
␉␉␉␉␉␉␉value->word = 0x0901;␉␉␉// Core i3␊
␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Xeon(R)"))␊
␉␉␉␉␉␉␉value->word = 0x0501;␉␉␉// Xeon␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Core(TM) i3"))␊
␉␉␉␉␉␉␉␉value->word = 0x0901;␉␉// Core i3␊
␉␉␉␉␉␉else␊
␉␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Core(TM) i5"))␊
␉␉␉␉␉␉␉␉value->word = 0x0601;␉␉// Core i5␊
␉␉␉␉␉␉␉else␊
branches/ErmaC/Trunk/i386/libsaio/lzss.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/*␊
* Copyright (c) 2003 Apple Computer, Inc. All rights reserved.␊
*␊
* @APPLE_LICENSE_HEADER_START@␊
* ␊
* Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights␊
* Reserved. This file contains Original Code and/or Modifications of␊
* Original Code as defined in and that are subject to the Apple Public␊
* Source License Version 2.0 (the "License"). You may not use this file␊
* except in compliance with the License. Please obtain a copy of the␊
* License at http://www.apple.com/publicsource and read it before using␊
* this file.␊
* ␊
* The Original Code and all software distributed under the License are␊
* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
* FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the␊
* License for the specific language governing rights and limitations␊
* under the License.␊
* ␊
* @APPLE_LICENSE_HEADER_END@␊
*/␊
/**************************************************************␊
LZSS.C -- A Data Compression Program␊
***************************************************************␊
4/6/1989 Haruhiko Okumura␊
Use, distribute, and modify this program freely.␊
Please send me your improved versions.␊
PC-VAN SCIENCE␊
NIFTY-Serve PAF01022␊
CompuServe 74050,1022␊
␊
**************************************************************/␊
/*␊
* lzss.c - Package for decompressing lzss compressed objects␊
*␊
* Copyright (c) 2003 Apple Computer, Inc.␊
*␊
* DRI: Josh de Cesare␊
*/␊
␊
#include "sl.h"␊
␊
#define N 4096 /* size of ring buffer - must be power of 2 */␊
#define F 18 /* upper limit for match_length */␊
#define THRESHOLD 2 /* encode string into position and length␊
if match_length is greater than this */␊
//#define NIL N /* index for root of binary search trees */␊
␊
int␊
decompress_lzss(u_int8_t *dst, u_int8_t *src, u_int32_t srclen)␊
{␊
/* ring buffer of size N, with extra F-1 bytes to aid string comparison */␊
u_int8_t text_buf[N + F - 1];␊
u_int8_t *dststart = dst;␊
u_int8_t *srcend = src + srclen;␊
int i, j, k, r, c;␊
unsigned int flags;␊
␊
dst = dststart;␊
for (i = 0; i < N - F; i++)␊
text_buf[i] = ' ';␊
r = N - F;␊
flags = 0;␊
for ( ; ; ) {␊
if (((flags >>= 1) & 0x100) == 0) {␊
if (src < srcend) c = *src++; else break;␊
flags = c | 0xFF00; /* uses higher byte cleverly */␊
} /* to count eight */␊
if (flags & 1) {␊
if (src < srcend) c = *src++; else break;␊
*dst++ = c;␊
text_buf[r++] = c;␊
r &= (N - 1);␊
} else {␊
if (src < srcend) i = *src++; else break;␊
if (src < srcend) j = *src++; else break;␊
i |= ((j & 0xF0) << 4);␊
j = (j & 0x0F) + THRESHOLD;␊
for (k = 0; k <= j; k++) {␊
c = text_buf[(i + k) & (N - 1)];␊
*dst++ = c;␊
text_buf[r++] = c;␊
r &= (N - 1);␊
}␊
}␊
}␊
␊
return dst - dststart;␊
}␊
branches/ErmaC/Trunk/i386/libsaio/saio_internal.h
119119
120120
121121
122
123
124
125
126
127
122
123
124
128125
129126
130127
extern int␉ testFAT32EFIBootSector( int biosdev, unsigned int secno, void * buffer );␊
␊
/* hfs_compare.c */␊
extern int32_t FastUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1,␊
␉␉␉␉␉␉␉ u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
extern void utf_encodestr( const u_int16_t * ucsp, int ucslen,␊
u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
extern void utf_decodestr(const u_int8_t *utf8p, u_int16_t *ucsp,␊
u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
extern int32_t FastUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1, u_int16_t *uniStr2, u_int32_t len2, int byte_order);␊
extern void utf_encodestr( const u_int16_t * ucsp, int ucslen, u_int8_t * utf8p, u_int32_t bufsize, int byte_order );␊
extern void utf_decodestr(const u_int8_t *utf8p, u_int16_t *ucsp, u_int16_t *ucslen, u_int32_t bufsize, int byte_order );␊
␊
/* load.c */␊
extern bool gHaveKernelCache;␊
branches/ErmaC/Trunk/i386/boot2/prompt.c
2828
2929
3030
31
31
3232
3333
3434
␊
#include <vers.h>␊
␊
char bootBanner[] = "\nDarwin/x86 boot v" I386BOOT_VERSION " - ErmaC (Trunk) r" I386BOOT_CHAMELEONREVISION "\n"␊
char bootBanner[] = "\nDarwin/x86 boot v" I386BOOT_VERSION " - Enoch by ErmaC r" I386BOOT_CHAMELEONREVISION "\n"␊
"Build date: " I386BOOT_BUILDDATE "\n"␊
"%dMB memory\n";␊
␊
branches/ErmaC/Trunk/i386/boot2/boot.h
113113
114114
115115
116
116117
117118
118119
␊
#define kUseNvidiaROM␉␉"UseNvidiaROM"␉␉/* nvidia.c */␊
#define kVBIOS␉␉␉␉"VBIOS"␉␉␉␉/* nvidia.c */␊
#define kHDMI␉␉␉␉"HDMI"␉␉␉␉/* nvidia.c */␊
#define kDcfg0␉␉␉␉"display_0"␉␉␉/* nvidia.c */␊
#define kDcfg1␉␉␉␉"display_1"␉␉␉/* nvidia.c */␊
␊
branches/ErmaC/Trunk/i386/cdboot/cdboot.s
406406
407407
408408
409
409
410410
411411
412412
; DS:SI = pointer to Disk Address Packet␊
;␊
; Returns:␊
; AH = return status (sucess is 0)␊
; AH = return status (success is 0)␊
; carry = 0 success␊
; 1 error␊
;␊
branches/ErmaC/Trunk/i386/cdboot/cdboothdd.s
320320
321321
322322
323
323
324324
325325
326326
; DS:SI = pointer to Disk Address Packet␊
;␊
; Returns:␊
; AH = return status (sucess is 0)␊
; AH = return status (success is 0)␊
; carry = 0 success␊
; 1 error␊
;␊
branches/ErmaC/Trunk/i386/libsa/strtol.c
6666
6767
6868
69
69
7070
7171
7272
* Added support for "0b101..." binary constants.␊
* Commented out references to errno.␊
*/␊
␊
␊
#if defined(LIBC_SCCS) && !defined(lint)␊
static char sccsid[] = "@(#)strtol.c␉5.4 (Berkeley) 2/23/91";␊
#endif /* LIBC_SCCS and not lint */␊
branches/ErmaC/Trunk/package/buildpkg.sh
8989
9090
9191
92
92
9393
9494
9595
......
952952
953953
954954
955
955
956956
957957
958958
choice_group_exclusive[0]=""␊
␊
# Package name␊
declare -r packagename="Chameleon"␊
declare -r packagename="Enoch"␊
␊
# Package identifiers␊
declare -r chameleon_package_identity="org.chameleon"␊
makedistribution ()␊
{␊
declare -r distributionDestDir="${SYMROOT}"␊
declare -r distributionFilename="${packagename// /}-${CHAMELEON_VERSION}-r${CHAMELEON_REVISION}.pkg"␊
declare -r distributionFilename="${packagename// /}-rev.${CHAMELEON_REVISION}.pkg"␊
declare -r distributionFilePath="${distributionDestDir}/${distributionFilename}"␊
␊
rm -f "${distributionDestDir}/${packagename// /}"*.pkg␊

Archive Download the corresponding diff file

Revision: 1936