Return to realmode.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / arch / i386 / include

Annotation of qemu/roms/ipxe/src/arch/i386/include/realmode.h, revision 1.1

1.1     ! root        1: #ifndef REALMODE_H
        !             2: #define REALMODE_H
        !             3: 
        !             4: #include <stdint.h>
        !             5: #include <registers.h>
        !             6: #include <ipxe/uaccess.h>
        !             7: 
        !             8: /*
        !             9:  * Data structures and type definitions
        !            10:  *
        !            11:  */
        !            12: 
        !            13: FILE_LICENCE ( GPL2_OR_LATER );
        !            14: 
        !            15: /*
        !            16:  * Declaration of variables in .data16
        !            17:  *
        !            18:  * To place a variable in the .data16 segment, declare it using the
        !            19:  * pattern:
        !            20:  *
        !            21:  *   int __data16 ( foo );
        !            22:  *   #define foo __use_data16 ( foo );
        !            23:  *
        !            24:  *   extern uint32_t __data16 ( bar );
        !            25:  *   #define bar __use_data16 ( bar );
        !            26:  *
        !            27:  *   static long __data16 ( baz ) = 0xff000000UL;
        !            28:  *   #define baz __use_data16 ( baz );
        !            29:  *
        !            30:  * i.e. take a normal declaration, add __data16() around the variable
        !            31:  * name, and add a line saying "#define <name> __use_data16 ( <name> )
        !            32:  *
        !            33:  * You can then access them just like any other variable, for example
        !            34:  *
        !            35:  *   int x = foo + bar;
        !            36:  *
        !            37:  * This magic is achieved at a cost of only around 7 extra bytes per
        !            38:  * group of accesses to .data16 variables.  When using KEEP_IT_REAL,
        !            39:  * there is no extra cost.
        !            40:  *
        !            41:  * You should place variables in .data16 when they need to be accessed
        !            42:  * by real-mode code.  Real-mode assembly (e.g. as created by
        !            43:  * REAL_CODE()) can access these variables via the usual data segment.
        !            44:  * You can therefore write something like
        !            45:  *
        !            46:  *   static uint16_t __data16 ( foo );
        !            47:  *   #define foo __use_data16 ( foo )
        !            48:  *
        !            49:  *   int bar ( void ) {
        !            50:  *     __asm__ __volatile__ ( REAL_CODE ( "int $0xff\n\t"
        !            51:  *                                        "movw %ax, foo" )
        !            52:  *                            : : );
        !            53:  *     return foo;
        !            54:  *   }
        !            55:  *
        !            56:  * Variables may also be placed in .text16 using __text16 and
        !            57:  * __use_text16.  Some variables (e.g. chained interrupt vectors) fit
        !            58:  * most naturally in .text16; most should be in .data16.
        !            59:  *
        !            60:  * If you have only a pointer to a magic symbol within .data16 or
        !            61:  * .text16, rather than the symbol itself, you can attempt to extract
        !            62:  * the underlying symbol name using __from_data16() or
        !            63:  * __from_text16().  This is not for the faint-hearted; check the
        !            64:  * assembler output to make sure that it's doing the right thing.
        !            65:  */
        !            66: 
        !            67: /**
        !            68:  * Copy data to base memory
        !            69:  *
        !            70:  * @v dest_seg         Destination segment
        !            71:  * @v dest_off         Destination offset
        !            72:  * @v src              Source
        !            73:  * @v len              Length
        !            74:  */
        !            75: static inline __always_inline void
        !            76: copy_to_real ( unsigned int dest_seg, unsigned int dest_off,
        !            77:               void *src, size_t n ) {
        !            78:        copy_to_user ( real_to_user ( dest_seg, dest_off ), 0, src, n );
        !            79: }
        !            80: 
        !            81: /**
        !            82:  * Copy data to base memory
        !            83:  *
        !            84:  * @v dest             Destination
        !            85:  * @v src_seg          Source segment
        !            86:  * @v src_off          Source offset
        !            87:  * @v len              Length
        !            88:  */
        !            89: static inline __always_inline void
        !            90: copy_from_real ( void *dest, unsigned int src_seg,
        !            91:                 unsigned int src_off, size_t n ) {
        !            92:        copy_from_user ( dest, real_to_user ( src_seg, src_off ), 0, n );
        !            93: }
        !            94: 
        !            95: /**
        !            96:  * Write a single variable to base memory
        !            97:  *
        !            98:  * @v var              Variable to write
        !            99:  * @v dest_seg         Destination segment
        !           100:  * @v dest_off         Destination offset
        !           101:  */
        !           102: #define put_real( var, dest_seg, dest_off ) \
        !           103:        copy_to_real ( (dest_seg), (dest_off), &(var), sizeof (var) )
        !           104: 
        !           105: /**
        !           106:  * Read a single variable from base memory
        !           107:  *
        !           108:  * @v var              Variable to read
        !           109:  * @v src_seg          Source segment
        !           110:  * @v src_off          Source offset
        !           111:  */
        !           112: #define get_real( var, src_seg, src_off ) \
        !           113:        copy_from_real ( &(var), (src_seg), (src_off), sizeof (var) )
        !           114: 
        !           115: /*
        !           116:  * REAL_CODE ( asm_code_str )
        !           117:  *
        !           118:  * This can be used in inline assembly to create a fragment of code
        !           119:  * that will execute in real mode.  For example: to write a character
        !           120:  * to the BIOS console using INT 10, you would do something like:
        !           121:  *
        !           122:  *     __asm__ __volatile__ ( REAL_CODE ( "int $0x16" )
        !           123:  *                           : "=a" ( character ) : "a" ( 0x0000 ) );
        !           124:  *
        !           125:  */
        !           126: 
        !           127: #endif /* REALMODE_H */

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