initial commit
[freebsd-arm:freebsd-arm.git] / boot / i386 / libi386 / smbios.c
1 /*-
2  * Copyright (c) 2005-2009 Jung-uk Kim <jkim@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *      notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *      notice, this list of conditions and the following disclaimer in the
12  *      documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <stand.h>
31 #include <bootstrap.h>
32 #include <sys/endian.h>
33
34 #include "btxv86.h"
35 #include "libi386.h"
36
37 /*
38  * Detect SMBIOS and export information about the SMBIOS into the
39  * environment.
40  *
41  * System Management BIOS Reference Specification, v2.6 Final
42  * http://www.dmtf.org/standards/published_documents/DSP0134_2.6.0.pdf
43  */
44
45 /*
46  * 2.1.1 SMBIOS Structure Table Entry Point
47  *
48  * "On non-EFI systems, the SMBIOS Entry Point structure, described below, can
49  * be located by application software by searching for the anchor-string on
50  * paragraph (16-byte) boundaries within the physical memory address range
51  * 000F0000h to 000FFFFFh. This entry point encapsulates an intermediate anchor
52  * string that is used by some existing DMI browsers."
53  */
54 #define SMBIOS_START            0xf0000
55 #define SMBIOS_LENGTH           0x10000
56 #define SMBIOS_STEP             0x10
57 #define SMBIOS_SIG              "_SM_"
58 #define SMBIOS_DMI_SIG          "_DMI_"
59
60 #define SMBIOS_GET8(base, off)  (*(uint8_t *)((base) + (off)))
61 #define SMBIOS_GET16(base, off) (*(uint16_t *)((base) + (off)))
62 #define SMBIOS_GET32(base, off) (*(uint32_t *)((base) + (off)))
63
64 #define SMBIOS_GETLEN(base)     SMBIOS_GET8(base, 0x01)
65 #define SMBIOS_GETSTR(base)     ((base) + SMBIOS_GETLEN(base))
66
67 static uint32_t smbios_enabled_memory = 0;
68 static uint32_t smbios_old_enabled_memory = 0;
69 static uint8_t  smbios_enabled_sockets = 0;
70 static uint8_t  smbios_populated_sockets = 0;
71
72 static uint8_t
73 smbios_checksum(const caddr_t addr, const uint8_t len)
74 {
75         uint8_t         sum;
76         int             i;
77
78         for (sum = 0, i = 0; i < len; i++)
79                 sum += SMBIOS_GET8(addr, i);
80         return (sum);
81 }
82
83 static caddr_t
84 smbios_sigsearch(const caddr_t addr, const uint32_t len)
85 {
86         caddr_t         cp;
87
88         /* Search on 16-byte boundaries. */
89         for (cp = addr; cp < addr + len; cp += SMBIOS_STEP)
90                 if (strncmp(cp, SMBIOS_SIG, 4) == 0 &&
91                     smbios_checksum(cp, SMBIOS_GET8(cp, 0x05)) == 0 &&
92                     strncmp(cp + 0x10, SMBIOS_DMI_SIG, 5) == 0 &&
93                     smbios_checksum(cp + 0x10, 0x0f) == 0)
94                         return (cp);
95         return (NULL);
96 }
97
98 static void
99 smbios_setenv(const char *name, caddr_t addr, const int offset)
100 {
101         caddr_t         cp;
102         int             i, idx;
103
104         idx = SMBIOS_GET8(addr, offset);
105         if (idx != 0) {
106                 cp = SMBIOS_GETSTR(addr);
107                 for (i = 1; i < idx; i++)
108                         cp += strlen(cp) + 1;
109                 setenv(name, cp, 1);
110         }
111 }
112
113 #ifdef SMBIOS_SERIAL_NUMBERS
114
115 #define UUID_SIZE               16
116 #define UUID_TYPE               uint32_t
117 #define UUID_STEP               sizeof(UUID_TYPE)
118 #define UUID_ALL_BITS           (UUID_SIZE / UUID_STEP)
119 #define UUID_GET(base, off)     (*(UUID_TYPE *)((base) + (off)))
120
121 static void
122 smbios_setuuid(const char *name, const caddr_t addr, const int ver)
123 {
124         char            uuid[37];
125         int             i, ones, zeros;
126         UUID_TYPE       n;
127         uint32_t        f1;
128         uint16_t        f2, f3;
129
130         for (i = 0, ones = 0, zeros = 0; i < UUID_SIZE; i += UUID_STEP) {
131                 n = UUID_GET(addr, i) + 1;
132                 if (zeros == 0 && n == 0)
133                         ones++;
134                 else if (ones == 0 && n == 1)
135                         zeros++;
136                 else
137                         break;
138         }
139
140         if (ones != UUID_ALL_BITS && zeros != UUID_ALL_BITS) {
141                 /*
142                  * 3.3.2.1 System UUID
143                  *
144                  * "Although RFC 4122 recommends network byte order for all
145                  * fields, the PC industry (including the ACPI, UEFI, and
146                  * Microsoft specifications) has consistently used
147                  * little-endian byte encoding for the first three fields:
148                  * time_low, time_mid, time_hi_and_version. The same encoding,
149                  * also known as wire format, should also be used for the
150                  * SMBIOS representation of the UUID."
151                  *
152                  * Note: We use network byte order for backward compatibility
153                  * unless SMBIOS version is 2.6+ or little-endian is forced.
154                  */
155 #ifndef SMBIOS_LITTLE_ENDIAN_UUID
156                 if (ver < 0x0206) {
157                         f1 = ntohl(SMBIOS_GET32(addr, 0));
158                         f2 = ntohs(SMBIOS_GET16(addr, 4));
159                         f3 = ntohs(SMBIOS_GET16(addr, 6));
160                 } else
161 #endif
162                 {
163                         f1 = le32toh(SMBIOS_GET32(addr, 0));
164                         f2 = le16toh(SMBIOS_GET16(addr, 4));
165                         f3 = le16toh(SMBIOS_GET16(addr, 6));
166                 }
167                 sprintf(uuid,
168                     "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
169                     f1, f2, f3, SMBIOS_GET8(addr, 8), SMBIOS_GET8(addr, 9),
170                     SMBIOS_GET8(addr, 10), SMBIOS_GET8(addr, 11),
171                     SMBIOS_GET8(addr, 12), SMBIOS_GET8(addr, 13),
172                     SMBIOS_GET8(addr, 14), SMBIOS_GET8(addr, 15));
173                 setenv(name, uuid, 1);
174         }
175 }
176
177 #undef UUID_SIZE
178 #undef UUID_TYPE
179 #undef UUID_STEP
180 #undef UUID_ALL_BITS
181 #undef UUID_GET
182
183 #endif
184
185 static caddr_t
186 smbios_parse_table(const caddr_t addr, const int ver)
187 {
188         caddr_t         cp;
189         int             proc, size, osize, type;
190
191         type = SMBIOS_GET8(addr, 0);    /* 3.1.2 Structure Header Format */
192         switch(type) {
193         case 0:         /* 3.3.1 BIOS Information (Type 0) */
194                 smbios_setenv("smbios.bios.vendor", addr, 0x04);
195                 smbios_setenv("smbios.bios.version", addr, 0x05);
196                 smbios_setenv("smbios.bios.reldate", addr, 0x08);
197                 break;
198
199         case 1:         /* 3.3.2 System Information (Type 1) */
200                 smbios_setenv("smbios.system.maker", addr, 0x04);
201                 smbios_setenv("smbios.system.product", addr, 0x05);
202                 smbios_setenv("smbios.system.version", addr, 0x06);
203 #ifdef SMBIOS_SERIAL_NUMBERS
204                 smbios_setenv("smbios.system.serial", addr, 0x07);
205                 smbios_setuuid("smbios.system.uuid", addr + 0x08, ver);
206 #endif
207                 break;
208
209         case 2:         /* 3.3.3 Base Board (or Module) Information (Type 2) */
210                 smbios_setenv("smbios.planar.maker", addr, 0x04);
211                 smbios_setenv("smbios.planar.product", addr, 0x05);
212                 smbios_setenv("smbios.planar.version", addr, 0x06);
213 #ifdef SMBIOS_SERIAL_NUMBERS
214                 smbios_setenv("smbios.planar.serial", addr, 0x07);
215 #endif
216                 break;
217
218         case 3:         /* 3.3.4 System Enclosure or Chassis (Type 3) */
219                 smbios_setenv("smbios.chassis.maker", addr, 0x04);
220                 smbios_setenv("smbios.chassis.version", addr, 0x06);
221 #ifdef SMBIOS_SERIAL_NUMBERS
222                 smbios_setenv("smbios.chassis.serial", addr, 0x07);
223                 smbios_setenv("smbios.chassis.tag", addr, 0x08);
224 #endif
225                 break;
226
227         case 4:         /* 3.3.5 Processor Information (Type 4) */
228                 /*
229                  * Offset 18h: Processor Status
230                  *
231                  * Bit 7        Reserved, must be 0
232                  * Bit 6        CPU Socket Populated
233                  *              1 - CPU Socket Populated
234                  *              0 - CPU Socket Unpopulated
235                  * Bit 5:3      Reserved, must be zero
236                  * Bit 2:0      CPU Status
237                  *              0h - Unknown
238                  *              1h - CPU Enabled
239                  *              2h - CPU Disabled by User via BIOS Setup
240                  *              3h - CPU Disabled by BIOS (POST Error)
241                  *              4h - CPU is Idle, waiting to be enabled
242                  *              5-6h - Reserved
243                  *              7h - Other
244                  */
245                 proc = SMBIOS_GET8(addr, 0x18);
246                 if ((proc & 0x07) == 1)
247                         smbios_enabled_sockets++;
248                 if ((proc & 0x40) != 0)
249                         smbios_populated_sockets++;
250                 break;
251
252         case 6:         /* 3.3.7 Memory Module Information (Type 6, Obsolete) */
253                 /*
254                  * Offset 0Ah: Enabled Size
255                  *
256                  * Bit 7        Bank connection
257                  *              1 - Double-bank connection
258                  *              0 - Single-bank connection
259                  * Bit 6:0      Size (n), where 2**n is the size in MB
260                  *              7Dh - Not determinable (Installed Size only)
261                  *              7Eh - Module is installed, but no memory
262                  *                    has been enabled
263                  *              7Fh - Not installed
264                  */
265                 osize = SMBIOS_GET8(addr, 0x0a) & 0x7f;
266                 if (osize > 0 && osize < 22)
267                         smbios_old_enabled_memory += 1 << (osize + 10);
268                 break;
269
270         case 17:        /* 3.3.18 Memory Device (Type 17) */
271                 /*
272                  * Offset 0Ch: Size
273                  *
274                  * Bit 15       Granularity
275                  *              1 - Value is in kilobytes units
276                  *              0 - Value is in megabytes units
277                  * Bit 14:0     Size
278                  */
279                 size = SMBIOS_GET16(addr, 0x0c);
280                 if (size != 0 && size != 0xffff)
281                         smbios_enabled_memory += (size & 0x8000) != 0 ?
282                             (size & 0x7fff) : (size << 10);
283                 break;
284
285         default:        /* skip other types */
286                 break;
287         }
288
289         /* Find structure terminator. */
290         cp = SMBIOS_GETSTR(addr);
291         while (SMBIOS_GET16(cp, 0) != 0)
292                 cp++;
293
294         return (cp + 2);
295 }
296
297 void
298 smbios_detect(void)
299 {
300         char            buf[16];
301         caddr_t         addr, dmi, smbios;
302         size_t          count, length;
303         uint32_t        paddr;
304         int             i, major, minor, ver;
305
306         /* Search signatures and validate checksums. */
307         smbios = smbios_sigsearch(PTOV(SMBIOS_START), SMBIOS_LENGTH);
308         if (smbios == NULL)
309                 return;
310
311         length = SMBIOS_GET16(smbios, 0x16);    /* Structure Table Length */
312         paddr = SMBIOS_GET32(smbios, 0x18);     /* Structure Table Address */
313         count = SMBIOS_GET16(smbios, 0x1c);     /* No of SMBIOS Structures */
314         ver = SMBIOS_GET8(smbios, 0x1e);        /* SMBIOS BCD Revision */
315
316         if (ver != 0) {
317                 major = ver >> 4;
318                 minor = ver & 0x0f;
319                 if (major > 9 || minor > 9)
320                         ver = 0;
321         }
322         if (ver == 0) {
323                 major = SMBIOS_GET8(smbios, 0x06); /* SMBIOS Major Version */
324                 minor = SMBIOS_GET8(smbios, 0x07); /* SMBIOS Minor Version */
325         }
326         ver = (major << 8) | minor;
327
328         addr = PTOV(paddr);
329         for (dmi = addr, i = 0; dmi < addr + length && i < count; i++)
330                 dmi = smbios_parse_table(dmi, ver);
331
332         sprintf(buf, "%d.%d", major, minor);
333         setenv("smbios.version", buf, 1);
334         if (smbios_enabled_memory > 0 || smbios_old_enabled_memory > 0) {
335                 sprintf(buf, "%u", smbios_enabled_memory > 0 ?
336                     smbios_enabled_memory : smbios_old_enabled_memory);
337                 setenv("smbios.memory.enabled", buf, 1);
338         }
339         if (smbios_enabled_sockets > 0) {
340                 sprintf(buf, "%u", smbios_enabled_sockets);
341                 setenv("smbios.socket.enabled", buf, 1);
342         }
343         if (smbios_populated_sockets > 0) {
344                 sprintf(buf, "%u", smbios_populated_sockets);
345                 setenv("smbios.socket.populated", buf, 1);
346         }
347 }