dom_fw_common.c

xen虚拟机源代码安装包

	 */
	fadt->pm1_event_length = 4;
	fadt->xpm1a_event_block.space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
	fadt->xpm1a_event_block.bit_width = 8;
	fadt->xpm1a_event_block.address = ACPI_TABLE_MPA(pm1a_event_block);
	fadt->pm1_control_length = 1;
	fadt->xpm1a_control_block.space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
	fadt->xpm1a_control_block.bit_width = 8;
	fadt->xpm1a_control_block.address = ACPI_TABLE_MPA(pm1a_control_block);
	fadt->pm_timer_length = 4;
	fadt->xpm_timer_block.space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
	fadt->xpm_timer_block.bit_width = 8;
	fadt->xpm_timer_block.address = ACPI_TABLE_MPA(pm_timer_block);

	fadt->header.checksum = -acpi_tb_checksum((u8*)fadt,
						  fadt->header.length);

	/* setup RSDP */
	memcpy(rsdp->signature, ACPI_SIG_RSDP, strlen(ACPI_SIG_RSDP));
	memcpy(rsdp->oem_id, "XEN", 3);
	rsdp->revision = 2; /* ACPI 2.0 includes XSDT */
	rsdp->length = sizeof(struct acpi_table_rsdp);
	rsdp->xsdt_physical_address = ACPI_TABLE_MPA(xsdt);

	rsdp->checksum = -acpi_tb_checksum((u8*)rsdp,
					   ACPI_RSDP_CHECKSUM_LENGTH);
	rsdp->extended_checksum = -acpi_tb_checksum((u8*)rsdp, rsdp->length);

	/* setup DSDT with trivial namespace. */ 
	memcpy(dsdt->signature, ACPI_SIG_DSDT, strlen(ACPI_SIG_DSDT));
	dsdt->revision = 1;
	memcpy(dsdt->oem_id, "XEN", 3);
	memcpy(dsdt->oem_table_id, "Xen/ia64", 8);
	memcpy(dsdt->asl_compiler_id, "XEN", 3);
	dsdt->asl_compiler_revision = xen_ia64_version(d);

	/* Trivial namespace, avoids ACPI CA complaints */
	tables->aml[0] = 0x10; /* Scope */
	tables->aml[1] = 0x40; /* length/offset to next object (patched) */
	tables->aml[2] = 0x00;
	memcpy(&tables->aml[3], "_SB_", 4);

	/* The processor object isn't absolutely necessary, revist for SMP */
	aml_len = 7;
	for (i = 0; i < 3; i++) {
		unsigned char *p = tables->aml + aml_len;
		p[0] = 0x5b; /* processor object */
		p[1] = 0x83;
		p[2] = 0x0b; /* next */
		p[3] = 'C';
		p[4] = 'P';
		snprintf ((char *)p + 5, 3, "%02x", i);
		if (i < 16)
			p[5] = 'U';
		p[7] = i;	/* acpi_id */
		p[8] = 0;	/* pblk_addr */
		p[9] = 0;
		p[10] = 0;
		p[11] = 0;
		p[12] = 0;	/* pblk_len */
		aml_len += 13;
	}
	tables->aml[1] = 0x40 + ((aml_len - 1) & 0x0f);
	tables->aml[2] = (aml_len - 1) >> 4;
	dsdt->length = sizeof(struct acpi_table_header) + aml_len;
	dsdt->checksum = -acpi_tb_checksum((u8*)dsdt, dsdt->length);

	/* setup MADT */
	memcpy(madt->header.signature, ACPI_SIG_MADT,
	       sizeof(madt->header.signature));
	madt->header.revision = 2;
	memcpy(madt->header.oem_id, "XEN", 3);
	memcpy(madt->header.oem_table_id, "Xen/ia64", 8);
	memcpy(madt->header.asl_compiler_id, "XEN", 3);
	madt->header.asl_compiler_revision = xen_ia64_version(d);

	/* An LSAPIC entry describes a CPU.  */
	nbr_cpus = 0;
	for (i = 0; i < MAX_VIRT_CPUS; i++) {
		lsapic[i].header.type = ACPI_MADT_LSAPIC;
		lsapic[i].header.length = sizeof(struct acpi_table_lsapic);
		lsapic[i].acpi_id = i;
		lsapic[i].id = i;
		lsapic[i].eid = 0;
		if (xen_ia64_is_vcpu_allocated(d, i)) {
			lsapic[i].flags.enabled = 1;
			nbr_cpus++;
		}
	}
	madt->header.length = sizeof(struct acpi_table_madt) +
	                      nbr_cpus * sizeof(struct acpi_table_lsapic);
	madt->header.checksum = -acpi_tb_checksum((u8*)madt,
						  madt->header.length);
	return;
}

