util/vgabios/testbios.c

   1 /* This file is part of the coreboot project. */
   2 /*
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; version 2 of the License.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <sys/io.h>
  17 #include <sys/mman.h>
  18 #include <fcntl.h>
  19 #include <getopt.h>
  20 #include <string.h>
  21 #include <stdarg.h>
  22 #include <stdtypes.h>
  23 #define die(x) { perror(x); exit(1); }
  24 #define warn(x) { perror(x);  }
  25
  26 #include <x86emu/x86emu.h>
  27 #include <console/console.h>
  28 #include <arch/byteorder.h>
  29 #include "device.h"
  30
  31 #include "testbios.h"
  32 #include "pci-userspace.h"
  33 int X86EMU_set_debug(int debug);
  34
  35 biosemu_device_t bios_device;
  36
  37 extern int teststart, testend;
  38
  39 #define BIOSMEM_SIZE (1024 * 1024)
  40 unsigned char biosmem[BIOSMEM_SIZE];
  41
  42 int verbose = 0;
  43
  44 static unsigned char *mapitin(char *file, off_t where, size_t size)
  45 {
  46         void *z;
  47
  48         int fd = open(file, O_RDWR, 0);
  49
  50         if (fd < 0)
  51                 die(file);
  52         z = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, where);
  53         if (z == (void *) -1)
  54                 die("mmap");
  55         close(fd);
  56
  57         return z;
  58 }
  59
  60 static unsigned short get_device(char *arg_val)
  61 {
  62         unsigned short devfn=0;
  63         long bus=0,dev=0,fn=0,need_pack=0;
  64         char *tok;
  65
  66         tok = strsep(&arg_val,":");
  67         if (arg_val != NULL) {
  68                 bus = strtol(tok,0,16);
  69                 need_pack = 1;
  70         }
  71         else {
  72                 arg_val = tok;
  73         }
  74
  75         tok = strsep(&arg_val,".");
  76         if (arg_val != NULL) {
  77                 dev = strtol(tok,0,16);
  78                 fn  = strtol(arg_val,0,16);
  79                 need_pack = 1;
  80         }
  81         else {
  82                 if (need_pack ==1 && (strlen(tok))) {
  83                         dev = strtol(tok,0,16);
  84                 }
  85         }
  86
  87         if ( need_pack == 1) {
  88                 devfn = bus<<8 | (dev<<3) | fn;
  89         }
  90         else {
  91                 devfn = strtol(tok, 0, 0);
  92         }
  93
  94         return devfn;
  95 }
  96
  97 int printk(int msg_level, const char *fmt, ...)
  98 {
  99         va_list args;
 100         int i;
 101
 102         putchar('<');
 103         putchar('0' + msg_level);
 104         putchar('>');
 105         putchar(' ');
 106         va_start(args, fmt);
 107         i = vprintf(fmt, args);
 108         va_end(args);
 109
 110         return i;
 111 }
 112
 113 static void usage(char *name)
 114 {
 115         printf
 116             ("Usage: %s [-c codesegment] [-s size] [-b base] [-i ip] [-t] "
 117              "<filename> ...\n", name);
 118 }
 119
 120 /* main entry into YABEL biosemu, arguments are:
 121  * *biosmem = pointer to virtual memory
 122  * biosmem_size = size of the virtual memory
 123  * *dev = pointer to the device to be initialised
 124  * rom_addr = address of the OptionROM to be executed, if this is = 0, YABEL
 125  * will look for an ExpansionROM BAR and use the code from there.
 126  */
 127 u32
 128 biosemu(u8 *biosmem, u32 biosmem_size, struct device * dev, unsigned long
 129                 rom_addr);
 130
 131
 132 int main(int argc, char **argv)
 133 {
 134         int ret;
 135         char *absegname = NULL;
 136         void *abseg = NULL;
 137         int c, trace = 0;
 138         unsigned char *cp;
 139         char *filename;
 140         ssize_t size = 0;
 141         int base = 0;
 142         int have_size = 0, have_base = 0, have_ip = 0, have_cs = 0;
 143         int have_devfn = 0;
 144         int parse_rom = 0;
 145         //char *fsegname = 0;
 146         //unsigned char *fsegptr;
 147         unsigned short initialip = 0, initialcs = 0, devfn = 0;
 148         //X86EMU_intrFuncs intFuncs[256];
 149         int debugflag = 0;
 150         struct device *dev;
 151
 152         //const char *optstring = "vh?b:i:c:s:tpd:";
 153         const char *optstring = "vh?b:i:c:s:tpd:";
 154         while (1) {
 155                 int option_index = 0;
 156                 static struct option long_options[] = {
 157                         {"verbose", 0, 0, 'v'},
 158                         {"help", 0, 0, 'h'},
 159                         {"trace", 0, 0, 't'},
 160                         {"base", 1, 0, 'b'},
 161                         //{"fseg", 1, 0, 'f'},
 162                         {"instructionpointer", 1, 0, 'i'},
 163                         {"codesegment", 1, 0, 'c'},
 164                         {"absegment", 1, 0, 'a'},
 165                         {"size", 1, 0, 's'},
 166                         {"parserom", 0, 0, 'p'},
 167                         {"device", 1, 0, 'd'},
 168                         {"debug", 1, 0, 'D'},
 169                         {0, 0, 0, 0}
 170                 };
 171                 c = getopt_long(argc, argv, optstring, long_options, &option_index);
 172                 if (c == -1)
 173                         break;
 174                 switch (c) {
 175                 case 'v':
 176                         verbose = 1;
 177                         break;
 178                 case 'h':
 179                 case '?':
 180                         usage(argv[0]);
 181                         return 0;
 182                 case 't':
 183                         trace = 1;
 184                         break;
 185                 //case 'b':
 186                 //      base = strtol(optarg, 0, 0);
 187                 //      have_base = 1;
 188                 //      break;
 189                 case 'i':
 190                         initialip = strtol(optarg, 0, 0);
 191                         have_ip = 1;
 192                         break;
 193                 case 'c':
 194                         initialcs = strtol(optarg, 0, 0);
 195                         have_cs = 1;
 196                         break;
 197                 case 's':
 198                         size = strtol(optarg, 0, 0);
 199                         have_size = 1;
 200                         break;
 201                 case 'p':
 202                         parse_rom = 1;
 203                         break;
 204         //      case 'f':
 205         //              fsegname = optarg;
 206         //              break;
 207                 case 'a':
 208                         absegname = optarg;
 209                         break;
 210                 case 'd':
 211                         devfn = get_device(optarg);
 212                         have_devfn = 1;
 213                         break;
 214                 case 'D':
 215                         debugflag = strtol(optarg, 0, 0);
 216                         break;
 217                 default:
 218                         printf("Unknown option\n");
 219                         usage(argv[0]);
 220                         return 1;
 221                 }
 222         }
 223
 224         if (optind >= argc) {
 225                 printf("Filename missing.\n");
 226                 usage(argv[0]);
 227                 return 1;
 228         }
 229
 230         while (optind < argc) {
 231                 printf("running file %s\n", argv[optind]);
 232                 filename = argv[optind];
 233                 optind++;
 234                 /* normally we would do continue, but for
 235                  * now only one filename is supported.
 236                  */
 237                 /* continue; */
 238                 break;
 239         }
 240
 241         if (!have_size) {
 242                 printf("No size specified. defaulting to 32k\n");
 243                 size = 32 * 1024;
 244         }
 245         if (!have_base) {
 246                 printf("No base specified. defaulting to 0xc0000\n");
 247                 base = 0xc0000;
 248         }
 249         //if (!have_cs) {
 250         //      printf("No initial code segment specified. defaulting to 0xc000\n");
 251         //      initialcs = 0xc000;
 252         //}
 253         if (!have_ip) {
 254                 printf
 255                     ("No initial instruction pointer specified. defaulting to 0x0003\n");
 256                 initialip = 0x0003;
 257         }
 258
 259         if (parse_rom)
 260                 printf("Parsing rom images not implemented.\n");
 261
 262         //printf("Point 1 int%x vector at %x\n", 0x42, getIntVect(0x42));
 263 #if 0
 264         if (initialip == 0x0003) {
 265                 if ((devfn == 0) || (have_devfn == 0)) {
 266                         printf("WARNING! It appears you are trying to run an option ROM.\n");
 267                         printf("  (initial ip = 0x0003)\n");
 268                         if (have_devfn) {
 269                                 printf("  However, the device you have specified is 0x00\n");
 270                                 printf("  It is very unlikely that your device is at this address\n");
 271                                 printf("  Please check your -d option\n");
 272                         }
 273                         else {
 274                                 printf("  Please specify a device with -d\n");
 275                                 printf("  The default is not likely to work\n");
 276                         }
 277                 }
 278         }
 279 #endif
 280
 281         if (absegname) {
 282                 abseg = mapitin(absegname, (off_t) 0xa0000, 0x20000);
 283                 if (!abseg)
 284                         die(absegname);
 285         }
 286
 287         ioperm(0, 0x400, 1);
 288
 289         if (iopl(3) < 0) {
 290                 warn("iopl failed, continuing anyway");
 291         }
 292
 293         /* Emergency sync ;-) */
 294         sync();
 295         sync();
 296
 297         /* Setting up interrupt environment.
 298          * basically this means initializing PCI and
 299          * intXX handlers.
 300          */
 301         pci_initialize();
 302
 303 #if 0
 304         for (i = 0; i < 256; i++)
 305                 intFuncs[i] = do_int;
 306         X86EMU_setupIntrFuncs(intFuncs);
 307 #endif
 308         cp = mapitin(filename, (off_t) 0, size);
 309
 310         if (devfn) {
 311                 printf("Loading ax with BusDevFn = %x\n",devfn);
 312         }
 313
 314 #if 0
 315         current->ax = devfn   ? devfn : 0xff;
 316         current->dx = 0x80;
 317         //      current->ip = 0;
 318         for (i = 0; i < size; i++)
 319                 wrb(base + i, cp[i]);
 320
 321         if (fsegname) {
 322                 fsegptr = mapitin(fsegname, (off_t) 0, 0x10000);
 323                 for (i = 0; i < 0x10000; i++)
 324                         wrb(0xf0000 + i, fsegptr[i]);
 325         } else {
 326                 const char *date = "01/01/99";
 327                 for (i = i; date[i]; i++)
 328                         wrb(0xffff5 + i, date[i]);
 329                 wrb(0xffff7, '/');
 330                 wrb(0xffffa, '/');
 331         }
 332         /* cpu setup */
 333         X86_AX = devfn ? devfn : 0xff;
 334         X86_DX = 0x80;
 335         X86_EIP = initialip;
 336         X86_CS = initialcs;
 337
 338         /* Initialize stack and data segment */
 339         X86_SS = 0x0030;
 340         X86_DS = 0x0040;
 341         X86_SP = 0xfffe;
 342         /* We need a sane way to return from bios
 343          * execution. A hlt instruction and a pointer
 344          * to it, both kept on the stack, will do.
 345          */
 346         pushw(0xf4f4);          /* hlt; hlt */
 347         pushw(X86_SS);
 348         pushw(X86_SP + 2);
 349
 350         X86_ES = 0x0000;
 351 #endif
 352
 353         if (trace) {
 354                 printf("Switching to single step mode.\n");
 355                 //X86EMU_trace_on();
 356         }
 357         if (debugflag) {
 358                 printf("Enable Debug = %x.\n",debugflag);
 359                 //X86EMU_set_debug(debugflag);
 360         }
 361 #if 0
 362         X86EMU_exec();
 363 #endif
 364
 365         ret = biosemu(biosmem, BIOSMEM_SIZE, dev, base);
 366
 367 #if 0
 368         current = &p;
 369         X86EMU_setMemBase(biosmem, sizeof(biosmem));
 370         M.abseg = (unsigned long)abseg;
 371         X86EMU_setupPioFuncs(&myfuncs);
 372 #endif
 373
 374         /* Cleaning up */
 375         pci_exit();
 376
 377         return 0;
 378 }