arch_init.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include "sysemu/sysemu.h"
  26 #include "sysemu/arch_init.h"
  27 #include "hw/pci/pci.h"
  28 #include "hw/audio/audio.h"
  29 #include "hw/smbios/smbios.h"
  30 #include "qemu/config-file.h"
  31 #include "qemu/error-report.h"
  32 #include "qmp-commands.h"
  33 #include "hw/acpi/acpi.h"
  34 #include "qemu/help_option.h"
  35
  36 #ifdef TARGET_SPARC
  37 int graphic_width = 1024;
  38 int graphic_height = 768;
  39 int graphic_depth = 8;
  40 #else
  41 int graphic_width = 800;
  42 int graphic_height = 600;
  43 int graphic_depth = 32;
  44 #endif
  45
  46
  47 #if defined(TARGET_ALPHA)
  48 #define QEMU_ARCH QEMU_ARCH_ALPHA
  49 #elif defined(TARGET_ARM)
  50 #define QEMU_ARCH QEMU_ARCH_ARM
  51 #elif defined(TARGET_CRIS)
  52 #define QEMU_ARCH QEMU_ARCH_CRIS
  53 #elif defined(TARGET_I386)
  54 #define QEMU_ARCH QEMU_ARCH_I386
  55 #elif defined(TARGET_M68K)
  56 #define QEMU_ARCH QEMU_ARCH_M68K
  57 #elif defined(TARGET_LM32)
  58 #define QEMU_ARCH QEMU_ARCH_LM32
  59 #elif defined(TARGET_MICROBLAZE)
  60 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE
  61 #elif defined(TARGET_MIPS)
  62 #define QEMU_ARCH QEMU_ARCH_MIPS
  63 #elif defined(TARGET_MOXIE)
  64 #define QEMU_ARCH QEMU_ARCH_MOXIE
  65 #elif defined(TARGET_OPENRISC)
  66 #define QEMU_ARCH QEMU_ARCH_OPENRISC
  67 #elif defined(TARGET_PPC)
  68 #define QEMU_ARCH QEMU_ARCH_PPC
  69 #elif defined(TARGET_S390X)
  70 #define QEMU_ARCH QEMU_ARCH_S390X
  71 #elif defined(TARGET_SH4)
  72 #define QEMU_ARCH QEMU_ARCH_SH4
  73 #elif defined(TARGET_SPARC)
  74 #define QEMU_ARCH QEMU_ARCH_SPARC
  75 #elif defined(TARGET_XTENSA)
  76 #define QEMU_ARCH QEMU_ARCH_XTENSA
  77 #elif defined(TARGET_UNICORE32)
  78 #define QEMU_ARCH QEMU_ARCH_UNICORE32
  79 #elif defined(TARGET_TRICORE)
  80 #define QEMU_ARCH QEMU_ARCH_TRICORE
  81 #endif
  82
  83 const uint32_t arch_type = QEMU_ARCH;
  84
  85 static struct defconfig_file {
  86     const char *filename;
  87     /* Indicates it is an user config file (disabled by -no-user-config) */
  88     bool userconfig;
  89 } default_config_files[] = {
  90     { CONFIG_QEMU_CONFDIR "/qemu.conf",                   true },
  91     { NULL }, /* end of list */
  92 };
  93
  94 int qemu_read_default_config_files(bool userconfig)
  95 {
  96     int ret;
  97     struct defconfig_file *f;
  98
  99     for (f = default_config_files; f->filename; f++) {
 100         if (!userconfig && f->userconfig) {
 101             continue;
 102         }
 103         ret = qemu_read_config_file(f->filename);
 104         if (ret < 0 && ret != -ENOENT) {
 105             return ret;
 106         }
 107     }
 108
 109     return 0;
 110 }
 111
 112 struct soundhw {
 113     const char *name;
 114     const char *descr;
 115     int enabled;
 116     int isa;
 117     union {
 118         int (*init_isa) (ISABus *bus);
 119         int (*init_pci) (PCIBus *bus);
 120     } init;
 121 };
 122
 123 static struct soundhw soundhw[9];
 124 static int soundhw_count;
 125
 126 void isa_register_soundhw(const char *name, const char *descr,
 127                           int (*init_isa)(ISABus *bus))
 128 {
 129     assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
 130     soundhw[soundhw_count].name = name;
 131     soundhw[soundhw_count].descr = descr;
 132     soundhw[soundhw_count].isa = 1;
 133     soundhw[soundhw_count].init.init_isa = init_isa;
 134     soundhw_count++;
 135 }
 136
 137 void pci_register_soundhw(const char *name, const char *descr,
 138                           int (*init_pci)(PCIBus *bus))
 139 {
 140     assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
 141     soundhw[soundhw_count].name = name;
 142     soundhw[soundhw_count].descr = descr;
 143     soundhw[soundhw_count].isa = 0;
 144     soundhw[soundhw_count].init.init_pci = init_pci;
 145     soundhw_count++;
 146 }
 147
 148 void select_soundhw(const char *optarg)
 149 {
 150     struct soundhw *c;
 151
 152     if (is_help_option(optarg)) {
 153     show_valid_cards:
 154
 155         if (soundhw_count) {
 156              printf("Valid sound card names (comma separated):\n");
 157              for (c = soundhw; c->name; ++c) {
 158                  printf ("%-11s %s\n", c->name, c->descr);
 159              }
 160              printf("\n-soundhw all will enable all of the above\n");
 161         } else {
 162              printf("Machine has no user-selectable audio hardware "
 163                     "(it may or may not have always-present audio hardware).\n");
 164         }
 165         exit(!is_help_option(optarg));
 166     }
 167     else {
 168         size_t l;
 169         const char *p;
 170         char *e;
 171         int bad_card = 0;
 172
 173         if (!strcmp(optarg, "all")) {
 174             for (c = soundhw; c->name; ++c) {
 175                 c->enabled = 1;
 176             }
 177             return;
 178         }
 179
 180         p = optarg;
 181         while (*p) {
 182             e = strchr(p, ',');
 183             l = !e ? strlen(p) : (size_t) (e - p);
 184
 185             for (c = soundhw; c->name; ++c) {
 186                 if (!strncmp(c->name, p, l) && !c->name[l]) {
 187                     c->enabled = 1;
 188                     break;
 189                 }
 190             }
 191
 192             if (!c->name) {
 193                 if (l > 80) {
 194                     error_report("Unknown sound card name (too big to show)");
 195                 }
 196                 else {
 197                     error_report("Unknown sound card name `%.*s'",
 198                                  (int) l, p);
 199                 }
 200                 bad_card = 1;
 201             }
 202             p += l + (e != NULL);
 203         }
 204
 205         if (bad_card) {
 206             goto show_valid_cards;
 207         }
 208     }
 209 }
 210
 211 void audio_init(void)
 212 {
 213     struct soundhw *c;
 214     ISABus *isa_bus = (ISABus *) object_resolve_path_type("", TYPE_ISA_BUS, NULL);
 215     PCIBus *pci_bus = (PCIBus *) object_resolve_path_type("", TYPE_PCI_BUS, NULL);
 216
 217     for (c = soundhw; c->name; ++c) {
 218         if (c->enabled) {
 219             if (c->isa) {
 220                 if (!isa_bus) {
 221                     error_report("ISA bus not available for %s", c->name);
 222                     exit(1);
 223                 }
 224                 c->init.init_isa(isa_bus);
 225             } else {
 226                 if (!pci_bus) {
 227                     error_report("PCI bus not available for %s", c->name);
 228                     exit(1);
 229                 }
 230                 c->init.init_pci(pci_bus);
 231             }
 232         }
 233     }
 234 }
 235
 236 int qemu_uuid_parse(const char *str, uint8_t *uuid)
 237 {
 238     int ret;
 239
 240     if (strlen(str) != 36) {
 241         return -1;
 242     }
 243
 244     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
 245                  &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
 246                  &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
 247                  &uuid[15]);
 248
 249     if (ret != 16) {
 250         return -1;
 251     }
 252     return 0;
 253 }
 254
 255 void do_acpitable_option(const QemuOpts *opts)
 256 {
 257 #ifdef TARGET_I386
 258     Error *err = NULL;
 259
 260     acpi_table_add(opts, &err);
 261     if (err) {
 262         error_reportf_err(err, "Wrong acpi table provided: ");
 263         exit(1);
 264     }
 265 #endif
 266 }
 267
 268 void do_smbios_option(QemuOpts *opts)
 269 {
 270 #ifdef TARGET_I386
 271     smbios_entry_add(opts);
 272 #endif
 273 }
 274
 275 void cpudef_init(void)
 276 {
 277 #if defined(cpudef_setup)
 278     cpudef_setup(); /* parse cpu definitions in target config file */
 279 #endif
 280 }
 281
 282 int kvm_available(void)
 283 {
 284 #ifdef CONFIG_KVM
 285     return 1;
 286 #else
 287     return 0;
 288 #endif
 289 }
 290
 291 int xen_available(void)
 292 {
 293 #ifdef CONFIG_XEN
 294     return 1;
 295 #else
 296     return 0;
 297 #endif
 298 }
 299
 300
 301 TargetInfo *qmp_query_target(Error **errp)
 302 {
 303     TargetInfo *info = g_malloc0(sizeof(*info));
 304
 305     info->arch = g_strdup(TARGET_NAME);
 306
 307     return info;
 308 }