Chameleon

Chameleon Svn Source Tree

Root/branches/meklortOld/i386/libsaio/smbios_patcher.c

Source at commit 1146 created 12 years 10 months ago.
By azimutz, Sync with trunk (r1145). Add nVidia dev id's, 0DF4 for "GeForce GT 450M" (issue 99) and 1251 for "GeForce GTX 560M" (thanks to oSxFr33k for testing).
1/*␊
2 * Copyright 2008 mackerintel␊
3 */␊
4␊
5#include "libsaio.h"␊
6#include "boot.h"␊
7#include "bootstruct.h"␊
8#include "acpi.h"␊
9#include "efi_tables.h"␊
10#include "fake_efi.h"␊
11#include "platform.h"␊
12#include "smbios_patcher.h"␊
13#include "pci.h"␊
14␊
15#ifndef DEBUG_SMBIOS␊
16#define DEBUG_SMBIOS 0␊
17#endif␊
18␊
19#if DEBUG_SMBIOS␊
20#define DBG(x...)␉printf(x)␊
21#else␊
22#define DBG(x...)␊
23#endif␊
24␊
25uint64_t smbios_p;␊
26␊
27char* gSMBIOSBoardModel;␊
28␊
29typedef struct {␊
30 const char* key;␊
31 const char* value;␊
32} SMStrEntryPair;␊
33␊
34// defaults for a MacBook␊
35static const SMStrEntryPair const sm_macbook_defaults[]={␊
36␉{"SMbiosvendor",␉"Apple Inc."␉␉␉},␊
37␉{"SMbiosversion",␉"MB41.88Z.0073.B00.0809221748"␉},␊
38␉{"SMbiosdate",␉␉"04/01/2008"␉␉␉},␊
39␉{"SMmanufacter",␉"Apple Inc."␉␉␉},␊
40␉{"SMproductname",␉"MacBook4,1"␉␉␉},␊
41␉{"SMsystemversion",␉"1.0"␉␉␉␉},␊
42␉{"SMserial",␉␉"SOMESRLNMBR"␉␉␉},␊
43␉{"SMfamily",␉␉"MacBook"␉␉␉},␊
44␉{"SMboardmanufacter",␉"Apple Inc."␉␉␉},␊
45␉{"SMboardproduct",␉"Mac-F42D89C8"␉␉␉},␊
46␉{ "",""␉}␊
47};␊
48␊
49// defaults for a MacBook Pro␊
50static const SMStrEntryPair const sm_macbookpro_defaults[]={␊
51␉{"SMbiosvendor",␉"Apple Inc."␉␉␉},␊
52␉{"SMbiosversion",␉"MBP41.88Z.0073.B00.0809221748"␉},␊
53␉{"SMbiosdate",␉␉"04/01/2008"␉␉␉},␊
54␉{"SMmanufacter",␉"Apple Inc."␉␉␉},␊
55␉{"SMproductname",␉"MacBookPro4,1"␉␉␉},␊
56␉{"SMsystemversion",␉"1.0"␉␉␉␉},␊
57␉{"SMserial",␉␉"SOMESRLNMBR"␉␉␉},␊
58␉{"SMfamily",␉␉"MacBookPro"␉␉␉},␊
59␉{"SMboardmanufacter",␉"Apple Inc."␉␉␉},␊
60␉{"SMboardproduct",␉"Mac-F42D89C8"␉␉␉},␊
61␉{ "",""␉}␊
62};␊
63␊
64// defaults for a Mac mini ␊
65static const SMStrEntryPair const sm_macmini_defaults[]={␊
66␉{"SMbiosvendor",␉"Apple Inc."␉␉␉},␊
67␉{"SMbiosversion",␉"MM21.88Z.009A.B00.0706281359"␉},␊
68␉{"SMbiosdate",␉␉"04/01/2008"␉␉␉},␊
69␉{"SMmanufacter",␉"Apple Inc."␉␉␉},␊
70␉{"SMproductname",␉"Macmini2,1"␉␉␉},␊
71␉{"SMsystemversion",␉"1.0"␉␉␉␉},␊
72␉{"SMserial",␉␉"SOMESRLNMBR"␉␉␉},␊
73␉{"SMfamily",␉␉"Napa Mac"␉␉␉},␊
74␉{"SMboardmanufacter",␉"Apple Inc."␉␉␉},␊
75␉{"SMboardproduct",␉"Mac-F4208EAA"␉␉␉},␊
76␉{ "",""␉}␊
77};␊
78␊
79// defaults for an iMac␊
80static const SMStrEntryPair const sm_imac_defaults[]={␊
81␉{"SMbiosvendor",␉"Apple Inc."␉␉␉},␊
82␉{"SMbiosversion",␉"IM81.88Z.00C1.B00.0802091538"␉},␊
83␉{"SMbiosdate",␉␉"04/01/2008"␉␉␉},␊
84␉{"SMmanufacter",␉"Apple Inc."␉␉␉},␊
85␉{"SMproductname",␉"iMac8,1"␉␉␉},␉␊
86␉{"SMsystemversion",␉"1.0"␉␉␉␉},␊
87␉{"SMserial",␉␉"SOMESRLNMBR"␉␉␉},␊
88␉{"SMfamily",␉␉"Mac"␉␉␉␉},␊
89␉{"SMboardmanufacter",␉"Apple Inc."␉␉␉},␊
90␉{"SMboardproduct",␉"Mac-F227BEC8"␉␉␉},␊
91␉{ "",""␉}␊
92};␊
93␊
94// defaults for a Mac Pro␊
95static const SMStrEntryPair const sm_macpro_defaults[]={␊
96␉{"SMbiosvendor",␉␉"Apple Computer, Inc."␉␉␉},␊
97␉{"SMbiosversion",␉␉"MP31.88Z.006C.B05.0802291410"␉},␊
98␉{"SMbiosdate",␉␉␉"04/01/2008"␉␉␉␉␉},␊
99␉{"SMmanufacter",␉␉"Apple Computer, Inc."␉␉␉},␊
100␉{"SMproductname",␉␉"MacPro3,1"␉␉␉␉␉␉},␊
101␉{"SMsystemversion",␉␉"1.0"␉␉␉␉␉␉␉},␊
102␉{"SMserial",␉␉␉"SOMESRLNMBR"␉␉␉␉␉},␊
103␉{"SMfamily",␉␉␉"MacPro"␉␉␉␉␉␉},␊
104␉{"SMboardmanufacter",␉"Apple Computer, Inc."␉␉␉},␊
105␉{"SMboardproduct",␉␉"Mac-F4208DC8"␉␉␉␉␉},␊
106␉{ "",""␉}␊
107};␊
108␊
109// defaults for an iMac11,1 core i3/i5/i7␊
110static const SMStrEntryPair const sm_imac_core_defaults[]={␊
111␉{"SMbiosvendor",␉␉"Apple Inc."␉␉␉␉␉},␊
112␉{"SMbiosversion",␉␉"IM111.88Z.0034.B00.0802091538"␉},␊
113␉{"SMbiosdate",␉␉␉"06/01/2009"␉␉␉␉␉},␊
114␉{"SMmanufacter",␉␉"Apple Inc."␉␉␉␉␉},␊
115␉{"SMproductname",␉␉"iMac11,1"␉␉␉␉␉␉},␉␊
116␉{"SMsystemversion",␉␉"1.0"␉␉␉␉␉␉␉},␊
117␉{"SMserial",␉␉␉"SOMESRLNMBR"␉␉␉␉␉},␊
118␉{"SMfamily",␉␉␉"iMac"␉␉␉␉␉␉␉},␊
119␉{"SMboardmanufacter",␉"Apple Computer, Inc."␉␉␉},␊
120␉{"SMboardproduct",␉␉"Mac-F2268DAE"␉␉␉␉␉},␊
121␉{ "",""␉}␊
122};␊
123␊
124// defaults for a Mac Pro 4,1 core i7/Xeon␊
125static const SMStrEntryPair const sm_macpro_core_defaults[]={␊
126␉{"SMbiosvendor",␉␉"Apple Computer, Inc."␉␉␉},␊
127␉{"SMbiosversion",␉␉"MP41.88Z.0081.B04.0903051113"␉},␊
128␉{"SMbiosdate",␉␉␉"11/06/2009"␉␉␉␉␉},␊
129␉{"SMmanufacter",␉␉"Apple Computer, Inc."␉␉␉},␊
130␉{"SMproductname",␉␉"MacPro4,1"␉␉␉␉␉␉},␊
131␉{"SMsystemversion",␉␉"1.0"␉␉␉␉␉␉␉},␊
132␉{"SMserial",␉␉␉"SOMESRLNMBR"␉␉␉␉␉},␊
133␉{"SMfamily",␉␉␉"MacPro"␉␉␉␉␉␉},␊
134␉{"SMboardmanufacter",␉"Apple Computer, Inc."␉␉␉},␊
135␉{"SMboardproduct",␉␉"Mac-F4208DC8"␉␉␉␉␉},␊
136␉{ "",""␉}␊
137};␊
138␊
139static const char* sm_get_defstr(const char * key, int table_num)␊
140{␊
141␉int␉i;␊
142␉const SMStrEntryPair*␉sm_defaults;␊
143␊
144␉if (platformCPUFeature(CPU_FEATURE_MOBILE)) {␊
145␉␉if (Platform->CPU.NoCores > 1) {␊
146␉␉␉sm_defaults=sm_macbookpro_defaults;␊
147␉␉} else {␊
148␉␉␉sm_defaults=sm_macbook_defaults;␊
149␉␉}␊
150␉} else {␊
151␉␉switch (Platform->CPU.NoCores) ␊
152␉␉{␊
153␉␉␉case 1: ␊
154␉␉␉␉sm_defaults=sm_macmini_defaults; ␊
155␉␉␉␉break;␊
156␉␉␉case 2:␊
157␉␉␉␉sm_defaults=sm_imac_defaults;␊
158␉␉␉␉break;␊
159␉␉␉default:␊
160␉␉␉{␊
161␉␉␉␉switch (Platform->CPU.Family) ␊
162␉␉␉␉{␊
163␉␉␉␉␉case 0x06:␊
164␉␉␉␉␉{␊
165␉␉␉␉␉␉switch (Platform->CPU.Model)␊
166␉␉␉␉␉␉{␊
167␉␉␉␉␉␉␉case CPU_MODEL_FIELDS: // Intel Core i5, i7 LGA1156 (45nm)␊
168␉␉␉␉␉␉␉case CPU_MODEL_DALES: // Intel Core i5, i7 LGA1156 (45nm) ???␊
169␉␉␉␉␉␉␉case CPU_MODEL_DALES_32NM: // Intel Core i3, i5, i7 LGA1156 (32nm) (Clarkdale, Arrandale)␊
170␉␉␉␉␉␉␉case 0x19: // Intel Core i5 650 @3.20 Ghz ␊
171␉␉␉␉␉␉␉␉sm_defaults=sm_imac_core_defaults; ␊
172␉␉␉␉␉␉␉␉break;␊
173␉␉␉␉␉␉␉case CPU_MODEL_NEHALEM: ␊
174␉␉␉␉␉␉␉case CPU_MODEL_NEHALEM_EX:␊
175␉␉␉␉␉␉␉case CPU_MODEL_WESTMERE: ␊
176␉␉␉␉␉␉␉case CPU_MODEL_WESTMERE_EX:␊
177␉␉␉␉␉␉␉␉sm_defaults=sm_macpro_core_defaults; ␊
178␉␉␉␉␉␉␉␉break;␊
179␉␉␉␉␉␉␉default:␊
180␉␉␉␉␉␉␉␉sm_defaults=sm_macpro_defaults; ␊
181␉␉␉␉␉␉␉␉break;␊
182␉␉␉␉␉␉}␊
183␉␉␉␉␉␉break;␊
184␉␉␉␉␉}␊
185␉␉␉␉␉default:␊
186␉␉␉␉␉␉sm_defaults=sm_macpro_defaults; ␊
187␉␉␉␉␉␉break;␊
188␉␉␉␉}␊
189␉␉␉␉break;␊
190␉␉␉}␊
191␉␉}␊
192␉}␊
193␉␊
194␉for (i=0; sm_defaults[i].key[0]; i++) {␊
195␉␉if (!strcmp (sm_defaults[i].key, key)) {␊
196␉␉␉return sm_defaults[i].value;␊
197␉␉}␊
198␉}␊
199␊
200␉// Shouldn't happen␊
201␉printf ("Error: no default for '%s' known\n", key);␊
202␉sleep (2);␊
203␉return "";␊
204}␊
205␊
206static int sm_get_fsb(const char *name, int table_num)␊
207{␊
208␉return Platform->CPU.FSBFrequency/1000000;␊
209}␊
210␊
211static int sm_get_cpu (const char *name, int table_num)␊
212{␊
213␉return Platform->CPU.CPUFrequency/1000000;␊
214}␊
215␊
216static int sm_get_bus_speed (const char *name, int table_num)␊
217{␊
218␉if (Platform->CPU.Vendor == 0x756E6547) // Intel␊
219␉{␉␉␊
220␉␉switch (Platform->CPU.Family) ␊
221␉␉{␊
222␉␉␉case 0x06:␊
223␉␉␉{␊
224␉␉␉␉switch (Platform->CPU.Model)␊
225␉␉␉␉{␊
226␉␉␉␉␉case 0x0D: // ?␊
227␉␉␉␉␉case CPU_MODEL_YONAH:␉// Yonah␉␉0x0E␊
228␉␉␉␉␉case CPU_MODEL_MEROM:␉// Merom␉␉0x0F␊
229␉␉␉␉␉case CPU_MODEL_PENRYN:␉// Penryn␉␉0x17␊
230␉␉␉␉␉case CPU_MODEL_ATOM:␉// Atom 45nm␉0x1C␊
231␉␉␉␉␉␉return 0; // TODO: populate bus speed for these processors␊
232␉␉␉␉␉␉␊
233//␉␉␉␉␉case CPU_MODEL_FIELDS: // Intel Core i5, i7 LGA1156 (45nm)␊
234//␉␉␉␉␉␉if (strstr(Platform.CPU.BrandString, "Core(TM) i5"))␊
235//␉␉␉␉␉␉␉return 2500; // Core i5␊
236//␉␉␉␉␉␉return 4800; // Core i7␊
237␉␉␉␉␉␉␊
238//␉␉␉␉␉case CPU_MODEL_NEHALEM: // Intel Core i7 LGA1366 (45nm)␊
239//␉␉␉␉␉case CPU_MODEL_NEHALEM_EX:␊
240//␉␉␉␉␉case CPU_MODEL_DALES: // Intel Core i5, i7 LGA1156 (45nm) ???␊
241//␉␉␉␉␉␉return 4800; // GT/s / 1000␊
242//␉␉␉␉␉␉␊
243␉␉␉␉␉case CPU_MODEL_WESTMERE_EX: // Intel Core i7 LGA1366 (45nm) 6 Core ???␊
244␉␉␉␉␉␉return 0; // TODO: populate bus speed for these processors␊
245␉␉␉␉␉␉␊
246//␉␉␉␉␉case 0x19: // Intel Core i5 650 @3.20 Ghz␊
247//␉␉␉␉␉␉return 2500; // why? Intel spec says 2.5GT/s ␊
248␊
249␉␉␉␉␉case 0x19: // Intel Core i5 650 @3.20 Ghz␊
250␉␉␉␉␉case CPU_MODEL_NEHALEM: // Intel Core i7 LGA1366 (45nm)␊
251␉␉␉␉␉case CPU_MODEL_FIELDS: // Intel Core i5, i7 LGA1156 (45nm)␊
252␉␉␉␉␉case CPU_MODEL_DALES: // Intel Core i5, i7 LGA1156 (45nm) ???␊
253␉␉␉␉␉case CPU_MODEL_DALES_32NM: // Intel Core i3, i5, i7 LGA1156 (32nm)␊
254␉␉␉␉␉case CPU_MODEL_WESTMERE: // Intel Core i7 LGA1366 (32nm) 6 Core␊
255␉␉␉␉␉case CPU_MODEL_NEHALEM_EX: // Intel Core i7 LGA1366 (45nm) 6 Core ???␊
256␉␉␉␉␉{ // thanks to dgobe for i3/i5/i7 bus speed detection␊
257␉␉␉␉␉␉int nhm_bus = 0x3F;␊
258␉␉␉␉␉␉static long possible_nhm_bus[] = {0xFF, 0x7F, 0x3F};␊
259␉␉␉␉␉␉unsigned long did, vid;␊
260␉␉␉␉␉␉int i;␊
261␉␉␉␉␉␉␊
262␉␉␉␉␉␉// Nehalem supports Scrubbing␊
263␉␉␉␉␉␉// First, locate the PCI bus where the MCH is located␊
264␉␉␉␉␉␉for(i = 0; i < sizeof(possible_nhm_bus); i++)␊
265␉␉␉␉␉␉{␊
266␉␉␉␉␉␉␉vid = pci_config_read16(PCIADDR(possible_nhm_bus[i], 3, 4), 0x00);␊
267␉␉␉␉␉␉␉did = pci_config_read16(PCIADDR(possible_nhm_bus[i], 3, 4), 0x02);␊
268␉␉␉␉␉␉␉vid &= 0xFFFF;␊
269␉␉␉␉␉␉␉did &= 0xFF00;␊
270␉␉␉␉␉␉␉␊
271␉␉␉␉␉␉␉if(vid == 0x8086 && did >= 0x2C00)␊
272␉␉␉␉␉␉␉␉nhm_bus = possible_nhm_bus[i]; ␊
273␉␉␉␉␉␉}␊
274␉␉␉␉␉␉␊
275␉␉␉␉␉␉unsigned long qpimult, qpibusspeed;␊
276␉␉␉␉␉␉qpimult = pci_config_read32(PCIADDR(nhm_bus, 2, 1), 0x50);␊
277␉␉␉␉␉␉qpimult &= 0x7F;␊
278␉␉␉␉␉␉DBG("qpimult %d\n", qpimult);␊
279␉␉␉␉␉␉qpibusspeed = (qpimult * 2 * (Platform->CPU.FSBFrequency/1000000));␊
280␉␉␉␉␉␉// Rek: rounding decimals to match original mac profile info␊
281␉␉␉␉␉␉if (qpibusspeed%100 != 0)qpibusspeed = ((qpibusspeed+50)/100)*100;␊
282␉␉␉␉␉␉DBG("qpibusspeed %d\n", qpibusspeed);␊
283␉␉␉␉␉␉return qpibusspeed;␊
284␉␉␉␉␉}␊
285␉␉␉␉}␊
286␉␉␉}␊
287␉␉}␊
288␉}␊
289␉return 0;␊
290}␊
291␊
292static int sm_get_simplecputype()␊
293{␊
294␉if (Platform->CPU.NoCores >= 4) ␊
295␉{␊
296␉␉return 0x0501; // Quad-Core Xeon␊
297␉}␊
298␉else if (Platform->CPU.NoCores == 1) ␊
299␉{␊
300␉␉return 0x0201; // Core Solo␊
301␉};␊
302␉␊
303␉return 0x0301; // Core 2 Duo␊
304}␊
305␊
306static int sm_get_cputype (const char *name, int table_num)␊
307{␊
308␉static bool done = false;␉␉␊
309␉␉␊
310␉if (Platform->CPU.Vendor == 0x756E6547) // Intel␊
311␉{␊
312␉␉if (!done) {␊
313␉␉␉verbose("CPU is %s, family 0x%x, model 0x%x\n", Platform->CPU.BrandString, Platform->CPU.Family, Platform->CPU.Model);␊
314␉␉␉done = true;␊
315␉␉}␊
316␉␉␊
317␉␉switch (Platform->CPU.Family) ␊
318␉␉{␊
319␉␉␉case 0x06:␊
320␉␉␉{␊
321␉␉␉␉switch (Platform->CPU.Model)␊
322␉␉␉␉{␊
323␉␉␉␉␉case 0x0D: // ?␊
324␉␉␉␉␉case CPU_MODEL_YONAH: // Yonah␊
325␉␉␉␉␉case CPU_MODEL_MEROM: // Merom␊
326␉␉␉␉␉case CPU_MODEL_PENRYN: // Penryn␊
327␉␉␉␉␉case CPU_MODEL_ATOM: // Intel Atom (45nm)␊
328␉␉␉␉␉␉return sm_get_simplecputype();␊
329␉␉␉␉␉␉␊
330␉␉␉␉␉case CPU_MODEL_NEHALEM: // Intel Core i7 LGA1366 (45nm)␊
331␉␉␉␉␉␉return 0x0701; // Core i7␊
332␉␉␉␉␉␉␊
333␉␉␉␉␉case CPU_MODEL_FIELDS: // Lynnfield, Clarksfield, Jasper␊
334␉␉␉␉␉␉if (strstr(Platform->CPU.BrandString, "Core(TM) i5"))␊
335␉␉␉␉␉␉␉return 0x601; // Core i5␊
336␉␉␉␉␉␉return 0x701; // Core i7␊
337␉␉␉␉␉␉␊
338␉␉␉␉␉case CPU_MODEL_DALES: // Intel Core i5, i7 LGA1156 (45nm) (Havendale, Auburndale)␊
339␉␉␉␉␉␉if (strstr(Platform->CPU.BrandString, "Core(TM) i5"))␊
340␉␉␉␉␉␉␉return 0x601; // Core i5␊
341␉␉␉␉␉␉return 0x0701; // Core i7␊
342␉␉␉␉␉␉␊
343␉␉␉␉␉case CPU_MODEL_DALES_32NM: // Intel Core i3, i5, i7 LGA1156 (32nm) (Clarkdale, Arrandale)␊
344␉␉␉␉␉␉if (strstr(Platform->CPU.BrandString, "Core(TM) i3"))␊
345␉␉␉␉␉␉␉return 0x901; // Core i3␊
346␉␉␉␉␉␉if (strstr(Platform->CPU.BrandString, "Core(TM) i5"))␊
347␉␉␉␉␉␉␉return 0x601; // Core i5␊
348␉␉␉␉␉␉return 0x0701; // Core i7␊
349␉␉␉␉␉␉␊
350␉␉␉␉␉case CPU_MODEL_WESTMERE: // Intel Core i7 LGA1366 (32nm) 6 Core (Gulftown, Westmere-EP, Westmere-WS)␊
351␉␉␉␉␉case CPU_MODEL_WESTMERE_EX: // Intel Core i7 LGA1366 (45nm) 6 Core ???␊
352␉␉␉␉␉␉return 0x0701; // Core i7␊
353␉␉␉␉␉␉␊
354␉␉␉␉␉case 0x19: // Intel Core i5 650 @3.20 Ghz␊
355␉␉␉␉␉␉return 0x601; // Core i5␊
356␉␉␉␉}␊
357␉␉␉}␊
358␉␉}␊
359␉}␊
360␉␊
361␉return sm_get_simplecputype();␊
362}␊
363␊
364static int sm_get_memtype (const char *name, int table_num)␊
365{␊
366␉int␉map;␊
367␊
368␉if (table_num < MAX_RAM_SLOTS) {␊
369␉␉map = Platform->DMI.DIMM[table_num];␊
370␉␉if (Platform->RAM.DIMM[map].InUse && Platform->RAM.DIMM[map].Type != 0) {␊
371 DBG("RAM Detected Type = %d\n", Platform->RAM.DIMM[map].Type);␊
372 return Platform->RAM.DIMM[map].Type;␊
373␉␉}␊
374␉}␊
375␉␊
376␉return SMB_MEM_TYPE_DDR2;␊
377}␊
378␊
379static int sm_get_memspeed (const char *name, int table_num)␊
380{␊
381␉int␉map;␊
382␊
383␉if (table_num < MAX_RAM_SLOTS) {␊
384␉␉map = Platform->DMI.DIMM[table_num];␊
385␉␉if (Platform->RAM.DIMM[map].InUse && Platform->RAM.DIMM[map].Frequency != 0) {␊
386 DBG("RAM Detected Freq = %d Mhz\n", Platform->RAM.DIMM[map].Frequency);␊
387 return Platform->RAM.DIMM[map].Frequency;␊
388␉␉}␊
389␉}␊
390␊
391␉return 800;␊
392}␊
393␊
394static const char *sm_get_memvendor (const char *name, int table_num)␊
395{␊
396␉int␉map;␊
397␊
398␉if (table_num < MAX_RAM_SLOTS) {␊
399␉␉map = Platform->DMI.DIMM[table_num];␊
400␉␉if (Platform->RAM.DIMM[map].InUse && strlen(Platform->RAM.DIMM[map].Vendor) > 0) {␊
401␉␉␉DBG("RAM Detected Vendor[%d]='%s'\n", table_num, Platform->RAM.DIMM[map].Vendor);␊
402␉␉␉return Platform->RAM.DIMM[map].Vendor;␊
403␉␉}␊
404␉}␊
405␉return "N/A";␊
406}␊
407␉␊
408static const char *sm_get_memserial (const char *name, int table_num)␊
409{␊
410␉int␉map;␊
411␊
412␉if (table_num < MAX_RAM_SLOTS) {␊
413␉␉map = Platform->DMI.DIMM[table_num];␊
414␉␉if (Platform->RAM.DIMM[map].InUse && strlen(Platform->RAM.DIMM[map].SerialNo) > 0) {␊
415 DBG("name = %s, map=%d, RAM Detected SerialNo[%d]='%s'\n", name ? name : "", ␊
416 map, table_num, Platform->RAM.DIMM[map].SerialNo);␊
417 return Platform->RAM.DIMM[map].SerialNo;␊
418␉␉}␊
419␉}␊
420␉return "N/A";␊
421}␊
422␊
423static const char *sm_get_mempartno (const char *name, int table_num)␊
424{␊
425␉int␉map;␊
426␊
427␉if (table_num < MAX_RAM_SLOTS) {␊
428␉␉map = Platform->DMI.DIMM[table_num];␊
429␉␉if (Platform->RAM.DIMM[map].InUse && strlen(Platform->RAM.DIMM[map].PartNo) > 0) {␊
430␉␉␉DBG("Ram Detected PartNo[%d]='%s'\n", table_num, Platform->RAM.DIMM[map].PartNo);␊
431␉␉␉return Platform->RAM.DIMM[map].PartNo;␊
432␉␉}␊
433␉}␊
434␉return "N/A";␊
435}␊
436␊
437static int sm_one (int tablen)␊
438{␊
439␉return 1;␊
440}␊
441␊
442struct smbios_property smbios_properties[]=␊
443{␊
444␉{.name="SMbiosvendor",␉␉.table_type= 0,␉.value_type=SMSTRING,␉.offset=0x04,␉.auto_str=sm_get_defstr␉},␊
445␉{.name="SMbiosversion",␉␉.table_type= 0,␉.value_type=SMSTRING,␉.offset=0x05,␉.auto_str=sm_get_defstr␉},␊
446␉{.name="SMbiosdate",␉␉.table_type= 0,␉.value_type=SMSTRING,␉.offset=0x08,␉.auto_str=sm_get_defstr␉},␊
447␉{.name="SMmanufacter",␉␉.table_type= 1,␉.value_type=SMSTRING,␉.offset=0x04,␉.auto_str=sm_get_defstr␉},␊
448␉{.name="SMproductname",␉␉.table_type= 1,␉.value_type=SMSTRING,␉.offset=0x05,␉.auto_str=sm_get_defstr␉},␊
449␉{.name="SMsystemversion",␉.table_type= 1,␉.value_type=SMSTRING,␉.offset=0x06,␉.auto_str=sm_get_defstr␉},␊
450␉{.name="SMserial",␉␉.table_type= 1,␉.value_type=SMSTRING,␉.offset=0x07,␉.auto_str=sm_get_defstr␉},␊
451␉{.name="SMUUID",␉␉.table_type= 1, .value_type=SMOWORD,␉.offset=0x08,␉.auto_oword=0␉␉},␊
452␉{.name="SMfamily",␉␉.table_type= 1,␉.value_type=SMSTRING,␉.offset=0x1a,␉.auto_str=sm_get_defstr␉},␊
453␉{.name="SMboardmanufacter",␉.table_type= 2, .value_type=SMSTRING,␉.offset=0x04,␉.auto_str=sm_get_defstr␉},␊
454␉{.name="SMboardproduct",␉.table_type= 2, .value_type=SMSTRING,␉.offset=0x05,␉.auto_str=sm_get_defstr␉},␊
455␉{.name="SMexternalclock",␉.table_type= 4,␉.value_type=SMWORD,␉.offset=0x12,␉.auto_int=sm_get_fsb␉},␊
456␉{.name="SMmaximalclock",␉.table_type= 4,␉.value_type=SMWORD,␉.offset=0x14,␉.auto_int=sm_get_cpu␉},␊
457␉{.name="SMmemdevloc",␉␉.table_type=17,␉.value_type=SMSTRING,␉.offset=0x10,␉.auto_str=0␉␉},␊
458␉{.name="SMmembankloc",␉␉.table_type=17,␉.value_type=SMSTRING,␉.offset=0x11,␉.auto_str=0␉␉},␊
459␉{.name="SMmemtype",␉␉.table_type=17,␉.value_type=SMBYTE,␉.offset=0x12,␉.auto_int=sm_get_memtype},␊
460␉{.name="SMmemspeed",␉␉.table_type=17,␉.value_type=SMWORD,␉.offset=0x15,␉.auto_int=sm_get_memspeed},␊
461␉{.name="SMmemmanufacter",␉.table_type=17,␉.value_type=SMSTRING,␉.offset=0x17,␉.auto_str=sm_get_memvendor},␊
462␉{.name="SMmemserial",␉␉.table_type=17,␉.value_type=SMSTRING,␉.offset=0x18,␉.auto_str=sm_get_memserial},␊
463␉{.name="SMmempart",␉␉.table_type=17,␉.value_type=SMSTRING,␉.offset=0x1A,␉.auto_str=sm_get_mempartno},␊
464␉{.name="SMcputype",␉␉.table_type=131,.value_type=SMWORD,␉.offset=0x04,␉.auto_int=sm_get_cputype},␊
465␉{.name="SMbusspeed",␉␉.table_type=132,.value_type=SMWORD,␉.offset=0x04,␉.auto_int=sm_get_bus_speed}␊
466};␊
467␊
468struct smbios_table_description smbios_table_descriptions[]=␊
469{␊
470␉{.type=0,␉.len=0x18,␉.numfunc=sm_one},␊
471␉{.type=1,␉.len=0x1b,␉.numfunc=sm_one},␊
472␉{.type=2,␉.len=0x0f,␉.numfunc=sm_one},␊
473␉{.type=4,␉.len=0x2a,␉.numfunc=sm_one},␊
474␉{.type=17,␉.len=0x1c,␉.numfunc=0},␊
475␉{.type=131,␉.len=0x06,␉.numfunc=sm_one},␊
476␉{.type=132,␉.len=0x06,␉.numfunc=sm_one}␊
477};␊
478␊
479// getting smbios addr with fast compare ops, late checksum testing ...␊
480#define COMPARE_DWORD(a,b) ( *((u_int32_t *) a) == *((u_int32_t *) b) )␊
481static const char * const SMTAG = "_SM_";␊
482static const char* const DMITAG= "_DMI_";␊
483␊
484static struct SMBEntryPoint *getAddressOfSmbiosTable(void)␊
485{␊
486␉struct SMBEntryPoint␉*smbios;␊
487␉/* ␊
488␉ * The logic is to start at 0xf0000 and end at 0xfffff iterating 16 bytes at a time looking␊
489␉ * for the SMBIOS entry-point structure anchor (literal ASCII "_SM_").␊
490␉ */␊
491␉smbios = (struct SMBEntryPoint*) SMBIOS_RANGE_START;␊
492␉while (smbios <= (struct SMBEntryPoint *)SMBIOS_RANGE_END) {␊
493 if (COMPARE_DWORD(smbios->anchor, SMTAG) && ␊
494 COMPARE_DWORD(smbios->dmi.anchor, DMITAG) &&␊
495 smbios->dmi.anchor[4]==DMITAG[4] &&␊
496 checksum8(smbios, sizeof(struct SMBEntryPoint)) == 0)␊
497␉ {␉␉␉␊
498 return smbios;␊
499␉ }␊
500 smbios = (struct SMBEntryPoint*) ( ((char*) smbios) + 16 );␊
501␉}␊
502␉printf("ERROR: Unable to find SMBIOS!\n");␊
503␉pause();␊
504␉return NULL;␊
505}␊
506␊
507/** Compute necessary space requirements for new smbios */␊
508static struct SMBEntryPoint *smbios_dry_run(struct SMBEntryPoint *origsmbios)␊
509{␊
510␉struct SMBEntryPoint␉*ret;␊
511␉char␉␉␉*smbiostables;␊
512␉char␉␉␉*tablesptr;␊
513␉int␉␉␉origsmbiosnum;␊
514␉int␉␉␉i, j;␊
515␉int␉␉␉tablespresent[256];␊
516␉bool␉␉␉do_auto=true;␊
517␊
518␉bzero(tablespresent, sizeof(tablespresent));␊
519␊
520␉getBoolForKey(kSMBIOSdefaults, &do_auto, &bootInfo->bootConfig);␊
521␊
522␉ret = (struct SMBEntryPoint *)AllocateKernelMemory(sizeof(struct SMBEntryPoint));␊
523␉if (origsmbios) {␊
524␉␉smbiostables = (char *)origsmbios->dmi.tableAddress;␊
525␉␉origsmbiosnum = origsmbios->dmi.structureCount;␊
526␉} else {␊
527␉␉smbiostables = NULL;␊
528␉␉origsmbiosnum = 0;␊
529␉}␊
530␊
531␉// _SM_␊
532␉ret->anchor[0] = 0x5f;␊
533␉ret->anchor[1] = 0x53;␊
534␉ret->anchor[2] = 0x4d;␊
535␉ret->anchor[3] = 0x5f; ␊
536␉ret->entryPointLength = sizeof(*ret);␊
537␉ret->majorVersion = 2;␊
538␉ret->minorVersion = 1;␊
539␉ret->maxStructureSize = 0; // will be calculated later in this function␊
540␉ret->entryPointRevision = 0;␊
541␉for (i=0;i<5;i++) {␊
542␉␉ret->formattedArea[i] = 0;␊
543␉}␊
544␉//_DMI_␊
545␉ret->dmi.anchor[0] = 0x5f;␊
546␉ret->dmi.anchor[1] = 0x44;␊
547␉ret->dmi.anchor[2] = 0x4d;␊
548␉ret->dmi.anchor[3] = 0x49;␊
549␉ret->dmi.anchor[4] = 0x5f;␊
550␉ret->dmi.tableLength = 0; // will be calculated later in this function␊
551␉ret->dmi.tableAddress = 0; // will be initialized in smbios_real_run()␊
552␉ret->dmi.structureCount = 0; // will be calculated later in this function␊
553␉ret->dmi.bcdRevision = 0x21;␊
554␉tablesptr = smbiostables;␊
555␊
556 // add stringlen of overrides to original stringlen, update maxStructure size adequately, ␊
557 // update structure count and tablepresent[type] with count of type. ␊
558␉if (smbiostables) {␊
559␉␉for (i=0; i<origsmbiosnum; i++) {␊
560␉␉␉struct smbios_table_header␉*cur = (struct smbios_table_header *)tablesptr;␊
561␉␉␉char␉␉␉␉*stringsptr;␊
562␉␉␉int␉␉␉␉stringlen;␊
563␊
564␉␉␉tablesptr += cur->length;␊
565␉␉␉stringsptr = tablesptr;␊
566␉␉␉for (; tablesptr[0]!=0 || tablesptr[1]!=0; tablesptr++);␊
567␉␉␉tablesptr += 2;␊
568␉␉␉stringlen = tablesptr - stringsptr - 1;␊
569␉␉␉if (stringlen == 1) {␊
570␉␉␉␉stringlen = 0;␊
571␉␉␉}␊
572␉␉␉for (j=0; j<sizeof(smbios_properties)/sizeof(smbios_properties[0]); j++) {␊
573␉␉␉␉const char␉*str;␊
574␉␉␉␉int␉␉size;␊
575␉␉␉␉char␉␉altname[40];␊
576␊
577␉␉␉␉sprintf(altname, "%s_%d",smbios_properties[j].name, tablespresent[cur->type] + 1);␉␉␉␉␊
578␉␉␉␉if (smbios_properties[j].table_type == cur->type &&␊
579␉␉␉␉ smbios_properties[j].value_type == SMSTRING &&␊
580␉␉␉␉ (getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig) ||␊
581␉␉␉␉ getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig)))␊
582␉␉␉␉{␊
583␉␉␉␉␉stringlen += size + 1;␊
584␉␉␉␉} else if (smbios_properties[j].table_type == cur->type &&␊
585␉␉␉␉ smbios_properties[j].value_type == SMSTRING &&␊
586␉␉␉␉ do_auto && smbios_properties[j].auto_str)␊
587␉␉␉␉{␊
588␉␉␉␉␉stringlen += strlen(smbios_properties[j].auto_str(smbios_properties[j].name, tablespresent[cur->type])) + 1;␊
589␉␉␉␉}␊
590␉␉␉}␊
591␉␉␉if (stringlen == 0) {␊
592␉␉␉␉stringlen = 1;␊
593␉␉␉}␊
594␉␉␉stringlen++;␊
595␉␉␉if (ret->maxStructureSize < cur->length+stringlen) {␊
596␉␉␉␉ret->maxStructureSize=cur->length+stringlen;␊
597␉␉␉}␊
598␉␉␉ret->dmi.tableLength += cur->length+stringlen;␊
599␉␉␉ret->dmi.structureCount++;␊
600␉␉␉tablespresent[cur->type]++;␊
601␉␉}␊
602␉}␊
603 // Add eventually table types whose detected count would be < required count, and update ret header with:␊
604 // new stringlen addons, structure count, and tablepresent[type] count adequately␊
605␉for (i=0; i<sizeof(smbios_table_descriptions)/sizeof(smbios_table_descriptions[0]); i++) {␊
606␉␉int␉numnec=-1;␊
607␉␉char␉buffer[40];␊
608␊
609␉␉sprintf(buffer, "SMtable%d", i);␊
610␉␉if (!getIntForKey(buffer, &numnec, &bootInfo->smbiosConfig)) {␊
611␉␉␉numnec = -1;␊
612␉␉}␊
613␉␉if (numnec==-1 && do_auto && smbios_table_descriptions[i].numfunc) {␊
614␉␉␉numnec = smbios_table_descriptions[i].numfunc(smbios_table_descriptions[i].type);␊
615␉␉}␊
616␉␉while (tablespresent[smbios_table_descriptions[i].type] < numnec) {␊
617␉␉␉int␉stringlen = 0;␊
618␉␉␉for (j=0; j<sizeof(smbios_properties)/sizeof(smbios_properties[0]); j++) {␊
619␉␉␉␉const char␉*str;␊
620␉␉␉␉int␉␉size;␊
621␉␉␉␉char␉␉altname[40];␊
622␊
623␉␉␉␉sprintf(altname, "%s_%d",smbios_properties[j].name, tablespresent[smbios_table_descriptions[i].type] + 1);␊
624␉␉␉␉if (smbios_properties[j].table_type == smbios_table_descriptions[i].type &&␊
625␉␉␉␉ smbios_properties[j].value_type == SMSTRING &&␊
626␉␉␉␉ (getValueForKey(altname, &str, &size, &bootInfo->smbiosConfig) ||␊
627␉␉␉␉ getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig)))␊
628␉␉␉␉{␊
629␉␉␉␉␉stringlen += size + 1;␊
630␉␉␉␉} else if (smbios_properties[j].table_type == smbios_table_descriptions[i].type &&␊
631␉␉␉␉ smbios_properties[j].value_type==SMSTRING &&␊
632␉␉␉␉ do_auto && smbios_properties[j].auto_str)␊
633␉␉␉␉{␊
634␉␉␉␉␉stringlen += strlen(smbios_properties[j].auto_str(smbios_properties[j].name, tablespresent[smbios_table_descriptions[i].type])) + 1;␊
635␉␉␉␉}␊
636␉␉␉}␊
637␉␉␉if (stringlen == 0) {␊
638␉␉␉␉stringlen = 1;␊
639␉␉␉}␊
640␉␉␉stringlen++;␊
641␉␉␉if (ret->maxStructureSize < smbios_table_descriptions[i].len+stringlen) {␊
642␉␉␉␉ret->maxStructureSize = smbios_table_descriptions[i].len + stringlen;␊
643␉␉␉}␊
644␉␉␉ret->dmi.tableLength += smbios_table_descriptions[i].len + stringlen;␊
645␉␉␉ret->dmi.structureCount++;␊
646␉␉␉tablespresent[smbios_table_descriptions[i].type]++;␊
647␉␉}␊
648␉}␊
649␉return ret;␊
650}␊
651␊
652/** From the origsmbios detected by getAddressOfSmbiosTable() to newsmbios whose entrypoint ␊
653 * struct has been created by smbios_dry_run, update each table struct content of new smbios␊
654 * int the new allocated table address of size newsmbios->tablelength.␊
655 */␊
656static void smbios_real_run(struct SMBEntryPoint * origsmbios, struct SMBEntryPoint * newsmbios)␊
657{␊
658␉char *smbiostables;␊
659␉char *tablesptr, *newtablesptr;␊
660␉int origsmbiosnum;␊
661␉// bitmask of used handles␊
662␉uint8_t handles[8192]; ␊
663␉uint16_t nexthandle=0;␊
664␉int i, j;␊
665␉int tablespresent[256];␊
666␉bool do_auto=true;␊
667␉␊
668 static bool done = false; // IMPROVEME: called twice via getSmbios(), but only the second call can get all necessary info !␊
669␊
670␉extern void dumpPhysAddr(const char * title, void * a, int len);␊
671␉␊
672␉bzero(tablespresent, sizeof(tablespresent));␊
673␉bzero(handles, sizeof(handles));␊
674␊
675␉getBoolForKey(kSMBIOSdefaults, &do_auto, &bootInfo->bootConfig);␊
676␉␊
677␉newsmbios->dmi.tableAddress = (uint32_t)AllocateKernelMemory(newsmbios->dmi.tableLength);␊
678␉if (origsmbios) {␊
679␉␉smbiostables = (char *)origsmbios->dmi.tableAddress;␊
680␉␉origsmbiosnum = origsmbios->dmi.structureCount;␊
681␉} else {␊
682␉␉smbiostables = NULL;␊
683␉␉origsmbiosnum = 0;␊
684␉}␊
685␉tablesptr = smbiostables;␊
686␉newtablesptr = (char *)newsmbios->dmi.tableAddress;␊
687␊
688 // if old smbios exists then update new smbios with old smbios original content first␊
689␉if (smbiostables) {␊
690␉␉for (i=0; i<origsmbiosnum; i++) {␊
691␉␉␉struct smbios_table_header␉*oldcur = (struct smbios_table_header *) tablesptr;␊
692␉␉␉struct smbios_table_header␉*newcur = (struct smbios_table_header *) newtablesptr;␊
693␉␉␉char␉␉␉␉*stringsptr;␊
694␉␉␉int␉␉␉␉nstrings = 0;␊
695␊
696␉␉␉handles[(oldcur->handle) / 8] |= 1 << ((oldcur->handle) % 8);␊
697␊
698 // copy table length from old table to new table but not the old strings␊
699␉␉␉memcpy(newcur,oldcur, oldcur->length);␊
700␊
701␉␉␉tablesptr += oldcur->length;␊
702␉␉␉stringsptr = tablesptr;␊
703␉␉␉newtablesptr += oldcur->length;␊
704␊
705 // calculate the number of strings in the old content␊
706␉␉␉for (;tablesptr[0]!=0 || tablesptr[1]!=0; tablesptr++) {␊
707␉␉␉␉if (tablesptr[0] == 0) {␊
708␉␉␉␉␉nstrings++;␊
709␉␉␉␉}␊
710␉␉␉}␊
711␉␉␉if (tablesptr != stringsptr) {␊
712␉␉␉␉nstrings++;␊
713␉␉␉}␊
714␉␉␉tablesptr += 2;␊
715␊
716 // copy the old strings to new table␊
717␉␉␉memcpy(newtablesptr, stringsptr, tablesptr-stringsptr);␊
718␊
719 ␉␉␉// point to next possible space for a string (deducting the second 0 char at the end)␊
720␉␉␉newtablesptr += tablesptr - stringsptr - 1;␊
721 if (nstrings == 0) { // if no string was found rewind to the first 0 char of the 0,0 terminator␊
722␉␉␉␉newtablesptr--;␊
723␉␉␉}␊
724␊
725 // now for each property in the table update the overrides if any (auto or user)␊
726␉␉␉for (j=0; j<sizeof(smbios_properties)/sizeof(smbios_properties[0]); j++) {␊
727␉␉␉␉const char␉*str;␊
728␉␉␉␉int␉␉size;␊
729␉␉␉␉int␉␉num;␊
730␉␉␉␉char␉␉altname[40];␊
731␊
732␉␉␉␉sprintf(altname, "%s_%d", smbios_properties[j].name, tablespresent[newcur->type] + 1);␊
733␉␉␉␉if (smbios_properties[j].table_type == newcur->type) {␊
734␉␉␉␉␉switch (smbios_properties[j].value_type) {␊
735␉␉␉␉␉case SMSTRING:␊
736␉␉␉␉␉␉if (getValueForKey(altname, &str, &size, &bootInfo->smbiosConfig) ||␊
737␉␉␉␉␉␉ getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig))␊
738␉␉␉␉␉␉{␊
739␉␉␉␉␉␉␉memcpy(newtablesptr, str, size);␊
740␉␉␉␉␉␉␉newtablesptr[size] = 0;␊
741␉␉␉␉␉␉␉newtablesptr += size + 1;␊
742␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = ++nstrings;␊
743␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_str) {␊
744␉␉␉␉␉␉␉str = smbios_properties[j].auto_str(smbios_properties[j].name, tablespresent[newcur->type]);␊
745␉␉␉␉␉␉␉size = strlen(str);␊
746␉␉␉␉␉␉␉memcpy(newtablesptr, str, size);␊
747␉␉␉␉␉␉␉newtablesptr[size] = 0;␊
748␉␉␉␉␉␉␉newtablesptr += size + 1;␊
749␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = ++nstrings;␊
750␉␉␉␉␉␉}␊
751␉␉␉␉␉␉break;␊
752␊
753␉␉␉␉␉case SMOWORD:␊
754␉␉␉␉␉␉if (getValueForKey(altname, &str, &size, &bootInfo->smbiosConfig) ||␊
755␉␉␉␉␉␉ getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig))␊
756␉␉␉␉␉␉{␊
757␉␉␉␉␉␉␉int␉␉k=0, t=0, kk=0;␊
758␉␉␉␉␉␉␉const char␉*ptr = str;␊
759␉␉␉␉␉␉␉memset(((char*)newcur) + smbios_properties[j].offset, 0, 16);␊
760␉␉␉␉␉␉␉while (ptr-str<size && *ptr && (*ptr==' ' || *ptr=='\t' || *ptr=='\n')) {␊
761␉␉␉␉␉␉␉␉ptr++;␊
762␉␉␉␉␉␉␉}␊
763␉␉␉␉␉␉␉if (size-(ptr-str)>=2 && ptr[0]=='0' && (ptr[1]=='x' || ptr[1]=='X')) {␊
764␉␉␉␉␉␉␉␉ptr += 2;␊
765␉␉␉␉␉␉␉}␊
766␉␉␉␉␉␉␉for (;ptr-str<size && *ptr && k<16;ptr++) {␊
767␉␉␉␉␉␉␉␉if (*ptr>='0' && *ptr<='9') {␊
768␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'0')),kk++;␊
769␉␉␉␉␉␉␉␉}␊
770␉␉␉␉␉␉␉␉if (*ptr>='a' && *ptr<='f') {␊
771␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'a'+10)),kk++;␊
772␉␉␉␉␉␉␉␉}␊
773␉␉␉␉␉␉␉␉if (*ptr>='A' && *ptr<='F') {␊
774␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'A'+10)),kk++;␊
775␉␉␉␉␉␉␉␉}␊
776␉␉␉␉␉␉␉␉if (kk == 2) {␊
777␉␉␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset + k)) = t;␊
778␉␉␉␉␉␉␉␉␉k++;␊
779␉␉␉␉␉␉␉␉␉kk = 0;␊
780␉␉␉␉␉␉␉␉␉t = 0;␊
781␉␉␉␉␉␉␉␉}␊
782␉␉␉␉␉␉␉}␊
783␉␉␉␉␉␉}␊
784␉␉␉␉␉␉break;␊
785␊
786␉␉␉␉␉case SMBYTE:␊
787␉␉␉␉␉␉if (getIntForKey(altname, &num, &bootInfo->smbiosConfig) ||␊
788␉␉␉␉␉␉ getIntForKey(smbios_properties[j].name, &num, &bootInfo->smbiosConfig))␊
789␉␉␉␉␉␉{␊
790␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = num;␊
791␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_int) {␊
792␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]);␉␉␉␉␉␉␉␊
793␉␉␉␉␉␉}␊
794␉␉␉␉␉␉break;␊
795␊
796␉␉␉␉␉case SMWORD:␊
797␉␉␉␉␉␉if (getIntForKey(altname, &num, &bootInfo->smbiosConfig) ||␊
798␉␉␉␉␉␉ getIntForKey(smbios_properties[j].name, &num, &bootInfo->smbiosConfig))␊
799␉␉␉␉␉␉{␊
800␉␉␉␉␉␉␉*((uint16_t*)(((char*)newcur) + smbios_properties[j].offset)) = num;␊
801␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_int) {␊
802␉␉␉␉␉␉␉*((uint16_t*)(((char*)newcur) + smbios_properties[j].offset)) = smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]);␊
803␉␉␉␉␉␉}␊
804␉␉␉␉␉␉break;␊
805␉␉␉␉␉}␊
806␉␉␉␉}␊
807␉␉␉}␊
808␉␉␉if (nstrings == 0) {␊
809␉␉␉␉newtablesptr[0] = 0;␊
810␉␉␉␉newtablesptr++;␊
811␉␉␉}␊
812␉␉␉newtablesptr[0] = 0;␊
813␉␉␉newtablesptr++;␊
814␉␉␉tablespresent[newcur->type]++;␊
815␉␉}␊
816␉}␊
817␊
818 // for each eventual complementary table not present in the original smbios, do the overrides␊
819␉for (i=0; i<sizeof(smbios_table_descriptions)/sizeof(smbios_table_descriptions[0]); i++) {␊
820␉␉int␉numnec = -1;␊
821␉␉char␉buffer[40];␊
822␊
823␉␉sprintf(buffer, "SMtable%d", i);␊
824␉␉if (!getIntForKey(buffer, &numnec, &bootInfo->smbiosConfig)) {␊
825␉␉␉numnec = -1;␊
826␉␉}␊
827␉␉if (numnec == -1 && do_auto && smbios_table_descriptions[i].numfunc) {␊
828␉␉␉numnec = smbios_table_descriptions[i].numfunc(smbios_table_descriptions[i].type);␊
829␉␉}␊
830␉␉while (tablespresent[smbios_table_descriptions[i].type] < numnec) {␊
831␉␉␉struct smbios_table_header␉*newcur = (struct smbios_table_header *) newtablesptr;␊
832␉␉␉int␉␉␉␉nstrings = 0;␊
833␊
834␉␉␉memset(newcur,0, smbios_table_descriptions[i].len);␊
835␉␉␉while (handles[(nexthandle)/8] & (1 << ((nexthandle) % 8))) {␊
836␉␉␉␉nexthandle++;␊
837␉␉␉}␊
838␉␉␉newcur->handle = nexthandle;␊
839␉␉␉handles[nexthandle / 8] |= 1 << (nexthandle % 8);␊
840␉␉␉newcur->type = smbios_table_descriptions[i].type;␊
841␉␉␉newcur->length = smbios_table_descriptions[i].len;␊
842␉␉␉newtablesptr += smbios_table_descriptions[i].len;␊
843␉␉␉for (j=0; j<sizeof(smbios_properties)/sizeof(smbios_properties[0]); j++) {␊
844␉␉␉␉const char␉*str;␊
845␉␉␉␉int␉␉size;␊
846␉␉␉␉int␉␉num;␊
847␉␉␉␉char␉␉altname[40];␊
848␊
849␉␉␉␉sprintf(altname, "%s_%d", smbios_properties[j].name, tablespresent[newcur->type] + 1);␊
850␉␉␉␉if (smbios_properties[j].table_type == newcur->type) {␊
851␉␉␉␉␉switch (smbios_properties[j].value_type) {␊
852␉␉␉␉␉case SMSTRING:␊
853␉␉␉␉␉␉if (getValueForKey(altname, &str, &size, &bootInfo->smbiosConfig) ||␊
854␉␉␉␉␉␉ getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig))␊
855␉␉␉␉␉␉{␊
856␉␉␉␉␉␉␉memcpy(newtablesptr, str, size);␊
857␉␉␉␉␉␉␉newtablesptr[size] = 0;␊
858␉␉␉␉␉␉␉newtablesptr += size + 1;␊
859␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = ++nstrings;␊
860␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_str) {␊
861␉␉␉␉␉␉␉str = smbios_properties[j].auto_str(smbios_properties[j].name, tablespresent[newcur->type]);␊
862␉␉␉␉␉␉␉size = strlen(str);␊
863␉␉␉␉␉␉␉memcpy(newtablesptr, str, size);␊
864␉␉␉␉␉␉␉newtablesptr[size] = 0;␊
865␉␉␉␉␉␉␉newtablesptr += size + 1;␊
866␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = ++nstrings;␊
867␉␉␉␉␉␉}␊
868␉␉␉␉␉␉break;␊
869␊
870␉␉␉␉␉case SMOWORD:␊
871␉␉␉␉␉␉if (getValueForKey(altname, &str, &size, &bootInfo->smbiosConfig) ||␊
872␉␉␉␉␉␉ getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig))␊
873␉␉␉␉␉␉{␊
874␉␉␉␉␉␉␉int␉␉k=0, t=0, kk=0;␊
875␉␉␉␉␉␉␉const char␉*ptr = str;␊
876␊
877␉␉␉␉␉␉␉memset(((char*)newcur) + smbios_properties[j].offset, 0, 16);␊
878␉␉␉␉␉␉␉while (ptr-str<size && *ptr && (*ptr==' ' || *ptr=='\t' || *ptr=='\n')) {␊
879␉␉␉␉␉␉␉␉ptr++;␊
880␉␉␉␉␉␉␉}␊
881␉␉␉␉␉␉␉if (size-(ptr-str)>=2 && ptr[0]=='0' && (ptr[1]=='x' || ptr[1]=='X')) {␊
882␉␉␉␉␉␉␉␉ptr += 2;␊
883␉␉␉␉␉␉␉}␊
884␉␉␉␉␉␉␉for (;ptr-str<size && *ptr && k<16;ptr++) {␊
885␉␉␉␉␉␉␉␉if (*ptr>='0' && *ptr<='9') {␊
886␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'0')),kk++;␊
887␉␉␉␉␉␉␉␉}␊
888␉␉␉␉␉␉␉␉if (*ptr>='a' && *ptr<='f') {␊
889␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'a'+10)),kk++;␊
890␉␉␉␉␉␉␉␉}␊
891␉␉␉␉␉␉␉␉if (*ptr>='A' && *ptr<='F') {␊
892␉␉␉␉␉␉␉␉␉(t=(t<<4)|(*ptr-'A'+10)),kk++;␊
893␉␉␉␉␉␉␉␉}␊
894␉␉␉␉␉␉␉␉if (kk == 2) {␊
895␉␉␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset + k)) = t;␊
896␉␉␉␉␉␉␉␉␉k++;␊
897␉␉␉␉␉␉␉␉␉kk = 0;␊
898␉␉␉␉␉␉␉␉␉t = 0;␊
899␉␉␉␉␉␉␉␉}␊
900␉␉␉␉␉␉␉}␊
901␉␉␉␉␉␉}␊
902␉␉␉␉␉␉break;␊
903␉␉␉␉␉␉␊
904␉␉␉␉␉case SMBYTE:␊
905␉␉␉␉␉␉if (getIntForKey(altname, &num, &bootInfo->smbiosConfig) ||␊
906␉␉␉␉␉␉ getIntForKey(smbios_properties[j].name, &num, &bootInfo->smbiosConfig))␊
907␉␉␉␉␉␉{␊
908␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = num;␊
909␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_int) {␊
910␉␉␉␉␉␉␉*((uint8_t*)(((char*)newcur) + smbios_properties[j].offset)) = smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]);␊
911␉␉␉␉␉␉}␊
912␉␉␉␉␉␉break;␊
913␉␉␉␉␉␉␊
914␉␉␉␉␉case SMWORD:␊
915␉␉␉␉␉␉if (getIntForKey(altname, &num, &bootInfo->smbiosConfig) ||␊
916␉␉␉␉␉␉ getIntForKey(smbios_properties[j].name, &num, &bootInfo->smbiosConfig))␊
917␉␉␉␉␉␉{␊
918␉␉␉␉␉␉␉*((uint16_t*)(((char*)newcur) + smbios_properties[j].offset)) = num;␊
919␉␉␉␉␉␉} else if (do_auto && smbios_properties[j].auto_int) {␊
920␉␉␉␉␉␉␉*((uint16_t*)(((char*)newcur)+smbios_properties[j].offset)) = smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]);␊
921␉␉␉␉␉␉}␊
922␉␉␉␉␉␉break;␊
923␉␉␉␉␉}␊
924␉␉␉␉}␊
925␉␉␉}␊
926␉␉␉if (nstrings == 0) {␊
927␉␉␉␉newtablesptr[0] = 0;␊
928␉␉␉␉newtablesptr++;␊
929␉␉␉}␊
930␉␉␉newtablesptr[0] = 0;␊
931␉␉␉newtablesptr++;␊
932␉␉␉tablespresent[smbios_table_descriptions[i].type]++;␊
933␉␉}␊
934␉}␊
935␊
936 // calculate new checksums␊
937␉newsmbios->dmi.checksum = 0;␊
938␉newsmbios->dmi.checksum = 256 - checksum8(&newsmbios->dmi, sizeof(newsmbios->dmi));␊
939␉newsmbios->checksum = 0;␊
940␉newsmbios->checksum = 256 - checksum8(newsmbios, sizeof(*newsmbios));␊
941␉␊
942␉if (!done) {␊
943␉␉verbose("Patched DMI Table\n");␊
944␉␉done=true;␊
945␉}␊
946}␊
947␊
948#define MAX_DMI_TABLES 96␊
949typedef struct DmiNumAssocTag {␊
950 struct DMIHeader * dmi;␊
951 uint8_t type;␊
952} DmiNumAssoc;␊
953␊
954static DmiNumAssoc DmiTablePair[MAX_DMI_TABLES];␊
955static int DmiTablePairCount = 0;␊
956static int current_pos=0;␊
957static bool ftTablePairInit = true;␊
958␊
959/** ␊
960 * Get a table structure entry from a type specification and a smbios address␊
961 * return NULL if table is not found␊
962 */␊
963static void getSmbiosTableStructure(struct SMBEntryPoint *smbios)␊
964{␊
965 struct DMIHeader * dmihdr=NULL;␊
966 SMBByte* p;␊
967 int i;␊
968␊
969 if (ftTablePairInit && smbios!=NULL) {␊
970 ftTablePairInit = false;␊
971#if DEBUG_SMBIOS␊
972 printf(">>> SMBIOSAddr=0x%08x\n", smbios);␊
973 printf(">>> DMI: addr=0x%08x, len=%d, count=%d\n", smbios->dmi.tableAddress, ␊
974 smbios->dmi.tableLength, smbios->dmi.structureCount);␊
975#endif␊
976 p = (SMBByte *) smbios->dmi.tableAddress;␊
977 for (i=0; ␊
978 i < smbios->dmi.structureCount && ␊
979 p + 4 <= (SMBByte *)smbios->dmi.tableAddress + smbios->dmi.tableLength; ␊
980 i++) {␊
981 dmihdr = (struct DMIHeader *) p;␊
982 ␊
983#if DEBUG_SMBIOS␊
984 // verbose(">>>>>> DMI(%d): type=0x%02x, len=0x%d\n",i,dmihdr->type,dmihdr->length);␊
985#endif␊
986 if (dmihdr->length < 4 || dmihdr->type == 127 /* EOT */) break;␊
987 if (DmiTablePairCount < MAX_DMI_TABLES) {␊
988 DmiTablePair[DmiTablePairCount].dmi = dmihdr;␊
989 DmiTablePair[DmiTablePairCount].type = dmihdr->type;␊
990 DmiTablePairCount++;␊
991 }␊
992 else {␊
993 printf("DMI table entries list is full! Next entries won't be stored.\n");␊
994 }␊
995#if DEBUG_SMBIOS␊
996 printf("DMI header found for table type %d, length = %d\n", dmihdr->type, dmihdr->length);␊
997#endif␊
998 p = p + dmihdr->length;␊
999 while ((p - (SMBByte *)smbios->dmi.tableAddress + 1 < smbios->dmi.tableLength) && (p[0] != 0x00 || p[1] != 0x00)) {␊
1000 p++;␊
1001␉ }␊
1002 p += 2;␊
1003␉}␊
1004 ␊
1005 }␊
1006}␊
1007␊
1008/** Get original or new smbios entry point, if sucessful, the adresses are cached for next time */␊
1009struct SMBEntryPoint *getSmbios(int which)␊
1010{␊
1011 static struct SMBEntryPoint *orig = NULL; // cached␊
1012 static struct SMBEntryPoint *patched = NULL; // cached␊
1013␊
1014 // whatever we are called with orig or new flag, initialize asap both structures␊
1015 switch (which) {␊
1016 case SMBIOS_ORIGINAL:␊
1017 if (orig==NULL) {␊
1018 orig = getAddressOfSmbiosTable();␊
1019 getSmbiosTableStructure(orig); // generate tables entry list for fast table finding␊
1020 }␊
1021 return orig;␊
1022 case SMBIOS_PATCHED:␊
1023 if (orig==NULL && (orig = getAddressOfSmbiosTable())==NULL ) {␊
1024 printf("Could not find original SMBIOS !!\n");␊
1025 pause();␊
1026 } else {␊
1027 patched = smbios_dry_run(orig);␊
1028 if(patched==NULL) {␊
1029 printf("Could not create new SMBIOS !!\n");␊
1030 pause();␊
1031 }␊
1032 else {␊
1033 smbios_real_run(orig, patched);␊
1034 }␊
1035 }␊
1036␊
1037 return patched;␊
1038 default:␊
1039 printf("ERROR: invalid option for getSmbios() !!\n");␊
1040 break;␊
1041 }␊
1042␊
1043 return NULL;␊
1044}␊
1045␊
1046/** Find first original dmi Table with a particular type */␊
1047struct DMIHeader* FindFirstDmiTableOfType(int type, int minlength)␊
1048{␊
1049 current_pos = 0;␊
1050 ␊
1051 return FindNextDmiTableOfType(type, minlength);␊
1052};␊
1053␊
1054/** Find next original dmi Table with a particular type */␊
1055struct DMIHeader* FindNextDmiTableOfType(int type, int minlength)␊
1056{␊
1057 int i;␊
1058␊
1059 if (ftTablePairInit) getSmbios(SMBIOS_ORIGINAL);␊
1060␊
1061 for (i=current_pos; i < DmiTablePairCount; i++) {␊
1062 if (type == DmiTablePair[i].type && ␊
1063 DmiTablePair[i].dmi &&␊
1064 DmiTablePair[i].dmi->length >= minlength ) {␊
1065 current_pos = i+1;␊
1066 return DmiTablePair[i].dmi;␊
1067 }␊
1068 }␊
1069 return NULL; // not found␊
1070};␊
1071␊
1072␊
1073const char * smbiosStringAtIndex(DMIHeader* smHeader, int index, int* length )␊
1074{␊
1075 const char * last = 0;␊
1076 const char * next = (const char *) smHeader + smHeader->length;␊
1077␉␊
1078 if ( length ) *length = 0;␊
1079 while ( index-- )␊
1080 {␊
1081 last = 0;␊
1082␉␉const char * cp = 0;␊
1083␉␉for ( cp = next; *cp || cp[1]; cp++ )␊
1084 {␊
1085 if ( *cp == '\0' )␊
1086 {␊
1087 last = next;␊
1088 next = cp + 1;␊
1089 break;␊
1090 }␊
1091 }␊
1092 if ( last == 0 ) break;␊
1093 }␊
1094␉␊
1095 if ( last )␊
1096 {␊
1097 while (*last == ' ') last++;␊
1098 if (length)␊
1099 {␊
1100 UInt8 len;␊
1101 for ( len = next - last - 1; len && last[len - 1] == ' '; len-- )␊
1102 ;␊
1103 *length = len; // number of chars not counting the terminating NULL␊
1104 }␊
1105 }␊
1106␉␊
1107 return last ? last : "";␊
1108}␊
1109␊
1110␊
1111char* getSmbiosProductName()␊
1112{␊
1113␉struct SMBEntryPoint␉*smbios;␊
1114␉SMBSystemInformation␉*p;␊
1115␉char*␉␉␉␉␉tempString;␊
1116␉int␉␉␉␉␉␉tmpLen;␊
1117␉␊
1118␉smbios = getSmbios(SMBIOS_ORIGINAL);␊
1119␉if (smbios==NULL) return 0; ␊
1120␉␊
1121␉p = (SMBSystemInformation*) FindFirstDmiTableOfType(1, 0x19); // Type 1: (3.3.2) System Information␊
1122␉if (p==NULL) return NULL;␊
1123␉␊
1124␉␊
1125␉tempString = (char*)smbiosStringAtIndex((DMIHeader*)p, p->productName, &tmpLen);␊
1126␉tempString[tmpLen] = 0;␊
1127␉␊
1128␉gSMBIOSBoardModel = malloc(tmpLen + 1);␊
1129␉if(gSMBIOSBoardModel)␊
1130␉{␊
1131␉␉strncpy(gSMBIOSBoardModel, tempString, tmpLen);␊
1132␉␉Node* node = DT__FindNode("/", false);␊
1133␉␉DT__AddProperty(node, "orig-model", tmpLen, gSMBIOSBoardModel);␊
1134␉}␊
1135␉verbose("Actual model name is '%s'\n", tempString);␊
1136␉return gSMBIOSBoardModel;␊
1137}␊
1138␊
1139

Archive Download this file

Revision: 1146