78a7480420df7696ff68b4ef56133e69dfe09a42
[people/balajirrao/gpxe.git] / src / arch / i386 / firmware / pcbios / smbios.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <string.h>
21 #include <stdio.h>
22 #include <errno.h>
23 #include <gpxe/uaccess.h>
24 #include <realmode.h>
25 #include <pnpbios.h>
26 #include <smbios.h>
27
28 /** @file
29  *
30  * System Management BIOS
31  *
32  */
33
34 /** Signature for SMBIOS entry point */
35 #define SMBIOS_SIGNATURE \
36         ( ( '_' << 0 ) + ( 'S' << 8 ) + ( 'M' << 16 ) + ( '_' << 24 ) )
37
38 /**
39  * SMBIOS entry point
40  *
41  * This is the single table which describes the list of SMBIOS
42  * structures.  It is located by scanning through the BIOS segment.
43  */
44 struct smbios_entry {
45         /** Signature
46          *
47          * Must be equal to SMBIOS_SIGNATURE
48          */
49         uint32_t signature;
50         /** Checksum */
51         uint8_t checksum;
52         /** Length */
53         uint8_t length;
54         /** Major version */
55         uint8_t major;
56         /** Minor version */
57         uint8_t minor;
58         /** Maximum structure size */
59         uint16_t max;
60         /** Entry point revision */
61         uint8_t revision;
62         /** Formatted area */
63         uint8_t formatted[5];
64         /** DMI Signature */
65         uint8_t dmi_signature[5];
66         /** DMI checksum */
67         uint8_t dmi_checksum;
68         /** Structure table length */
69         uint16_t smbios_length;
70         /** Structure table address */
71         physaddr_t smbios_address;
72         /** Number of SMBIOS structures */
73         uint16_t smbios_count;
74         /** BCD revision */
75         uint8_t bcd_revision;
76 } __attribute__ (( packed ));
77
78 /**
79  * SMBIOS entry point descriptor
80  *
81  * This contains the information from the SMBIOS entry point that we
82  * care about.
83  */
84 struct smbios {
85         /** Start of SMBIOS structures */
86         userptr_t address;
87         /** Length of SMBIOS structures */ 
88         size_t length;
89         /** Number of SMBIOS structures */
90         unsigned int count;
91 };
92
93 /**
94  * SMBIOS strings descriptor
95  *
96  * This is returned as part of the search for an SMBIOS structure, and
97  * contains the information needed for extracting the strings within
98  * the "unformatted" portion of the structure.
99  */
100 struct smbios_strings {
101         /** Start of strings data */
102         userptr_t data;
103         /** Length of strings data */
104         size_t length;
105 };
106
107 /**
108  * Find SMBIOS
109  *
110  * @ret smbios          SMBIOS entry point descriptor, or NULL if not found
111  */
112 static struct smbios * find_smbios ( void ) {
113         static struct smbios smbios = {
114                 .address = UNULL,
115         };
116         union {
117                 struct smbios_entry entry;
118                 uint8_t bytes[256]; /* 256 is maximum length possible */
119         } u;
120         unsigned int offset;
121         size_t len;
122         unsigned int i;
123         uint8_t sum;
124
125         /* Return cached result if available */
126         if ( smbios.address != UNULL )
127                 return &smbios;
128
129         /* Try to find SMBIOS */
130         for ( offset = 0 ; offset < 0x10000 ; offset += 0x10 ) {
131
132                 /* Read start of header and verify signature */
133                 copy_from_real ( &u.entry, BIOS_SEG, offset,
134                                  sizeof ( u.entry ));
135                 if ( u.entry.signature != SMBIOS_SIGNATURE )
136                         continue;
137
138                 /* Read whole header and verify checksum */
139                 len = u.entry.length;
140                 copy_from_real ( &u.bytes, BIOS_SEG, offset, len );
141                 for ( i = 0 , sum = 0 ; i < len ; i++ ) {
142                         sum += u.bytes[i];
143                 }
144                 if ( sum != 0 ) {
145                         DBG ( "SMBIOS at %04x:%04x has bad checksum %02x\n",
146                               BIOS_SEG, offset, sum );
147                         continue;
148                 }
149
150                 /* Fill result structure */
151                 DBG ( "Found SMBIOS entry point at %04x:%04x\n",
152                       BIOS_SEG, offset );
153                 smbios.address = phys_to_user ( u.entry.smbios_address );
154                 smbios.length = u.entry.smbios_length;
155                 smbios.count = u.entry.smbios_count;
156                 return &smbios;
157         }
158
159         DBG ( "No SMBIOS found\n" );
160         return NULL;
161 }
162
163 /**
164  * Find SMBIOS strings terminator
165  *
166  * @v smbios            SMBIOS entry point descriptor
167  * @v offset            Offset to start of strings
168  * @ret offset          Offset to strings terminator, or 0 if not found
169  */
170 static size_t find_strings_terminator ( struct smbios *smbios,
171                                         size_t offset ) {
172         size_t max_offset = ( smbios->length - 2 );
173         uint16_t nulnul;
174
175         for ( ; offset <= max_offset ; offset++ ) {
176                 copy_from_user ( &nulnul, smbios->address, offset, 2 );
177                 if ( nulnul == 0 )
178                         return ( offset + 1 );
179         }
180         return 0;
181 }
182
183 /**
184  * Find specific structure type within SMBIOS
185  *
186  * @v type              Structure type to search for
187  * @v structure         Buffer to fill in with structure
188  * @v length            Length of buffer
189  * @v strings           Strings descriptor to fill in, or NULL
190  * @ret rc              Return status code
191  */
192 int find_smbios_structure ( unsigned int type, void *structure,
193                             size_t length, struct smbios_strings *strings ) {
194         struct smbios *smbios;
195         struct smbios_header header;
196         struct smbios_strings temp_strings;
197         unsigned int count = 0;
198         size_t offset = 0;
199         size_t strings_offset;
200         size_t terminator_offset;
201
202         /* Locate SMBIOS entry point */
203         if ( ! ( smbios = find_smbios() ) )
204                 return -ENOENT;
205
206         /* Ensure that we have a usable strings descriptor buffer */
207         if ( ! strings )
208                 strings = &temp_strings;
209
210         /* Scan through list of structures */
211         while ( ( ( offset + sizeof ( header ) ) < smbios->length ) &&
212                 ( count < smbios->count ) ) {
213
214                 /* Read next SMBIOS structure header */
215                 copy_from_user ( &header, smbios->address, offset,
216                                  sizeof ( header ) );
217
218                 /* Determine start and extent of strings block */
219                 strings_offset = ( offset + header.length );
220                 if ( strings_offset > smbios->length ) {
221                         DBG ( "SMBIOS structure at offset %zx with length "
222                               "%zx extends beyond SMBIOS\n", offset,
223                               header.length );
224                         return -ENOENT;
225                 }
226                 terminator_offset =
227                         find_strings_terminator ( smbios, strings_offset );
228                 if ( ! terminator_offset ) {
229                         DBG ( "SMBIOS structure at offset %zx has "
230                               "unterminated strings section\n", offset );
231                         return -ENOENT;
232                 }
233                 strings->data = userptr_add ( smbios->address,
234                                               strings_offset );
235                 strings->length = ( terminator_offset - strings_offset );
236
237                 DBG ( "SMBIOS structure at offset %zx has type %d, "
238                       "length %zx, strings length %zx\n",
239                       offset, header.type, header.length, strings->length );
240
241                 /* If this is the structure we want, return */
242                 if ( header.type == type ) {
243                         if ( length > header.length )
244                                 length = header.length;
245                         copy_from_user ( structure, smbios->address,
246                                          offset, length );
247                         return 0;
248                 }
249
250                 /* Move to next SMBIOS structure */
251                 offset = ( terminator_offset + 1 );
252                 count++;
253         }
254
255         DBG ( "SMBIOS structure type %d not found\n", type );
256         return -ENOENT;
257 }
258
259 /**
260  * Find indexed string within SMBIOS structure
261  *
262  * @v strings           SMBIOS strings descriptor
263  * @v index             String index
264  * @v buffer            Buffer for string
265  * @v length            Length of string buffer
266  * @ret rc              Return status code
267  */
268 int find_smbios_string ( struct smbios_strings *strings, unsigned int index,
269                          char *buffer, size_t length ) {
270         size_t offset = 0;
271         size_t string_len;
272
273         /* Zero buffer.  This ensures that a valid NUL terminator is
274          * always present (unless length==0).
275          */
276         memset ( buffer, 0, length );
277            
278         /* String numbers start at 1 (0 is used to indicate "no string") */
279         if ( ! index )
280                 return 0;
281
282         while ( offset < strings->length ) {
283                 /* Get string length.  This is known safe, since the
284                  * smbios_strings struct is constructed so as to
285                  * always end on a string boundary.
286                  */
287                 string_len = strlen_user ( strings->data, offset );
288                 if ( --index == 0 ) {
289                         /* Copy string, truncating as necessary. */
290                         if ( string_len >= length )
291                                 string_len = ( length - 1 );
292                         copy_from_user ( buffer, strings->data,
293                                          offset, string_len );
294                         return 0;
295                 }
296                 offset += ( string_len + 1 );
297         }
298
299         DBG ( "SMBIOS string index %d not found\n", index );
300         return -ENOENT;
301 }
302
303 /**
304  * Find SMBIOS serial number
305  *
306  */
307 int dump_smbios_info ( void ) {
308         struct smbios_system_information sysinfo;
309         struct smbios_strings strings;
310         char buf[64];
311         int rc;
312
313         if ( ( rc = find_smbios_structure ( SMBIOS_TYPE_SYSTEM_INFORMATION,
314                                             &sysinfo, sizeof ( sysinfo ),
315                                             &strings ) ) != 0 )
316                 return rc;
317
318         DBG_HD ( &sysinfo, sizeof ( sysinfo ) );
319
320         if ( ( rc = find_smbios_string ( &strings, sysinfo.manufacturer,
321                                          buf, sizeof ( buf ) ) ) != 0 )
322                 return rc;
323         DBG ( "Manufacturer: \"%s\"\n", buf );
324
325         if ( ( rc = find_smbios_string ( &strings, sysinfo.product,
326                                          buf, sizeof ( buf ) ) ) != 0 )
327                 return rc;
328         DBG ( "Product: \"%s\"\n", buf );
329
330         DBG ( "UUID:\n" );
331         DBG_HD ( &sysinfo.uuid, sizeof ( sysinfo.uuid ) );
332
333         return 0;
334 }