Merge with /home/shaggy/git/linus-clean/
[linux-2.6] / arch / i386 / kernel / dmi_scan.c
1 #include <linux/types.h>
2 #include <linux/string.h>
3 #include <linux/init.h>
4 #include <linux/module.h>
5 #include <linux/dmi.h>
6 #include <linux/bootmem.h>
7
8
9 struct dmi_header {
10         u8 type;
11         u8 length;
12         u16 handle;
13 };
14
15 #undef DMI_DEBUG
16
17 #ifdef DMI_DEBUG
18 #define dmi_printk(x) printk x
19 #else
20 #define dmi_printk(x)
21 #endif
22
23 static char * __init dmi_string(struct dmi_header *dm, u8 s)
24 {
25         u8 *bp = ((u8 *) dm) + dm->length;
26
27         if (!s)
28                 return "";
29         s--;
30         while (s > 0 && *bp) {
31                 bp += strlen(bp) + 1;
32                 s--;
33         }
34         return bp;
35 }
36
37 /*
38  *      We have to be cautious here. We have seen BIOSes with DMI pointers
39  *      pointing to completely the wrong place for example
40  */
41 static int __init dmi_table(u32 base, int len, int num,
42                             void (*decode)(struct dmi_header *))
43 {
44         u8 *buf, *data;
45         int i = 0;
46                 
47         buf = bt_ioremap(base, len);
48         if (buf == NULL)
49                 return -1;
50
51         data = buf;
52
53         /*
54          *      Stop when we see all the items the table claimed to have
55          *      OR we run off the end of the table (also happens)
56          */
57         while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
58                 struct dmi_header *dm = (struct dmi_header *)data;
59                 /*
60                  *  We want to know the total length (formated area and strings)
61                  *  before decoding to make sure we won't run off the table in
62                  *  dmi_decode or dmi_string
63                  */
64                 data += dm->length;
65                 while ((data - buf < len - 1) && (data[0] || data[1]))
66                         data++;
67                 if (data - buf < len - 1)
68                         decode(dm);
69                 data += 2;
70                 i++;
71         }
72         bt_iounmap(buf, len);
73         return 0;
74 }
75
76 static int __init dmi_checksum(u8 *buf)
77 {
78         u8 sum = 0;
79         int a;
80         
81         for (a = 0; a < 15; a++)
82                 sum += buf[a];
83
84         return sum == 0;
85 }
86
87 static int __init dmi_iterate(void (*decode)(struct dmi_header *))
88 {
89         u8 buf[15];
90         char __iomem *p, *q;
91
92         /*
93          * no iounmap() for that ioremap(); it would be a no-op, but it's
94          * so early in setup that sucker gets confused into doing what
95          * it shouldn't if we actually call it.
96          */
97         p = ioremap(0xF0000, 0x10000);
98         if (p == NULL)
99                 return -1;
100
101         for (q = p; q < p + 0x10000; q += 16) {
102                 memcpy_fromio(buf, q, 15);
103                 if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
104                         u16 num = (buf[13] << 8) | buf[12];
105                         u16 len = (buf[7] << 8) | buf[6];
106                         u32 base = (buf[11] << 24) | (buf[10] << 16) |
107                                    (buf[9] << 8) | buf[8];
108
109                         /*
110                          * DMI version 0.0 means that the real version is taken from
111                          * the SMBIOS version, which we don't know at this point.
112                          */
113                         if (buf[14] != 0)
114                                 printk(KERN_INFO "DMI %d.%d present.\n",
115                                         buf[14] >> 4, buf[14] & 0xF);
116                         else
117                                 printk(KERN_INFO "DMI present.\n");
118
119                         dmi_printk((KERN_INFO "%d structures occupying %d bytes.\n",
120                                 num, len));
121                         dmi_printk((KERN_INFO "DMI table at 0x%08X.\n", base));
122
123                         if (dmi_table(base,len, num, decode) == 0)
124                                 return 0;
125                 }
126         }
127         return -1;
128 }
129
130 static char *dmi_ident[DMI_STRING_MAX];
131
132 /*
133  *      Save a DMI string
134  */
135 static void __init dmi_save_ident(struct dmi_header *dm, int slot, int string)
136 {
137         char *d = (char*)dm;
138         char *p = dmi_string(dm, d[string]);
139
140         if (p == NULL || *p == 0)
141                 return;
142         if (dmi_ident[slot])
143                 return;
144
145         dmi_ident[slot] = alloc_bootmem(strlen(p) + 1);
146         if(dmi_ident[slot])
147                 strcpy(dmi_ident[slot], p);
148         else
149                 printk(KERN_ERR "dmi_save_ident: out of memory.\n");
150 }
151
152 /*
153  *      Process a DMI table entry. Right now all we care about are the BIOS
154  *      and machine entries. For 2.5 we should pull the smbus controller info
155  *      out of here.
156  */
157 static void __init dmi_decode(struct dmi_header *dm)
158 {
159         u8 *data __attribute__((__unused__)) = (u8 *)dm;
160         
161         switch(dm->type) {
162         case  0:
163                 dmi_printk(("BIOS Vendor: %s\n", dmi_string(dm, data[4])));
164                 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
165                 dmi_printk(("BIOS Version: %s\n", dmi_string(dm, data[5])));
166                 dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
167                 dmi_printk(("BIOS Release: %s\n", dmi_string(dm, data[8])));
168                 dmi_save_ident(dm, DMI_BIOS_DATE, 8);
169                 break;
170         case 1:
171                 dmi_printk(("System Vendor: %s\n", dmi_string(dm, data[4])));
172                 dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
173                 dmi_printk(("Product Name: %s\n", dmi_string(dm, data[5])));
174                 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
175                 dmi_printk(("Version: %s\n", dmi_string(dm, data[6])));
176                 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
177                 dmi_printk(("Serial Number: %s\n", dmi_string(dm, data[7])));
178                 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
179                 break;
180         case 2:
181                 dmi_printk(("Board Vendor: %s\n", dmi_string(dm, data[4])));
182                 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
183                 dmi_printk(("Board Name: %s\n", dmi_string(dm, data[5])));
184                 dmi_save_ident(dm, DMI_BOARD_NAME, 5);
185                 dmi_printk(("Board Version: %s\n", dmi_string(dm, data[6])));
186                 dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
187                 break;
188         }
189 }
190
191 void __init dmi_scan_machine(void)
192 {
193         if (dmi_iterate(dmi_decode))
194                 printk(KERN_INFO "DMI not present.\n");
195 }
196
197
198 /**
199  *      dmi_check_system - check system DMI data
200  *      @list: array of dmi_system_id structures to match against
201  *
202  *      Walk the blacklist table running matching functions until someone
203  *      returns non zero or we hit the end. Callback function is called for
204  *      each successfull match. Returns the number of matches.
205  */
206 int dmi_check_system(struct dmi_system_id *list)
207 {
208         int i, count = 0;
209         struct dmi_system_id *d = list;
210
211         while (d->ident) {
212                 for (i = 0; i < ARRAY_SIZE(d->matches); i++) {
213                         int s = d->matches[i].slot;
214                         if (s == DMI_NONE)
215                                 continue;
216                         if (dmi_ident[s] && strstr(dmi_ident[s], d->matches[i].substr))
217                                 continue;
218                         /* No match */
219                         goto fail;
220                 }
221                 if (d->callback && d->callback(d))
222                         break;
223                 count++;
224 fail:           d++;
225         }
226
227         return count;
228 }
229 EXPORT_SYMBOL(dmi_check_system);
230
231 /**
232  *      dmi_get_system_info - return DMI data value
233  *      @field: data index (see enum dmi_filed)
234  *
235  *      Returns one DMI data value, can be used to perform
236  *      complex DMI data checks.
237  */
238 char *dmi_get_system_info(int field)
239 {
240         return dmi_ident[field];
241 }
242 EXPORT_SYMBOL(dmi_get_system_info);