util/flashrom/cbtable.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2002 Steven James <pyro@linuxlabs.com>
   5  * Copyright (C) 2002 Linux Networx
   6  * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
   7  * Copyright (C) 2006-2007 coresystems GmbH
   8  * (Written by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH)
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; version 2 of the License.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdint.h>
  26 #include <stdlib.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <sys/types.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <sys/mman.h>
  33 #include "flash.h"
  34 #include "coreboot_tables.h"
  35
  36 char *lb_part = NULL, *lb_vendor = NULL;
  37
  38 static unsigned long compute_checksum(void *addr, unsigned long length)
  39 {
  40         uint8_t *ptr;
  41         volatile union {
  42                 uint8_t byte[2];
  43                 uint16_t word;
  44         } value;
  45         unsigned long sum;
  46         unsigned long i;
  47
  48         /* In the most straight forward way possible,
  49          * compute an ip style checksum.
  50          */
  51         sum = 0;
  52         ptr = addr;
  53         for (i = 0; i < length; i++) {
  54                 unsigned long value;
  55                 value = ptr[i];
  56                 if (i & 1) {
  57                         value <<= 8;
  58                 }
  59                 /* Add the new value */
  60                 sum += value;
  61                 /* Wrap around the carry */
  62                 if (sum > 0xFFFF) {
  63                         sum = (sum + (sum >> 16)) & 0xFFFF;
  64                 }
  65         }
  66         value.byte[0] = sum & 0xff;
  67         value.byte[1] = (sum >> 8) & 0xff;
  68
  69         return (~value.word) & 0xFFFF;
  70 }
  71
  72 #define for_each_lbrec(head, rec) \
  73         for(rec = (struct lb_record *)(((char *)head) + sizeof(*head)); \
  74                 (((char *)rec) < (((char *)head) + sizeof(*head) + head->table_bytes))  && \
  75                 (rec->size >= 1) && \
  76                 ((((char *)rec) + rec->size) <= (((char *)head) + sizeof(*head) + head->table_bytes)); \
  77                 rec = (struct lb_record *)(((char *)rec) + rec->size))
  78
  79 static int count_lb_records(struct lb_header *head)
  80 {
  81         struct lb_record *rec;
  82         int count;
  83
  84         count = 0;
  85         for_each_lbrec(head, rec) {
  86                 count++;
  87         }
  88
  89         return count;
  90 }
  91
  92 static struct lb_header *find_lb_table(void *base, unsigned long start,
  93                                        unsigned long end)
  94 {
  95         unsigned long addr;
  96
  97         /* For now be stupid.... */
  98         for (addr = start; addr < end; addr += 16) {
  99                 struct lb_header *head =
 100                     (struct lb_header *)(((char *)base) + addr);
 101                 struct lb_record *recs =
 102                     (struct lb_record *)(((char *)base) + addr + sizeof(*head));
 103                 if (memcmp(head->signature, "LBIO", 4) != 0)
 104                         continue;
 105                 printf_debug("Found canidate at: %08lx-%08lx\n",
 106                              addr, addr + head->table_bytes);
 107                 if (head->header_bytes != sizeof(*head)) {
 108                         fprintf(stderr, "Header bytes of %d are incorrect.\n",
 109                                 head->header_bytes);
 110                         continue;
 111                 }
 112                 if (count_lb_records(head) != head->table_entries) {
 113                         fprintf(stderr, "Bad record count: %d.\n",
 114                                 head->table_entries);
 115                         continue;
 116                 }
 117                 if (compute_checksum((uint8_t *) head, sizeof(*head)) != 0) {
 118                         fprintf(stderr, "Bad header checksum.\n");
 119                         continue;
 120                 }
 121                 if (compute_checksum(recs, head->table_bytes)
 122                     != head->table_checksum) {
 123                         fprintf(stderr, "Bad table checksum: %04x.\n",
 124                                 head->table_checksum);
 125                         continue;
 126                 }
 127                 fprintf(stdout, "Found coreboot table at 0x%08lx.\n", addr);
 128                 return head;
 129
 130         };
 131
 132         return 0;
 133 }
 134
 135 static void find_mainboard(struct lb_record *ptr, unsigned long addr)
 136 {
 137         struct lb_mainboard *rec;
 138         int max_size;
 139         char vendor[256], part[256];
 140
 141         rec = (struct lb_mainboard *)ptr;
 142         max_size = rec->size - sizeof(*rec);
 143         printf("Vendor ID: %.*s, part ID: %.*s\n",
 144                max_size - rec->vendor_idx,
 145                rec->strings + rec->vendor_idx,
 146                max_size - rec->part_number_idx,
 147                rec->strings + rec->part_number_idx);
 148         snprintf(vendor, 255, "%.*s", max_size - rec->vendor_idx,
 149                  rec->strings + rec->vendor_idx);
 150         snprintf(part, 255, "%.*s", max_size - rec->part_number_idx,
 151                  rec->strings + rec->part_number_idx);
 152
 153         if (lb_part) {
 154                 printf("Overwritten by command line, vendor ID: %s, part ID: %s.\n", lb_vendor, lb_part);
 155         } else {
 156                 lb_part = strdup(part);
 157                 lb_vendor = strdup(vendor);
 158         }
 159 }
 160
 161 static struct lb_record *next_record(struct lb_record *rec)
 162 {
 163         return (struct lb_record *)(((char *)rec) + rec->size);
 164 }
 165
 166 static void search_lb_records(struct lb_record *rec, struct lb_record *last,
 167                               unsigned long addr)
 168 {
 169         struct lb_record *next;
 170         int count;
 171         count = 0;
 172
 173         for (next = next_record(rec); (rec < last) && (next <= last);
 174              rec = next, addr += rec->size) {
 175                 next = next_record(rec);
 176                 count++;
 177                 if (rec->tag == LB_TAG_MAINBOARD) {
 178                         find_mainboard(rec, addr);
 179                         break;
 180                 }
 181         }
 182 }
 183
 184 int coreboot_init(void)
 185 {
 186         uint8_t *low_1MB;
 187         unsigned long addr;
 188         struct lb_header *lb_table;
 189         struct lb_record *rec, *last;
 190
 191         low_1MB = physmap("low megabyte", 0x0, 1024*1024);
 192         lb_table = find_lb_table(low_1MB, 0x00000, 0x1000);
 193         if (!lb_table)
 194                 lb_table = find_lb_table(low_1MB, 0xf0000, 1024*1024);
 195         if (!lb_table) {
 196                 printf("No coreboot table found.\n");
 197                 return -1;
 198         }
 199
 200         addr = ((char *)lb_table) - ((char *)low_1MB);
 201         printf_debug("coreboot table found at %p.\n", lb_table);
 202         rec = (struct lb_record *)(((char *)lb_table) + lb_table->header_bytes);
 203         last = (struct lb_record *)(((char *)rec) + lb_table->table_bytes);
 204         printf_debug("coreboot header(%d) checksum: %04x table(%d) checksum: %04x entries: %d\n",
 205              lb_table->header_bytes, lb_table->header_checksum,
 206              lb_table->table_bytes, lb_table->table_checksum,
 207              lb_table->table_entries);
 208         search_lb_records(rec, last, addr + lb_table->header_bytes);
 209
 210         return 0;
 211 }