src/arch/x86/interface/pcbios/int15.c - ipxe - Git at Google

 /*
  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  *
  * You can also choose to distribute this program under the terms of
  * the Unmodified Binary Distribution Licence (as given in the file
  * COPYING.UBDL), provided that you have satisfied its requirements.
  */

 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
 #include <assert.h>
 #include <realmode.h>
 #include <bios.h>
 #include <memsizes.h>
 #include <ipxe/io.h>
 #include <ipxe/memmap.h>

 /**
  * @file
  *
  * Memory mapping
  *
  */

 /** Magic value for INT 15,e820 calls */
 #define SMAP ( 0x534d4150 )

 /** An INT 15,e820 memory map entry */
 struct e820_entry {
 	/** Start of region */
 	uint64_t start;
 	/** Length of region */
 	uint64_t len;
 	/** Type of region */
 	uint32_t type;
 	/** Extended attributes (optional) */
 	uint32_t attrs;
 } __attribute__ (( packed ));

 #define E820_TYPE_RAM		1 /**< Normal memory */
 #define E820_TYPE_RESERVED	2 /**< Reserved and unavailable */
 #define E820_TYPE_ACPI		3 /**< ACPI reclaim memory */
 #define E820_TYPE_NVS		4 /**< ACPI NVS memory */

 #define E820_ATTR_ENABLED	0x00000001UL
 #define E820_ATTR_NONVOLATILE	0x00000002UL
 #define E820_ATTR_UNKNOWN	0xfffffffcUL

 #define E820_MIN_SIZE		20

 /** Buffer for INT 15,e820 calls */
 static struct e820_entry __bss16 ( e820buf );
 #define e820buf __use_data16 ( e820buf )

 /** We are running during POST; inhibit INT 15,e820 and INT 15,e801 */
 uint8_t __bss16 ( memmap_post );
 #define memmap_post __use_data16 ( memmap_post )

 /**
  * Get size of extended memory via INT 15,e801
  *
  * @ret extmem		Extended memory size, in kB, or 0
  */
 static unsigned int extmemsize_e801 ( void ) {
 	uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k;
 	uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k;
 	unsigned int flags;
 	unsigned int extmem;

 	/* Inhibit INT 15,e801 during POST */
 	if ( memmap_post ) {
 		DBG ( "INT 15,e801 not available during POST\n" );
 		return 0;
 	}

 	__asm__ __volatile__ ( REAL_CODE ( "stc\n\t"
 					   "int $0x15\n\t"
 					   "pushfw\n\t"
 					   "popw %w0\n\t" )
 			       : "=R" ( flags ),
 				 "=a" ( extmem_1m_to_16m_k ),
 				 "=b" ( extmem_16m_plus_64k ),
 				 "=c" ( confmem_1m_to_16m_k ),
 				 "=d" ( confmem_16m_plus_64k )
 			       : "a" ( 0xe801 ) );

 	if ( flags & CF ) {
 		DBG ( "INT 15,e801 failed with CF set\n" );
 		return 0;
 	}

 	if ( ! ( extmem_1m_to_16m_k | extmem_16m_plus_64k ) ) {
 		DBG ( "INT 15,e801 extmem=0, using confmem\n" );
 		extmem_1m_to_16m_k = confmem_1m_to_16m_k;
 		extmem_16m_plus_64k = confmem_16m_plus_64k;
 	}

 	extmem = ( extmem_1m_to_16m_k + ( extmem_16m_plus_64k * 64 ) );
 	DBG ( "INT 15,e801 extended memory size %d+64*%d=%d kB "
 	      "[100000,%llx)\n", extmem_1m_to_16m_k, extmem_16m_plus_64k,
 	      extmem, ( 0x100000 + ( ( ( uint64_t ) extmem ) * 1024 ) ) );

 	/* Sanity check.  Some BIOSes report the entire 4GB address
 	 * space as available, which cannot be correct (since that
 	 * would leave no address space available for 32-bit PCI
 	 * BARs).
 	 */
 	if ( extmem == ( 0x400000 - 0x400 ) ) {
 		DBG ( "INT 15,e801 reported whole 4GB; assuming insane\n" );
 		return 0;
 	}

 	return extmem;
 }

 /**
  * Get size of extended memory via INT 15,88
  *
  * @ret extmem		Extended memory size, in kB
  */
 static unsigned int extmemsize_88 ( void ) {
 	uint16_t extmem;

 	/* Ignore CF; it is not reliable for this call */
 	__asm__ __volatile__ ( REAL_CODE ( "int $0x15" )
 			       : "=a" ( extmem ) : "a" ( 0x8800 ) );

 	DBG ( "INT 15,88 extended memory size %d kB [100000, %x)\n",
 	      extmem, ( 0x100000 + ( extmem * 1024 ) ) );
 	return extmem;
 }

 /**
  * Get size of extended memory
  *
  * @ret extmem		Extended memory size, in kB
  *
  * Note that this is only an approximation; for an accurate picture,
  * use the E820 memory map obtained via memmap_describe();
  */
 unsigned int extmemsize ( void ) {
 	unsigned int extmem_e801;
 	unsigned int extmem_88;

 	/* Try INT 15,e801 first, then fall back to INT 15,88 */
 	extmem_88 = extmemsize_88();
 	extmem_e801 = extmemsize_e801();
 	return ( extmem_e801 ? extmem_e801 : extmem_88 );
 }

 /**
  * Get e820 memory map
  *
  * @v region		Memory region of interest to be updated
  * @ret rc		Return status code
  */
 static int meme820 ( struct memmap_region *region ) {
 	unsigned int count = 0;
 	uint64_t start = 0;
 	uint64_t len = 0;
 	uint32_t next = 0;
 	uint32_t smap;
 	uint32_t size;
 	unsigned int flags;
 	unsigned int discard_D;

 	/* Inhibit INT 15,e820 during POST */
 	if ( memmap_post ) {
 		DBG ( "INT 15,e820 not available during POST\n" );
 		return -ENOTTY;
 	}

 	/* Clear the E820 buffer.  Do this once before starting,
 	 * rather than on each call; some BIOSes rely on the contents
 	 * being preserved between calls.
 	 */
 	memset ( &e820buf, 0, sizeof ( e820buf ) );

 	do {
 		/* Some BIOSes corrupt %esi for fun. Guard against
 		 * this by telling gcc that all non-output registers
 		 * may be corrupted.
 		 */
 		__asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t"
 						   "stc\n\t"
 						   "int $0x15\n\t"
 						   "pushfw\n\t"
 						   "popw %%dx\n\t"
 						   "popl %%ebp\n\t" )
 				       : "=a" ( smap ), "=b" ( next ),
 					 "=c" ( size ), "=d" ( flags ),
 					 "=D" ( discard_D )
 				       : "a" ( 0xe820 ), "b" ( next ),
 					 "D" ( __from_data16 ( &e820buf ) ),
 					 "c" ( sizeof ( e820buf ) ),
 					 "d" ( SMAP )
 				       : "esi", "memory" );

 		if ( smap != SMAP ) {
 			DBG ( "INT 15,e820 failed SMAP signature check\n" );
 			return -ENOTSUP;
 		}

 		if ( size < E820_MIN_SIZE ) {
 			DBG ( "INT 15,e820 returned only %d bytes\n", size );
 			return -EINVAL;
 		}

 		if ( flags & CF ) {
 			DBG ( "INT 15,e820 terminated on CF set\n" );
 			break;
 		}

 		DBG ( "INT 15,e820 region [%llx,%llx) type %d",
 		      e820buf.start, ( e820buf.start + e820buf.len ),
 		      ( int ) e820buf.type );
 		if ( size > offsetof ( typeof ( e820buf ), attrs ) ) {
 			DBG ( " (%s", ( ( e820buf.attrs & E820_ATTR_ENABLED )
 					? "enabled" : "disabled" ) );
 			if ( e820buf.attrs & E820_ATTR_NONVOLATILE )
 				DBG ( ", non-volatile" );
 			if ( e820buf.attrs & E820_ATTR_UNKNOWN )
 				DBG ( ", other [%08x]", e820buf.attrs );
 			DBG ( ")" );
 		}
 		DBG ( "\n" );

 		/* Discard non-RAM regions */
 		if ( e820buf.type != E820_TYPE_RAM )
 			continue;

 		/* Check extended attributes, if present */
 		if ( size > offsetof ( typeof ( e820buf ), attrs ) ) {
 			if ( ! ( e820buf.attrs & E820_ATTR_ENABLED ) )
 				continue;
 			if ( e820buf.attrs & E820_ATTR_NONVOLATILE )
 				continue;
 		}

 		/* Check for adjacent regions and merge them */
 		if ( e820buf.start == ( start + len ) ) {
 			len += e820buf.len;
 		} else {
 			start = e820buf.start;
 			len = e820buf.len;
 		}

 		/* Sanity check: first region (base memory) should
 		 * start at address zero.
 		 */
 		if ( ( count == 0 ) && ( start != 0 ) ) {
 			DBG ( "INT 15,e820 region 0 starts at %llx (expected "
 			      "0); assuming insane\n", start );
 			return -EINVAL;
 		}

 		/* Sanity check: second region (extended memory)
 		 * should start at address 0x100000.
 		 */
 		if ( ( count == 1 ) && ( start != 0x100000 ) ) {
 			DBG ( "INT 15,e820 region 1 starts at %llx (expected "
 			      "100000); assuming insane\n", start );
 			return -EINVAL;
 		}

 		/* Update region of interest */
 		memmap_update ( region, start, len, MEMMAP_FL_MEMORY, "e820" );
 		count++;

 	} while ( next != 0 );

 	/* Sanity checks.  Some BIOSes report complete garbage via INT
 	 * 15,e820 (especially at POST time), despite passing the
 	 * signature checks.  We currently check for a base memory
 	 * region (starting at 0) and at least one high memory region
 	 * (starting at 0x100000).
 	 */
 	if ( count < 2 ) {
 		DBG ( "INT 15,e820 returned only %d regions; assuming "
 		      "insane\n", count );
 		return -EINVAL;
 	}

 	return 0;
 }

 /**
  * Describe memory region from system memory map
  *
  * @v min		Minimum address
  * @v hide		Hide in-use regions from the memory map
  * @v region		Region descriptor to fill in
  */
 static void int15_describe ( uint64_t min, int hide,
 			     struct memmap_region *region ) {
 	unsigned int basemem;
 	unsigned int extmem;
 	uint64_t inaccessible;
 	int rc;

 	/* Initialise region */
 	memmap_init ( min, region );

 	/* Mark addresses above 4GB as inaccessible: we have no way to
 	 * access them either in a 32-bit build or in a 64-bit build
 	 * (since the 64-bit build identity-maps only the 32-bit
 	 * address space).
 	 */
 	inaccessible = ( 1ULL << 32 );
 	memmap_update ( region, inaccessible, -inaccessible,
 			MEMMAP_FL_INACCESSIBLE, NULL );

 	/* Enable/disable INT 15 interception as applicable */
 	int15_intercept ( hide );

 	/* Try INT 15,e820 first, falling back to constructing a map
 	 * from basemem and extmem sizes
 	 */
 	if ( ( rc = meme820 ( region ) ) == 0 ) {
 		DBG ( "Obtained system memory map via INT 15,e820\n" );
 	} else {
 		basemem = basememsize();
 		DBG ( "FBMS base memory size %d kB [0,%x)\n",
 		      basemem, ( basemem * 1024 ) );
 		extmem = extmemsize();
 		memmap_update ( region, 0, ( basemem * 1024 ),
 				MEMMAP_FL_MEMORY, "basemem" );
 		memmap_update ( region, 0x100000, ( extmem * 1024 ),
 				MEMMAP_FL_MEMORY, "extmem" );
 	}

 	/* Restore INT 15 interception */
 	int15_intercept ( 1 );
 }

 PROVIDE_MEMMAP ( int15, memmap_describe, int15_describe );
	/*
	* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation; either version 2 of the
	* License, or any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	* You can also choose to distribute this program under the terms of
	* the Unmodified Binary Distribution Licence (as given in the file
	* COPYING.UBDL), provided that you have satisfied its requirements.
	*/

	FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

	#include <stdint.h>
	#include <string.h>
	#include <errno.h>
	#include <assert.h>
	#include <realmode.h>
	#include <bios.h>
	#include <memsizes.h>
	#include <ipxe/io.h>
	#include <ipxe/memmap.h>

	/**
	* @file
	*
	* Memory mapping
	*
	*/

	/** Magic value for INT 15,e820 calls */
	#define SMAP ( 0x534d4150 )

	/** An INT 15,e820 memory map entry */
	struct e820_entry {
	/** Start of region */
	uint64_t start;
	/** Length of region */
	uint64_t len;
	/** Type of region */
	uint32_t type;
	/** Extended attributes (optional) */
	uint32_t attrs;
	} __attribute__ (( packed ));

	#define E820_TYPE_RAM 1 /*< Normal memory /
	#define E820_TYPE_RESERVED 2 /*< Reserved and unavailable /
	#define E820_TYPE_ACPI 3 /*< ACPI reclaim memory /
	#define E820_TYPE_NVS 4 /*< ACPI NVS memory /

	#define E820_ATTR_ENABLED 0x00000001UL
	#define E820_ATTR_NONVOLATILE 0x00000002UL
	#define E820_ATTR_UNKNOWN 0xfffffffcUL

	#define E820_MIN_SIZE 20

	/** Buffer for INT 15,e820 calls */
	static struct e820_entry __bss16 ( e820buf );
	#define e820buf __use_data16 ( e820buf )

	/** We are running during POST; inhibit INT 15,e820 and INT 15,e801 */
	uint8_t __bss16 ( memmap_post );
	#define memmap_post __use_data16 ( memmap_post )

	/**
	* Get size of extended memory via INT 15,e801
	*
	* @ret extmem Extended memory size, in kB, or 0
	*/
	static unsigned int extmemsize_e801 ( void ) {
	uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k;
	uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k;
	unsigned int flags;
	unsigned int extmem;

	/* Inhibit INT 15,e801 during POST */
	if ( memmap_post ) {
	DBG ( "INT 15,e801 not available during POST\n" );
	return 0;
	}

	__asm__ __volatile__ ( REAL_CODE ( "stc\n\t"
	"int $0x15\n\t"
	"pushfw\n\t"
	"popw %w0\n\t" )
	: "=R" ( flags ),
	"=a" ( extmem_1m_to_16m_k ),
	"=b" ( extmem_16m_plus_64k ),
	"=c" ( confmem_1m_to_16m_k ),
	"=d" ( confmem_16m_plus_64k )
	: "a" ( 0xe801 ) );

	if ( flags & CF ) {
	DBG ( "INT 15,e801 failed with CF set\n" );
	return 0;
	}

	if ( ! ( extmem_1m_to_16m_k \| extmem_16m_plus_64k ) ) {
	DBG ( "INT 15,e801 extmem=0, using confmem\n" );
	extmem_1m_to_16m_k = confmem_1m_to_16m_k;
	extmem_16m_plus_64k = confmem_16m_plus_64k;
	}

	extmem = ( extmem_1m_to_16m_k + ( extmem_16m_plus_64k * 64 ) );
	DBG ( "INT 15,e801 extended memory size %d+64*%d=%d kB "
	"[100000,%llx)\n", extmem_1m_to_16m_k, extmem_16m_plus_64k,
	extmem, ( 0x100000 + ( ( ( uint64_t ) extmem ) * 1024 ) ) );

	/* Sanity check. Some BIOSes report the entire 4GB address
	* space as available, which cannot be correct (since that
	* would leave no address space available for 32-bit PCI
	* BARs).
	*/
	if ( extmem == ( 0x400000 - 0x400 ) ) {
	DBG ( "INT 15,e801 reported whole 4GB; assuming insane\n" );
	return 0;
	}

	return extmem;
	}

	/**
	* Get size of extended memory via INT 15,88
	*
	* @ret extmem Extended memory size, in kB
	*/
	static unsigned int extmemsize_88 ( void ) {
	uint16_t extmem;

	/* Ignore CF; it is not reliable for this call */
	__asm__ __volatile__ ( REAL_CODE ( "int $0x15" )
	: "=a" ( extmem ) : "a" ( 0x8800 ) );

	DBG ( "INT 15,88 extended memory size %d kB [100000, %x)\n",
	extmem, ( 0x100000 + ( extmem * 1024 ) ) );
	return extmem;
	}

	/**
	* Get size of extended memory
	*
	* @ret extmem Extended memory size, in kB
	*
	* Note that this is only an approximation; for an accurate picture,
	* use the E820 memory map obtained via memmap_describe();
	*/
	unsigned int extmemsize ( void ) {
	unsigned int extmem_e801;
	unsigned int extmem_88;

	/* Try INT 15,e801 first, then fall back to INT 15,88 */
	extmem_88 = extmemsize_88();
	extmem_e801 = extmemsize_e801();
	return ( extmem_e801 ? extmem_e801 : extmem_88 );
	}

	/**
	* Get e820 memory map
	*
	* @v region Memory region of interest to be updated
	* @ret rc Return status code
	*/
	static int meme820 ( struct memmap_region *region ) {
	unsigned int count = 0;
	uint64_t start = 0;
	uint64_t len = 0;
	uint32_t next = 0;
	uint32_t smap;
	uint32_t size;
	unsigned int flags;
	unsigned int discard_D;

	/* Inhibit INT 15,e820 during POST */
	if ( memmap_post ) {
	DBG ( "INT 15,e820 not available during POST\n" );
	return -ENOTTY;
	}

	/* Clear the E820 buffer. Do this once before starting,
	* rather than on each call; some BIOSes rely on the contents
	* being preserved between calls.
	*/
	memset ( &e820buf, 0, sizeof ( e820buf ) );

	do {
	/* Some BIOSes corrupt %esi for fun. Guard against
	* this by telling gcc that all non-output registers
	* may be corrupted.
	*/
	__asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t"
	"stc\n\t"
	"int $0x15\n\t"
	"pushfw\n\t"
	"popw %%dx\n\t"
	"popl %%ebp\n\t" )
	: "=a" ( smap ), "=b" ( next ),
	"=c" ( size ), "=d" ( flags ),
	"=D" ( discard_D )
	: "a" ( 0xe820 ), "b" ( next ),
	"D" ( __from_data16 ( &e820buf ) ),
	"c" ( sizeof ( e820buf ) ),
	"d" ( SMAP )
	: "esi", "memory" );

	if ( smap != SMAP ) {
	DBG ( "INT 15,e820 failed SMAP signature check\n" );
	return -ENOTSUP;
	}

	if ( size < E820_MIN_SIZE ) {
	DBG ( "INT 15,e820 returned only %d bytes\n", size );
	return -EINVAL;
	}

	if ( flags & CF ) {
	DBG ( "INT 15,e820 terminated on CF set\n" );
	break;
	}

	DBG ( "INT 15,e820 region [%llx,%llx) type %d",
	e820buf.start, ( e820buf.start + e820buf.len ),
	( int ) e820buf.type );
	if ( size > offsetof ( typeof ( e820buf ), attrs ) ) {
	DBG ( " (%s", ( ( e820buf.attrs & E820_ATTR_ENABLED )
	? "enabled" : "disabled" ) );
	if ( e820buf.attrs & E820_ATTR_NONVOLATILE )
	DBG ( ", non-volatile" );
	if ( e820buf.attrs & E820_ATTR_UNKNOWN )
	DBG ( ", other [%08x]", e820buf.attrs );
	DBG ( ")" );
	}
	DBG ( "\n" );

	/* Discard non-RAM regions */
	if ( e820buf.type != E820_TYPE_RAM )
	continue;

	/* Check extended attributes, if present */
	if ( size > offsetof ( typeof ( e820buf ), attrs ) ) {
	if ( ! ( e820buf.attrs & E820_ATTR_ENABLED ) )
	continue;
	if ( e820buf.attrs & E820_ATTR_NONVOLATILE )
	continue;
	}

	/* Check for adjacent regions and merge them */
	if ( e820buf.start == ( start + len ) ) {
	len += e820buf.len;
	} else {
	start = e820buf.start;
	len = e820buf.len;
	}

	/* Sanity check: first region (base memory) should
	* start at address zero.
	*/
	if ( ( count == 0 ) && ( start != 0 ) ) {
	DBG ( "INT 15,e820 region 0 starts at %llx (expected "
	"0); assuming insane\n", start );
	return -EINVAL;
	}

	/* Sanity check: second region (extended memory)
	* should start at address 0x100000.
	*/
	if ( ( count == 1 ) && ( start != 0x100000 ) ) {
	DBG ( "INT 15,e820 region 1 starts at %llx (expected "
	"100000); assuming insane\n", start );
	return -EINVAL;
	}

	/* Update region of interest */
	memmap_update ( region, start, len, MEMMAP_FL_MEMORY, "e820" );
	count++;

	} while ( next != 0 );

	/* Sanity checks. Some BIOSes report complete garbage via INT
	* 15,e820 (especially at POST time), despite passing the
	* signature checks. We currently check for a base memory
	* region (starting at 0) and at least one high memory region
	* (starting at 0x100000).
	*/
	if ( count < 2 ) {
	DBG ( "INT 15,e820 returned only %d regions; assuming "
	"insane\n", count );
	return -EINVAL;
	}

	return 0;
	}

	/**
	* Describe memory region from system memory map
	*
	* @v min Minimum address
	* @v hide Hide in-use regions from the memory map
	* @v region Region descriptor to fill in
	*/
	static void int15_describe ( uint64_t min, int hide,
	struct memmap_region *region ) {
	unsigned int basemem;
	unsigned int extmem;
	uint64_t inaccessible;
	int rc;

	/* Initialise region */
	memmap_init ( min, region );

	/* Mark addresses above 4GB as inaccessible: we have no way to
	* access them either in a 32-bit build or in a 64-bit build
	* (since the 64-bit build identity-maps only the 32-bit
	* address space).
	*/
	inaccessible = ( 1ULL << 32 );
	memmap_update ( region, inaccessible, -inaccessible,
	MEMMAP_FL_INACCESSIBLE, NULL );

	/* Enable/disable INT 15 interception as applicable */
	int15_intercept ( hide );

	/* Try INT 15,e820 first, falling back to constructing a map
	* from basemem and extmem sizes
	*/
	if ( ( rc = meme820 ( region ) ) == 0 ) {
	DBG ( "Obtained system memory map via INT 15,e820\n" );
	} else {
	basemem = basememsize();
	DBG ( "FBMS base memory size %d kB [0,%x)\n",
	basemem, ( basemem * 1024 ) );
	extmem = extmemsize();
	memmap_update ( region, 0, ( basemem * 1024 ),
	MEMMAP_FL_MEMORY, "basemem" );
	memmap_update ( region, 0x100000, ( extmem * 1024 ),
	MEMMAP_FL_MEMORY, "extmem" );
	}

	/* Restore INT 15 interception */
	int15_intercept ( 1 );
	}

	PROVIDE_MEMMAP ( int15, memmap_describe, int15_describe );