[Settings] Expose SMBIOS via settings API
[people/mcb30/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 <errno.h>
22 #include <assert.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 len;
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_len;
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 len;
89         /** Number of SMBIOS structures */
90         unsigned int count;
91 };
92
93 /** SMBIOS entry point descriptor */
94 static struct smbios smbios = {
95         .address = UNULL,
96 };
97
98 /**
99  * Find SMBIOS
100  *
101  * @ret rc              Return status code
102  */
103 static int find_smbios ( void ) {
104         union {
105                 struct smbios_entry entry;
106                 uint8_t bytes[256]; /* 256 is maximum length possible */
107         } u;
108         static unsigned int offset = 0;
109         size_t len;
110         unsigned int i;
111         uint8_t sum;
112
113         /* Return cached result if avaiable */
114         if ( smbios.address != UNULL )
115                 return 0;
116
117         /* Try to find SMBIOS */
118         for ( ; offset < 0x10000 ; offset += 0x10 ) {
119
120                 /* Read start of header and verify signature */
121                 copy_from_real ( &u.entry, BIOS_SEG, offset,
122                                  sizeof ( u.entry ));
123                 if ( u.entry.signature != SMBIOS_SIGNATURE )
124                         continue;
125
126                 /* Read whole header and verify checksum */
127                 len = u.entry.len;
128                 copy_from_real ( &u.bytes, BIOS_SEG, offset, len );
129                 for ( i = 0 , sum = 0 ; i < len ; i++ ) {
130                         sum += u.bytes[i];
131                 }
132                 if ( sum != 0 ) {
133                         DBG ( "SMBIOS at %04x:%04x has bad checksum %02x\n",
134                               BIOS_SEG, offset, sum );
135                         continue;
136                 }
137
138                 /* Fill result structure */
139                 DBG ( "Found SMBIOS entry point at %04x:%04x\n",
140                       BIOS_SEG, offset );
141                 smbios.address = phys_to_user ( u.entry.smbios_address );
142                 smbios.len = u.entry.smbios_len;
143                 smbios.count = u.entry.smbios_count;
144                 return 0;
145         }
146
147         DBG ( "No SMBIOS found\n" );
148         return -ENODEV;
149 }
150
151 /**
152  * Find SMBIOS strings terminator
153  *
154  * @v offset            Offset to start of strings
155  * @ret offset          Offset to strings terminator, or 0 if not found
156  */
157 static size_t find_strings_terminator ( size_t offset ) {
158         size_t max_offset = ( smbios.len - 2 );
159         uint16_t nulnul;
160
161         for ( ; offset <= max_offset ; offset++ ) {
162                 copy_from_user ( &nulnul, smbios.address, offset, 2 );
163                 if ( nulnul == 0 )
164                         return ( offset + 1 );
165         }
166         return 0;
167 }
168
169 /**
170  * Find specific structure type within SMBIOS
171  *
172  * @v type              Structure type to search for
173  * @v structure         SMBIOS structure descriptor to fill in
174  * @ret rc              Return status code
175  */
176 int find_smbios_structure ( unsigned int type,
177                             struct smbios_structure *structure ) {
178         unsigned int count = 0;
179         size_t offset = 0;
180         size_t strings_offset;
181         size_t terminator_offset;
182         int rc;
183
184         /* Find SMBIOS */
185         if ( ( rc = find_smbios() ) != 0 )
186                 return rc;
187
188         /* Scan through list of structures */
189         while ( ( ( offset + sizeof ( structure->header ) ) < smbios.len )
190                 && ( count < smbios.count ) ) {
191
192                 /* Read next SMBIOS structure header */
193                 copy_from_user ( &structure->header, smbios.address, offset,
194                                  sizeof ( structure->header ) );
195
196                 /* Determine start and extent of strings block */
197                 strings_offset = ( offset + structure->header.len );
198                 if ( strings_offset > smbios.len ) {
199                         DBG ( "SMBIOS structure at offset %zx with length "
200                               "%x extends beyond SMBIOS\n", offset,
201                               structure->header.len );
202                         return -ENOENT;
203                 }
204                 terminator_offset = find_strings_terminator ( strings_offset );
205                 if ( ! terminator_offset ) {
206                         DBG ( "SMBIOS structure at offset %zx has "
207                               "unterminated strings section\n", offset );
208                         return -ENOENT;
209                 }
210                 structure->strings_len = ( terminator_offset - strings_offset);
211
212                 DBG ( "SMBIOS structure at offset %zx has type %d, length %x, "
213                       "strings length %zx\n", offset, structure->header.type,
214                       structure->header.len, structure->strings_len );
215
216                 /* If this is the structure we want, return */
217                 if ( structure->header.type == type ) {
218                         structure->offset = offset;
219                         return 0;
220                 }
221
222                 /* Move to next SMBIOS structure */
223                 offset = ( terminator_offset + 1 );
224                 count++;
225         }
226
227         DBG ( "SMBIOS structure type %d not found\n", type );
228         return -ENOENT;
229 }
230
231 /**
232  * Copy SMBIOS structure
233  *
234  * @v structure         SMBIOS structure descriptor
235  * @v data              Buffer to hold SMBIOS structure
236  * @v len               Length of buffer
237  * @ret rc              Return status code
238  */
239 int read_smbios_structure ( struct smbios_structure *structure,
240                             void *data, size_t len ) {
241
242         assert ( smbios.address != UNULL );
243
244         if ( len > structure->header.len )
245                 len = structure->header.len;
246         copy_from_user ( data, smbios.address, structure->offset, len );
247         return 0;
248 }
249
250 /**
251  * Find indexed string within SMBIOS structure
252  *
253  * @v structure         SMBIOS structure descriptor
254  * @v index             String index
255  * @v data              Buffer for string
256  * @v len               Length of string buffer
257  * @ret rc              Length of string, or negative error
258  */
259 int read_smbios_string ( struct smbios_structure *structure,
260                          unsigned int index, void *data, size_t len ) {
261         size_t strings_start = ( structure->offset + structure->header.len );
262         size_t strings_end = ( strings_start + structure->strings_len );
263         size_t offset;
264         size_t string_len;
265
266         assert ( smbios.address != UNULL );
267
268         /* String numbers start at 1 (0 is used to indicate "no string") */
269         if ( ! index )
270                 return -ENOENT;
271
272         for ( offset = strings_start ; offset < strings_end ;
273               offset += ( string_len + 1 ) ) {
274                 /* Get string length.  This is known safe, since the
275                  * smbios_strings struct is constructed so as to
276                  * always end on a string boundary.
277                  */
278                 string_len = strlen_user ( smbios.address,
279                                            ( structure->offset + offset ) );
280                 if ( --index == 0 ) {
281                         /* Copy string, truncating as necessary. */
282                         if ( len > string_len )
283                                 len = string_len;
284                         copy_from_user ( data, smbios.address,
285                                          ( structure->offset + offset ), len );
286                         return string_len;
287                 }
288         }
289
290         DBG ( "SMBIOS string index %d not found\n", index );
291         return -ENOENT;
292 }