Return to paravirt.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src

Annotation of qemu/roms/seabios/src/paravirt.h, revision 1.1.1.4

1.1       root        1: #ifndef __PV_H
                      2: #define __PV_H
                      3: 
1.1.1.4 ! root        4: #include "config.h" // CONFIG_COREBOOT
1.1       root        5: #include "util.h"
                      6: 
                      7: /* This CPUID returns the signature 'KVMKVMKVM' in ebx, ecx, and edx.  It
                      8:  * should be used to determine that a VM is running under KVM.
                      9:  */
                     10: #define KVM_CPUID_SIGNATURE     0x40000000
                     11: 
                     12: static inline int kvm_para_available(void)
                     13: {
                     14:     unsigned int eax, ebx, ecx, edx;
                     15:     char signature[13];
                     16: 
                     17:     cpuid(KVM_CPUID_SIGNATURE, &eax, &ebx, &ecx, &edx);
                     18:     memcpy(signature + 0, &ebx, 4);
                     19:     memcpy(signature + 4, &ecx, 4);
                     20:     memcpy(signature + 8, &edx, 4);
                     21:     signature[12] = 0;
                     22: 
                     23:     if (strcmp(signature, "KVMKVMKVM") == 0)
                     24:         return 1;
                     25: 
                     26:     return 0;
                     27: }
                     28: 
                     29: #define QEMU_CFG_SIGNATURE             0x00
                     30: #define QEMU_CFG_ID                    0x01
                     31: #define QEMU_CFG_UUID                  0x02
                     32: #define QEMU_CFG_NUMA                  0x0d
                     33: #define QEMU_CFG_BOOT_MENU             0x0e
                     34: #define QEMU_CFG_MAX_CPUS              0x0f
                     35: #define QEMU_CFG_FILE_DIR               0x19
                     36: #define QEMU_CFG_ARCH_LOCAL            0x8000
                     37: #define QEMU_CFG_ACPI_TABLES           (QEMU_CFG_ARCH_LOCAL + 0)
                     38: #define QEMU_CFG_SMBIOS_ENTRIES                (QEMU_CFG_ARCH_LOCAL + 1)
                     39: #define QEMU_CFG_IRQ0_OVERRIDE         (QEMU_CFG_ARCH_LOCAL + 2)
1.1.1.2   root       40: #define QEMU_CFG_E820_TABLE            (QEMU_CFG_ARCH_LOCAL + 3)
1.1       root       41: 
                     42: extern int qemu_cfg_present;
                     43: 
                     44: void qemu_cfg_port_probe(void);
                     45: int qemu_cfg_show_boot_menu(void);
                     46: void qemu_cfg_get_uuid(u8 *uuid);
                     47: int qemu_cfg_irq0_override(void);
                     48: u16 qemu_cfg_acpi_additional_tables(void);
                     49: u16 qemu_cfg_next_acpi_table_len(void);
                     50: void *qemu_cfg_next_acpi_table_load(void *addr, u16 len);
                     51: u16 qemu_cfg_smbios_entries(void);
                     52: size_t qemu_cfg_smbios_load_field(int type, size_t offset, void *addr);
                     53: int qemu_cfg_smbios_load_external(int type, char **p, unsigned *nr_structs,
                     54:                                   unsigned *max_struct_size, char *end);
                     55: int qemu_cfg_get_numa_nodes(void);
                     56: void qemu_cfg_get_numa_data(u64 *data, int n);
                     57: u16 qemu_cfg_get_max_cpus(void);
                     58: 
                     59: typedef struct QemuCfgFile {
                     60:     u32  size;        /* file size */
                     61:     u16  select;      /* write this to 0x510 to read it */
                     62:     u16  reserved;
                     63:     char name[56];
                     64: } QemuCfgFile;
                     65: 
1.1.1.2   root       66: struct e820_reservation {
                     67:     u64 address;
                     68:     u64 length;
                     69:     u32 type;
                     70: };
                     71: 
                     72: u32 qemu_cfg_next_prefix_file(const char *prefix, u32 prevselect);
                     73: u32 qemu_cfg_find_file(const char *name);
                     74: int qemu_cfg_size_file(u32 select);
1.1.1.3   root       75: const char* qemu_cfg_name_file(u32 select);
1.1.1.2   root       76: int qemu_cfg_read_file(u32 select, void *dst, u32 maxlen);
                     77: 
                     78: // Wrappers that select cbfs or qemu_cfg file interface.
                     79: static inline u32 romfile_findprefix(const char *prefix, u32 previd) {
                     80:     if (CONFIG_COREBOOT)
                     81:         return (u32)cbfs_findprefix(prefix, (void*)previd);
                     82:     return qemu_cfg_next_prefix_file(prefix, previd);
                     83: }
                     84: static inline u32 romfile_find(const char *name) {
                     85:     if (CONFIG_COREBOOT)
                     86:         return (u32)cbfs_finddatafile(name);
                     87:     return qemu_cfg_find_file(name);
                     88: }
                     89: static inline u32 romfile_size(u32 fileid) {
                     90:     if (CONFIG_COREBOOT)
                     91:         return cbfs_datasize((void*)fileid);
                     92:     return qemu_cfg_size_file(fileid);
                     93: }
                     94: static inline int romfile_copy(u32 fileid, void *dst, u32 maxlen) {
                     95:     if (CONFIG_COREBOOT)
                     96:         return cbfs_copyfile((void*)fileid, dst, maxlen);
                     97:     return qemu_cfg_read_file(fileid, dst, maxlen);
                     98: }
1.1.1.3   root       99: static inline const char* romfile_name(u32 fileid) {
                    100:     if (CONFIG_COREBOOT)
                    101:         return cbfs_filename((void*)fileid);
                    102:     return qemu_cfg_name_file(fileid);
                    103: }
                    104: void *romfile_loadfile(const char *name, int *psize);
1.1.1.4 ! root      105: u64 romfile_loadint(const char *name, u64 defval);
1.1.1.2   root      106: 
                    107: u32 qemu_cfg_e820_entries(void);
                    108: void* qemu_cfg_e820_load_next(void *addr);
1.1       root      109: 
                    110: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.