[efi] Use EFI-native mechanism for accessing SMBIOS table
[people/pravin/gpxe.git] / src / interface / smbios / 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 <gpxe/smbios.h>
25
26 /** @file
27  *
28  * System Management BIOS
29  *
30  */
31
32 /** SMBIOS entry point descriptor */
33 static struct smbios smbios = {
34         .address = UNULL,
35 };
36
37 /**
38  * Find SMBIOS strings terminator
39  *
40  * @v offset            Offset to start of strings
41  * @ret offset          Offset to strings terminator, or 0 if not found
42  */
43 static size_t find_strings_terminator ( size_t offset ) {
44         size_t max_offset = ( smbios.len - 2 );
45         uint16_t nulnul;
46
47         for ( ; offset <= max_offset ; offset++ ) {
48                 copy_from_user ( &nulnul, smbios.address, offset, 2 );
49                 if ( nulnul == 0 )
50                         return ( offset + 1 );
51         }
52         return 0;
53 }
54
55 /**
56  * Find specific structure type within SMBIOS
57  *
58  * @v type              Structure type to search for
59  * @v structure         SMBIOS structure descriptor to fill in
60  * @ret rc              Return status code
61  */
62 int find_smbios_structure ( unsigned int type,
63                             struct smbios_structure *structure ) {
64         unsigned int count = 0;
65         size_t offset = 0;
66         size_t strings_offset;
67         size_t terminator_offset;
68         int rc;
69
70         /* Find SMBIOS */
71         if ( ( smbios.address == UNULL ) &&
72              ( ( rc = find_smbios ( &smbios ) ) != 0 ) )
73                 return rc;
74         assert ( smbios.address != UNULL );
75
76         /* Scan through list of structures */
77         while ( ( ( offset + sizeof ( structure->header ) ) < smbios.len )
78                 && ( count < smbios.count ) ) {
79
80                 /* Read next SMBIOS structure header */
81                 copy_from_user ( &structure->header, smbios.address, offset,
82                                  sizeof ( structure->header ) );
83
84                 /* Determine start and extent of strings block */
85                 strings_offset = ( offset + structure->header.len );
86                 if ( strings_offset > smbios.len ) {
87                         DBG ( "SMBIOS structure at offset %zx with length "
88                               "%x extends beyond SMBIOS\n", offset,
89                               structure->header.len );
90                         return -ENOENT;
91                 }
92                 terminator_offset = find_strings_terminator ( strings_offset );
93                 if ( ! terminator_offset ) {
94                         DBG ( "SMBIOS structure at offset %zx has "
95                               "unterminated strings section\n", offset );
96                         return -ENOENT;
97                 }
98                 structure->strings_len = ( terminator_offset - strings_offset);
99
100                 DBG ( "SMBIOS structure at offset %zx has type %d, length %x, "
101                       "strings length %zx\n", offset, structure->header.type,
102                       structure->header.len, structure->strings_len );
103
104                 /* If this is the structure we want, return */
105                 if ( structure->header.type == type ) {
106                         structure->offset = offset;
107                         return 0;
108                 }
109
110                 /* Move to next SMBIOS structure */
111                 offset = ( terminator_offset + 1 );
112                 count++;
113         }
114
115         DBG ( "SMBIOS structure type %d not found\n", type );
116         return -ENOENT;
117 }
118
119 /**
120  * Copy SMBIOS structure
121  *
122  * @v structure         SMBIOS structure descriptor
123  * @v data              Buffer to hold SMBIOS structure
124  * @v len               Length of buffer
125  * @ret rc              Return status code
126  */
127 int read_smbios_structure ( struct smbios_structure *structure,
128                             void *data, size_t len ) {
129
130         assert ( smbios.address != UNULL );
131
132         if ( len > structure->header.len )
133                 len = structure->header.len;
134         copy_from_user ( data, smbios.address, structure->offset, len );
135         return 0;
136 }
137
138 /**
139  * Find indexed string within SMBIOS structure
140  *
141  * @v structure         SMBIOS structure descriptor
142  * @v index             String index
143  * @v data              Buffer for string
144  * @v len               Length of string buffer
145  * @ret rc              Length of string, or negative error
146  */
147 int read_smbios_string ( struct smbios_structure *structure,
148                          unsigned int index, void *data, size_t len ) {
149         size_t strings_start = ( structure->offset + structure->header.len );
150         size_t strings_end = ( strings_start + structure->strings_len );
151         size_t offset;
152         size_t string_len;
153
154         assert ( smbios.address != UNULL );
155
156         /* String numbers start at 1 (0 is used to indicate "no string") */
157         if ( ! index )
158                 return -ENOENT;
159
160         for ( offset = strings_start ; offset < strings_end ;
161               offset += ( string_len + 1 ) ) {
162                 /* Get string length.  This is known safe, since the
163                  * smbios_strings struct is constructed so as to
164                  * always end on a string boundary.
165                  */
166                 string_len = strlen_user ( smbios.address, offset );
167                 if ( --index == 0 ) {
168                         /* Copy string, truncating as necessary. */
169                         if ( len > string_len )
170                                 len = string_len;
171                         copy_from_user ( data, smbios.address, offset, len );
172                         return string_len;
173                 }
174         }
175
176         DBG ( "SMBIOS string index %d not found\n", index );
177         return -ENOENT;
178 }