int
efi_mdt_cmp(const void *a, const void *b)
{
	const efi_memory_desc_t *x = a, *y = b;

	if (x->phys_addr > y->phys_addr)
		return 1;
	if (x->phys_addr < y->phys_addr)
		return -1;

	/* num_pages == 0 is allowed. */
	if (x->num_pages > y->num_pages)
		return 1;
	if (x->num_pages < y->num_pages)
		return -1;

	return 0;
}

int
dom_fw_init(domain_t *d,
	    uint64_t brkimm,
            struct xen_ia64_boot_param *bp,
            struct fw_tables *tables,
            unsigned long hypercalls_imva,
            unsigned long maxmem)
{
	unsigned long pfn;
	unsigned char checksum;
	char *cp;
	int num_mds, i;
	int fpswa_supported = 0;

	/* Caller must zero-clear fw_tables */

	/* EFI systab.  */
	tables->efi_systab.hdr.signature = EFI_SYSTEM_TABLE_SIGNATURE;
	tables->efi_systab.hdr.revision  = ((1 << 16) | 00); /* EFI 1.00 */
	tables->efi_systab.hdr.headersize = sizeof(tables->efi_systab.hdr);

	memcpy(tables->fw_vendor,FW_VENDOR,sizeof(FW_VENDOR));
	tables->efi_systab.fw_vendor = FW_FIELD_MPA(fw_vendor);
	tables->efi_systab.fw_revision = 1;
	tables->efi_systab.runtime = (void *)FW_FIELD_MPA(efi_runtime);
	tables->efi_systab.nr_tables = NUM_EFI_SYS_TABLES;
	tables->efi_systab.tables = FW_FIELD_MPA(efi_tables);

	/* EFI runtime.  */
	tables->efi_runtime.hdr.signature = EFI_RUNTIME_SERVICES_SIGNATURE;
	tables->efi_runtime.hdr.revision = EFI_RUNTIME_SERVICES_REVISION;
	tables->efi_runtime.hdr.headersize = sizeof(tables->efi_runtime.hdr);

	pfn = 0;
	EFI_HYPERCALL_PATCH(get_time,EFI_GET_TIME);
	EFI_HYPERCALL_PATCH(set_time,EFI_SET_TIME);
	EFI_HYPERCALL_PATCH(get_wakeup_time,EFI_GET_WAKEUP_TIME);
	EFI_HYPERCALL_PATCH(set_wakeup_time,EFI_SET_WAKEUP_TIME);
	EFI_HYPERCALL_PATCH(set_virtual_address_map,
	                    EFI_SET_VIRTUAL_ADDRESS_MAP);
	EFI_HYPERCALL_PATCH(get_variable,EFI_GET_VARIABLE);
	EFI_HYPERCALL_PATCH(get_next_variable,EFI_GET_NEXT_VARIABLE);
	EFI_HYPERCALL_PATCH(set_variable,EFI_SET_VARIABLE);
	EFI_HYPERCALL_PATCH(get_next_high_mono_count,
	                    EFI_GET_NEXT_HIGH_MONO_COUNT);
	EFI_HYPERCALL_PATCH(reset_system,EFI_RESET_SYSTEM);

	/* System tables.  */
	tables->efi_tables[0].guid = SAL_SYSTEM_TABLE_GUID;
	tables->efi_tables[0].table = FW_FIELD_MPA(sal_systab);
	for (i = 1; i < NUM_EFI_SYS_TABLES; i++) {
		tables->efi_tables[i].guid = NULL_GUID;
		tables->efi_tables[i].table = 0;
	}
	if (xen_ia64_is_dom0(d)) {
		efi_systable_init_dom0(tables);
	} else {
		efi_systable_init_domu(tables);
	}

	/* fill in the SAL system table: */
	memcpy(tables->sal_systab.signature, "SST_", 4);
	tables->sal_systab.size = sizeof(tables->sal_systab);
	tables->sal_systab.sal_rev_minor = 1;
	tables->sal_systab.sal_rev_major = 0;
	tables->sal_systab.entry_count = 2;

	memcpy((char *)tables->sal_systab.oem_id, "Xen/ia64", 8);
	memcpy((char *)tables->sal_systab.product_id, "Xen/ia64", 8);

	/* PAL entry point: */
	tables->sal_ed.type = SAL_DESC_ENTRY_POINT;
	tables->sal_ed.pal_proc = FW_HYPERCALL_PAL_CALL_PADDR;
	dom_fw_pal_hypercall_patch(brkimm, tables->sal_ed.pal_proc,
				   hypercalls_imva);
	/* SAL entry point.  */
	tables->sal_ed.sal_proc = FW_HYPERCALL_SAL_CALL_PADDR;
	dom_fw_hypercall_patch(brkimm, tables->sal_ed.sal_proc,
	                       FW_HYPERCALL_SAL_CALL, 1, hypercalls_imva);
	tables->sal_ed.gp = 0;  /* will be ignored */

	/* Fill an AP wakeup descriptor.  */
	tables->sal_wakeup.type = SAL_DESC_AP_WAKEUP;
	tables->sal_wakeup.mechanism = IA64_SAL_AP_EXTERNAL_INT;
	tables->sal_wakeup.vector = XEN_SAL_BOOT_RENDEZ_VEC;

	/* Compute checksum.  */
	checksum = 0;
	for (cp = (char *)&tables->sal_systab;
	     cp < (char *)&tables->fpswa_inf;
	     ++cp)
		checksum += *cp;
	tables->sal_systab.checksum = -checksum;

	/* SAL return point.  */
	dom_fw_hypercall_patch(brkimm, FW_HYPERCALL_SAL_RETURN_PADDR,
	                       FW_HYPERCALL_SAL_RETURN, 0, hypercalls_imva);

	/* Fill in the FPSWA interface: */
	if (!xen_ia64_fpswa_revision(d, &tables->fpswa_inf.revision)) {
		fpswa_supported = 1;
		dom_fpswa_hypercall_patch(brkimm, hypercalls_imva);
		tables->fpswa_inf.fpswa = 
			(void *)FW_HYPERCALL_FPSWA_ENTRY_PADDR;
	}

	tables->num_mds = 0;
	/* hypercall patches live here, masquerade as reserved PAL memory */
	xen_ia64_efi_make_md(&tables->efi_memmap[tables->num_mds],
			     EFI_PAL_CODE, EFI_MEMORY_WB | EFI_MEMORY_RUNTIME,
			     FW_HYPERCALL_BASE_PADDR, FW_HYPERCALL_END_PADDR);
	tables->num_mds++;

	/* Create dom0/domu md entry for fw and cpi tables area.  */
	xen_ia64_efi_make_md(&tables->efi_memmap[tables->num_mds],
			     EFI_ACPI_MEMORY_NVS,
			     EFI_MEMORY_WB | EFI_MEMORY_RUNTIME,
			     FW_ACPI_BASE_PADDR, FW_ACPI_END_PADDR);
	tables->num_mds++;
	xen_ia64_efi_make_md(&tables->efi_memmap[tables->num_mds],
			     EFI_RUNTIME_SERVICES_DATA,
			     EFI_MEMORY_WB | EFI_MEMORY_RUNTIME,
			     FW_TABLES_BASE_PADDR,
			     tables->fw_tables_end_paddr);
	tables->num_mds++;

	if (!xen_ia64_is_dom0(d) || xen_ia64_is_running_on_sim(d)) {
		/* DomU (or hp-ski).
		   Create a continuous memory area.  */
		/* kludge: bp->efi_memmap is used to pass memmap_info
		 * page's pfn and number of pages to reserve. 
		 * Currently the following pages must be reserved.
		 * memmap info page, start info page, xenstore page
		 * and console page.
		 * see ia64_setup_memmap() @ xc_dom_boot.c
		 */
		num_mds = complete_domu_memmap(d, tables, maxmem,
					       XEN_IA64_MEMMAP_INFO_PFN(bp),
					       XEN_IA64_MEMMAP_INFO_NUM_PAGES(bp));
	} else {
		/* Dom0.
		   We must preserve ACPI data from real machine,
		   as well as IO areas.  */
		num_mds = complete_dom0_memmap(d, tables);
	}
	if (num_mds < 0)
		return num_mds;
	BUG_ON(num_mds != tables->num_mds);

	/* Display memmap.  */
	for (i = 0 ; i < tables->num_mds; i++)
		print_md(&tables->efi_memmap[i]);

	/* Fill boot_param  */
	bp->efi_systab = FW_FIELD_MPA(efi_systab);
	bp->efi_memmap = FW_FIELD_MPA(efi_memmap);
	bp->efi_memmap_size = tables->num_mds * sizeof(efi_memory_desc_t);
	bp->efi_memdesc_size = sizeof(efi_memory_desc_t);
	bp->efi_memdesc_version = EFI_MEMDESC_VERSION;
	bp->command_line = 0;
	bp->console_info.num_cols = 80;
	bp->console_info.num_rows = 25;
	bp->console_info.orig_x = 0;
	bp->console_info.orig_y = 24;
	if (fpswa_supported)
		bp->fpswa = FW_FIELD_MPA(fpswa_inf);
	return 0;
}