home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 024 / psi110g.zip / EMMLIB.H < prev    next >
Text File  |  1994-04-17  |  60KB  |  918 lines
  1. /*===========================================================================*/
  2. /*                          EMM FUNCTION CLASSES                             */
  3. /*------------------------------------+--------------------------------------*/
  4. /*     PRESENCE, STATUS, & VERSION    |      MEMORY MOVEMENT & EXCHANGE      */
  5. /*------------------------------------+--------------------------------------*/
  6. /*   EMM_installed                    |   move_memory_region                 */
  7. /*   get_EMM_status                   |   xchg_memory_region                 */
  8. /*   get_EMM_version                  |                                      */
  9. /*                                    |                                      */
  10. /*------------------------------------+--------------------------------------*/
  11. /*          MEMORY ALLOCATION         |           HANDLE MANAGEMENT          */
  12. /*------------------------------------+--------------------------------------*/
  13. /*   get_unalloc_page_count           |   get_handle_count                   */
  14. /*   get_alloc_page_count             |   get_handle_pages                   */
  15. /*   get_total_page_count             |   get_all_handles_pages              */
  16. /*   get_unalloc_raw_page_count       |   get_handle_attrib                  */
  17. /*   get_alloc_raw_page_count         |   set_handle_attrib                  */
  18. /*   get_total_raw_page_count         |   get_attrib_capability              */
  19. /*   alloc_pages                      |   get_handle_name                    */
  20. /*   dealloc_pages                    |   set_handle_name                    */
  21. /*   realloc_pages                    |   get_handle_dir                     */
  22. /*   alloc_std_pages                  |   search_handle_name                 */
  23. /*   alloc_raw_pages                  |   get_total_handles                  */
  24. /*                                    |                                      */
  25. /*------------------------------------+--------------------------------------*/
  26. /*     MAPPABLE MEMORY REGION INFO    |         PROGRAM FLOW CONTROL         */
  27. /*------------------------------------+--------------------------------------*/
  28. /*   get_page_frame_seg               |   alter_map_jump                     */
  29. /*   get_mappable_conv_regions        |   alter_map_call                     */
  30. /*   get_mappable_exp_regions         |   get_alter_map_call_stack_size      */
  31. /*   get_mappable_regions             |                                      */
  32. /*   get_mappable_conv_region_count   |                                      */
  33. /*   get_mappable_exp_region_count    |                                      */
  34. /*   get_mappable_region_count        |                                      */
  35. /*   get_page_frame_count             |                                      */
  36. /*                                    |                                      */
  37. /*------------------------------------+--------------------------------------*/
  38. /*           MEMORY MAPPING           |                OS ONLY               */
  39. /*------------------------------------+--------------------------------------*/
  40. /*   map_unmap_page                   |   enable_OS_fcns                     */
  41. /*   map_unmap_pages                  |   disable_OS_fcns                    */
  42. /*                                    |   return_OS_access_key               */
  43. /*------------------------------------+   get_hw_info                        */
  44. /*       MEMORY MAPPING CONTEXT       |   get_alt_reg_set                    */
  45. /*------------------------------------+   set_alt_reg_set                    */
  46. /*   save_context                     |   get_alt_context_size               */
  47. /*   restore_context                  |   alloc_alt_reg_set                  */
  48. /*   get_context                      |   dealloc_alt_reg_set                */
  49. /*   set_context                      |   alloc_DMA_reg_set                  */
  50. /*   get_set_context                  |   enable_DMA_reg_set                 */
  51. /*   get_context_size                 |   disable_DMA_reg_set                */
  52. /*   get_partial_context              |   dealloc_DMA_reg_set                */
  53. /*   get_partial_context_size         |   prep_EMM_warmboot                  */
  54. /*   set_partial_context              |                                      */
  55. /*                                    |                                      */
  56. /*====================================+======================================*/
  57.   
  58. /*===========================================================================*/
  59. /*                           EMM MANIFEST CONSTANTS                          */
  60. /*===========================================================================*/
  61. #define MAX_HANDLES             255
  62. #define MAX_HANDLE_NAME_LEN     8
  63. #define VOLATILE                0
  64. #define NONVOLATILE             1
  65. #define MAX_MAPPABLE_REGIONS    64
  66. #define PHYS_PAGE_MODE          0
  67. #define SEG_MODE                1
  68. #define MAX_CONTEXT_SIZE        255
  69. #define CONV_MEM                0
  70. #define EXP_MEM                 1
  71. #define UNMAP                   0xFFFF
  72.   
  73. /*===========================================================================*/
  74. /*                                 EMM MACRO                                 */
  75. /*===========================================================================*/
  76.     /*-----------------------------------------------------------------------*/
  77.     /*   This macro converts an unsigned int containing a segment address,   */
  78.     /*   into a far pointer to a void.  It is useful in converting the       */
  79.     /*   segment values, returned by EMM function calls, into far pointers   */
  80.     /*   which C programs can use.  For example:                             */
  81.     /*                                                                       */
  82.     /*   unsigned int status,                                                */
  83.     /*                  page_frame_seg;                                      */
  84.     /*   char far *page_frame_ptr;                                           */
  85.     /*                                                                       */
  86.     /*   status = get_page_frame_seg (&page_frame_seg);                      */
  87.     /*   page_frame_ptr = FP(page_frame_seg);                                */
  88.     /*   *page_frame_ptr = 0;                                                */
  89.     /*-----------------------------------------------------------------------*/
  90.     #define FP(SEG) ((void far *)((unsigned long)SEG << 16))
  91.   
  92. /*===========================================================================*/
  93. /*                           EMM STRUCTURE TYPEDEFS                          */
  94. /*===========================================================================*/
  95.     /*-----------------------------------------------------------------------*/
  96.     /*               Structure:   HANDLES_PAGES_STRUCT                       */
  97.     /*                                                                       */
  98.     /*   Required by Functions:   get_all_handles_pages                      */
  99.     /*-----------------------------------------------------------------------*/
  100.     #pragma pack(1)
  101. typedef struct
  102. {
  103.     unsigned int            handle;
  104.     unsigned int            pages_allocated;
  105. } HANDLES_PAGES_STRUCT;
  106.     #pragma pack()
  107.   
  108.     /*-----------------------------------------------------------------------*/
  109.     /*               Structure:   HANDLE_NAME_STRUCT                         */
  110.     /*                                                                       */
  111.     /*   Required by Functions:   get_handle_name                            */
  112.     /*                            set_handle_name                            */
  113.     /*                            search_handle_name                         */
  114.     /*-----------------------------------------------------------------------*/
  115.     #pragma pack(1)
  116. typedef struct
  117. {
  118.     unsigned char           name [MAX_HANDLE_NAME_LEN];
  119. } HANDLE_NAME_STRUCT;
  120.     #pragma pack()
  121.   
  122.     /*-----------------------------------------------------------------------*/
  123.     /*               Structure:   HANDLE_DIR_STRUCT                          */
  124.     /*                                                                       */
  125.     /*   Required by Functions:   get_handle_dir                             */
  126.     /*-----------------------------------------------------------------------*/
  127.     #pragma pack(1)
  128. typedef struct
  129. {
  130.     unsigned int            handle;
  131.     unsigned char           name [MAX_HANDLE_NAME_LEN];
  132. } HANDLE_DIR_STRUCT;
  133.     #pragma pack()
  134.   
  135.     /*-----------------------------------------------------------------------*/
  136.     /*               Structure:   CONTEXT_STRUCT                             */
  137.     /*                                                                       */
  138.     /*   Required by Functions:   get_context                                */
  139.     /*                            set_context                                */
  140.     /*                            get_set_context                            */
  141.     /*                            get_partial_context                        */
  142.     /*                            set_partial_context                        */
  143.     /*                            set_alt_reg_set                            */
  144.     /*-----------------------------------------------------------------------*/
  145.     #pragma pack(1)
  146. typedef struct
  147. {
  148.     unsigned char           reserved [MAX_CONTEXT_SIZE];
  149. } CONTEXT_STRUCT;
  150.     #pragma pack()
  151.   
  152.     /*-----------------------------------------------------------------------*/
  153.     /*               Structure:   PARTIAL_CONTEXT_LIST_STRUCT                */
  154.     /*                                                                       */
  155.     /*   Required by Functions:   get_partial_context                        */
  156.     /*-----------------------------------------------------------------------*/
  157.     #pragma pack(1)
  158. typedef struct
  159. {
  160.     unsigned int            mappable_region_count;
  161.     unsigned int            mappable_region_seg [MAX_MAPPABLE_REGIONS];
  162. } PARTIAL_CONTEXT_LIST_STRUCT;
  163.     #pragma pack()
  164.   
  165.     /*-----------------------------------------------------------------------*/
  166.     /*               Structure:   MAP_STRUCT                                 */
  167.     /*                                                                       */
  168.     /*   Required by Functions:   map_unmap_pages                            */
  169.     /*                            alter_map_jump                             */
  170.     /*                            alter_map_call                             */
  171.     /*-----------------------------------------------------------------------*/
  172.     #pragma pack(1)
  173. typedef struct
  174. {
  175.     unsigned int            log_page;
  176.     unsigned int            phys_page_or_seg;
  177. } MAP_STRUCT;
  178.     #pragma pack()
  179.   
  180.     /*-----------------------------------------------------------------------*/
  181.     /*               Structure:   MAP_JUMP_STRUCT                            */
  182.     /*                                                                       */
  183.     /*   Required by Functions:   alter_map_jump                             */
  184.     /*-----------------------------------------------------------------------*/
  185.     #pragma pack(1)
  186. typedef struct
  187. {
  188.     void                    (far *target_function) ();
  189.     unsigned char           map_struct_count;
  190.     MAP_STRUCT far *        ptr_map_struct;
  191. } MAP_JUMP_STRUCT;
  192.     #pragma pack()
  193.   
  194.     /*-----------------------------------------------------------------------*/
  195.     /*               Structure:   MAP_CALL_STRUCT                            */
  196.     /*                                                                       */
  197.     /*   Required by Functions:   alter_map_call                             */
  198.     /*-----------------------------------------------------------------------*/
  199.     #pragma pack(1)
  200. typedef struct
  201. {
  202.     void                    (far *target_function) ();
  203.     unsigned char           init_map_struct_count;
  204.     MAP_STRUCT far *        ptr_init_map_struct;
  205.     unsigned char           final_map_struct_count;
  206.     MAP_STRUCT far *        ptr_final_map_struct;
  207.     unsigned char           reserved[8];
  208. } MAP_CALL_STRUCT;
  209.     #pragma pack()
  210.   
  211.     /*-----------------------------------------------------------------------*/
  212.     /*               Structure:   MOVE_XCHG_STRUCT                           */
  213.     /*                                                                       */
  214.     /*   Required by Functions:   move_memory_region                         */
  215.     /*                            xchg_memory_region                         */
  216.     /*-----------------------------------------------------------------------*/
  217.     #pragma pack(1)
  218. typedef struct
  219. {
  220.     unsigned long           region_size;
  221.     unsigned char           source_mem_type;
  222.     unsigned int            source_handle;
  223.     unsigned int            source_init_offset;
  224.     unsigned int            source_init_log_page_or_seg;
  225.     unsigned char           dest_mem_type;
  226.     unsigned int            dest_handle;
  227.     unsigned int            dest_init_offset;
  228.     unsigned int            dest_init_log_page_or_seg;
  229. } MOVE_XCHG_STRUCT;
  230.     #pragma pack()
  231.   
  232.     /*-----------------------------------------------------------------------*/
  233.     /*               Structure:   MAPPABLE_REGION_STRUCT                     */
  234.     /*                                                                       */
  235.     /*   Required by Functions:   get_mappable_conv_regions                  */
  236.     /*                            get_mappable_exp_regions                   */
  237.     /*                            get_mappable_regions                       */
  238.     /*-----------------------------------------------------------------------*/
  239.     #pragma pack(1)
  240. typedef struct
  241. {
  242.     unsigned int            mappable_region_seg;
  243.     unsigned int            phys_page;
  244. } MAPPABLE_REGION_STRUCT;
  245.     #pragma pack()
  246.   
  247.     /*-----------------------------------------------------------------------*/
  248.     /*               Structure:   HW_INFO_STRUCT                             */
  249.     /*                                                                       */
  250.     /*   Required by Functions:   get_hw_info                                */
  251.     /*-----------------------------------------------------------------------*/
  252.     #pragma pack(1)
  253. typedef struct
  254. {
  255.     unsigned int            raw_page_size_paragraphs;
  256.     unsigned int            alt_reg_set_count;
  257.     unsigned int            context_size;
  258.     unsigned int            DMA_reg_set_count;
  259.     unsigned int            DMA_channel_operation;
  260. } HW_INFO_STRUCT;
  261.     #pragma pack()
  262.   
  263. /*===========================================================================*/
  264. /*                          EMM FUNCTION PROTOTYPES                          */
  265. /*===========================================================================*/
  266.     /*-----------------------------------------------------------------------*/
  267.     /*   unsigned int status;                                                */
  268.     /*                                                                       */
  269.     /*   status = EMM_installed ();                                          */
  270.     /*-----------------------------------------------------------------------*/
  271. unsigned int EMM_installed  (void);
  272.   
  273.     /*-----------------------------------------------------------------------*/
  274.     /*   unsigned int status;                                                */
  275.     /*                                                                       */
  276.     /*   status = get_EMM_status ();                                         */
  277.     /*-----------------------------------------------------------------------*/
  278. unsigned int get_EMM_status (void);
  279.   
  280.     /*-----------------------------------------------------------------------*/
  281.     /*   unsigned int status,                                                */
  282.     /*                page_frame_seg;                                        */
  283.     /*                                                                       */
  284.     /*   status = get_page_frame_seg (&page_frame_seg);                      */
  285.     /*-----------------------------------------------------------------------*/
  286. unsigned int get_page_frame_seg (unsigned int far *);
  287.   
  288.     /*-----------------------------------------------------------------------*/
  289.     /*   unsigned int status,                                                */
  290.     /*                unalloc_page_count;                                    */
  291.     /*                                                                       */
  292.     /*   status = get_unalloc_page_count (&unalloc_page_count);              */
  293.     /*-----------------------------------------------------------------------*/
  294. unsigned int get_unalloc_page_count (unsigned int far *);
  295.   
  296.     /*-----------------------------------------------------------------------*/
  297.     /*   unsigned int status,                                                */
  298.     /*                alloc_page_count;                                      */
  299.     /*                                                                       */
  300.     /*   status = get_alloc_page_count (&alloc_page_count);                  */
  301.     /*-----------------------------------------------------------------------*/
  302. unsigned int get_alloc_page_count   (unsigned int far *);
  303.   
  304.     /*-----------------------------------------------------------------------*/
  305.     /*   unsigned int status,                                                */
  306.     /*                total_page_count;                                      */
  307.     /*                                                                       */
  308.     /*   status = get_total_page_count (&total_page_count);                  */
  309.     /*-----------------------------------------------------------------------*/
  310. unsigned int get_total_page_count   (unsigned int far *);
  311.   
  312.     /*-----------------------------------------------------------------------*/
  313.     /*   unsigned int status,                                                */
  314.     /*                pages,                                                 */
  315.     /*                handle;                                                */
  316.     /*                                                                       */
  317.     /*   status = alloc_pages (pages,                                        */
  318.     /*                         &handle);                                     */
  319.     /*-----------------------------------------------------------------------*/
  320. unsigned int alloc_pages    (unsigned int,
  321. unsigned int far *);
  322.   
  323.     /*-----------------------------------------------------------------------*/
  324.     /*   unsigned int status,                                                */
  325.     /*                phys_page,                                             */
  326.     /*                log_page,                                              */
  327.     /*                handle;                                                */
  328.     /*                                                                       */
  329.     /*   status = map_unmap_page (phys_page,                                 */
  330.     /*                            log_page,                                  */
  331.     /*                            handle);                                   */
  332.     /*-----------------------------------------------------------------------*/
  333. unsigned int map_unmap_page (unsigned int,
  334. unsigned int,
  335. unsigned int);
  336.   
  337.     /*-----------------------------------------------------------------------*/
  338.     /*   unsigned int status,                                                */
  339.     /*                handle;                                                */
  340.     /*                                                                       */
  341.     /*   status = dealloc_pages (handle);                                    */
  342.     /*-----------------------------------------------------------------------*/
  343. unsigned int dealloc_pages  (unsigned int);
  344.   
  345.     /*-----------------------------------------------------------------------*/
  346.     /*   unsigned int status,                                                */
  347.     /*                version;                                               */
  348.     /*                                                                       */
  349.     /*   status = get_EMM_version (&version);                                */
  350.     /*-----------------------------------------------------------------------*/
  351. unsigned int get_EMM_version    (unsigned int far *);
  352.   
  353.     /*-----------------------------------------------------------------------*/
  354.     /*   unsigned int status,                                                */
  355.     /*                handle;                                                */
  356.     /*                                                                       */
  357.     /*   status = save_context (handle);                                     */
  358.     /*-----------------------------------------------------------------------*/
  359. unsigned int save_context (unsigned int);
  360.   
  361.     /*-----------------------------------------------------------------------*/
  362.     /*   unsigned int status,                                                */
  363.     /*                handle;                                                */
  364.     /*                                                                       */
  365.     /*   status = restore_context (handle);                                  */
  366.     /*-----------------------------------------------------------------------*/
  367. unsigned int restore_context    (unsigned int);
  368.   
  369.     /*-----------------------------------------------------------------------*/
  370.     /*   unsigned int status,                                                */
  371.     /*                handle_count;                                          */
  372.     /*                                                                       */
  373.     /*   status = get_handle_count (&handle_count);                          */
  374.     /*-----------------------------------------------------------------------*/
  375. unsigned int get_handle_count   (unsigned int far *);
  376.   
  377.     /*-----------------------------------------------------------------------*/
  378.     /*   unsigned int status,                                                */
  379.     /*                pages_alloc_to_handle,                                 */
  380.     /*                handle;                                                */
  381.     /*                                                                       */
  382.     /*   status = get_handle_pages (&pages_alloc_to_handle,                  */
  383.     /*                              handle);                                 */
  384.     /*-----------------------------------------------------------------------*/
  385. unsigned int get_handle_pages   (unsigned int far *,
  386. unsigned int);
  387.   
  388.     /*-----------------------------------------------------------------------*/
  389.     /*   unsigned             int status,                                    */
  390.     /*                        hp_count;                                      */
  391.     /*   HANDLES_PAGES_STRUCT hp [MAX_HANDLES];                              */
  392.     /*                                                                       */
  393.     /*   status = get_all_handles_pages (&hp_count,                          */
  394.     /*                                   hp);                                */
  395.     /*-----------------------------------------------------------------------*/
  396. unsigned int get_all_handles_pages  (unsigned int far *,
  397. HANDLES_PAGES_STRUCT far *);
  398.   
  399.     /*-----------------------------------------------------------------------*/
  400.     /*   unsigned int   status;                                              */
  401.     /*   CONTEXT_STRUCT dest_context;                                        */
  402.     /*                                                                       */
  403.     /*   status = get_context (&dest_context);                               */
  404.     /*-----------------------------------------------------------------------*/
  405. unsigned int get_context    (CONTEXT_STRUCT far *);
  406.   
  407.     /*-----------------------------------------------------------------------*/
  408.     /*   unsigned int   status;                                              */
  409.     /*   CONTEXT_STRUCT source_context;                                      */
  410.     /*                                                                       */
  411.     /*   status = set_context (&source_context);                             */
  412.     /*-----------------------------------------------------------------------*/
  413. unsigned int set_context    (CONTEXT_STRUCT far *);
  414.   
  415.     /*-----------------------------------------------------------------------*/
  416.     /*   unsigned int   status;                                              */
  417.     /*   CONTEXT_STRUCT dest_context;                                        */
  418.     /*   CONTEXT_STRUCT source_context;                                      */
  419.     /*                                                                       */
  420.     /*   status = get_set_context (&dest_context,                            */
  421.     /*                             &source_context);                         */
  422.     /*-----------------------------------------------------------------------*/
  423. unsigned int get_set_context    (CONTEXT_STRUCT far *,
  424. CONTEXT_STRUCT far *);
  425.   
  426.     /*-----------------------------------------------------------------------*/
  427.     /*   unsigned int status,                                                */
  428.     /*                context_size;                                          */
  429.     /*                                                                       */
  430.     /*   status = get_context_size (&context_size);                          */
  431.     /*-----------------------------------------------------------------------*/
  432. unsigned int get_context_size   (unsigned int far *);
  433.   
  434.     /*-----------------------------------------------------------------------*/
  435.     /*   unsigned int                status;                                 */
  436.     /*   PARTIAL_CONTEXT_LIST_STRUCT pcl;                                    */
  437.     /*   CONTEXT_STRUCT              dest_context;                           */
  438.     /*                                                                       */
  439.     /*   pcl.mappable_region_count = 2;                                      */
  440.     /*   pcl.mappable_region_seg   = 0xC000;                                 */
  441.     /*   pcl.mappable_region_seg   = 0xC400;                                 */
  442.     /*   status = get_partial_context (&pcl,                                 */
  443.     /*                                 &dest_context);                       */
  444.     /*-----------------------------------------------------------------------*/
  445. unsigned int get_partial_context    (PARTIAL_CONTEXT_LIST_STRUCT far *,
  446. CONTEXT_STRUCT far *);
  447.   
  448.     /*-----------------------------------------------------------------------*/
  449.     /*   unsigned int   status;                                              */
  450.     /*   CONTEXT_STRUCT source_context;                                      */
  451.     /*                                                                       */
  452.     /*   status = set_partial_context (&source_context);                     */
  453.     /*-----------------------------------------------------------------------*/
  454. unsigned int set_partial_context    (CONTEXT_STRUCT far *);
  455.   
  456.     /*-----------------------------------------------------------------------*/
  457.     /*   unsigned int                status,                                 */
  458.     /*                               partial_context_size;                   */
  459.     /*   PARTIAL_CONTEXT_LIST_STRUCT pcl;                                    */
  460.     /*                                                                       */
  461.     /*   pcl.mappable_region_count = 2;                                      */
  462.     /*   status = get_partial_context_size (pcl.mappable_region_count,       */
  463.     /*                                      &partial_context_size);          */
  464.     /*-----------------------------------------------------------------------*/
  465. unsigned int get_partial_context_size   (unsigned int,
  466. unsigned int far *);
  467.   
  468.     /*-----------------------------------------------------------------------*/
  469.     /*   unsigned int status,                                                */
  470.     /*                mode,                                                  */
  471.     /*                mu_count,                                              */
  472.     /*                handle;                                                */
  473.     /*   MAP_STRUCT   mu [MAX_MAPPABLE_REGIONS];                             */
  474.     /*                                                                       */
  475.     /*   mode                   = SEG_MODE;                                  */
  476.     /*   mu_count               = 2;                                         */
  477.     /*   mu[0].log_page         = 0;                                         */
  478.     /*   mu[0].phys_page_or_seg = 0xC000;                                    */
  479.     /*   mu[1].log_page         = 1;                                         */
  480.     /*   mu[1].phys_page_or_seg = 0xC400;                                    */
  481.     /*   status = map_unmap_pages (mode,                                     */
  482.     /*                             mu_count,                                 */
  483.     /*                             mu,                                       */
  484.     /*                             handle);                                  */
  485.     /*-----------------------------------------------------------------------*/
  486. unsigned int map_unmap_pages    (unsigned int,
  487. unsigned int,
  488. MAP_STRUCT far *,
  489. unsigned int);
  490.   
  491.     /*-----------------------------------------------------------------------*/
  492.     /*   unsigned int status,                                                */
  493.     /*                pages,                                                 */
  494.     /*                handle;                                                */
  495.     /*                                                                       */
  496.     /*   status = realloc_pages (&pages,                                     */
  497.     /*                           handle);                                    */
  498.     /*-----------------------------------------------------------------------*/
  499. unsigned int realloc_pages  (unsigned int far *,
  500. unsigned int);
  501.   
  502.     /*-----------------------------------------------------------------------*/
  503.     /*   unsigned int status,                                                */
  504.     /*                attrib,                                                */
  505.     /*                handle;                                                */
  506.     /*                                                                       */
  507.     /*   status = get_handle_attrib (&attrib,                                */
  508.     /*                               handle);                                */
  509.     /*-----------------------------------------------------------------------*/
  510. unsigned int get_handle_attrib  (unsigned int far *,
  511. unsigned int);
  512.   
  513.     /*-----------------------------------------------------------------------*/
  514.     /*   unsigned int status,                                                */
  515.     /*                attrib,                                                */
  516.     /*                handle;                                                */
  517.     /*                                                                       */
  518.     /*   attrib = VOLATILE;                                                  */
  519.     /*   status = set_handle_attrib (attrib,                                 */
  520.     /*                               handle);                                */
  521.     /*-----------------------------------------------------------------------*/
  522. unsigned int set_handle_attrib  (unsigned int,
  523. unsigned int);
  524.   
  525.     /*-----------------------------------------------------------------------*/
  526.     /*   unsigned int status,                                                */
  527.     /*                attrib_capability;                                     */
  528.     /*                                                                       */
  529.     /*   status = get_attrib_capability (&attrib_capability);                */
  530.     /*-----------------------------------------------------------------------*/
  531. unsigned int get_attrib_capability  (unsigned int far *);
  532.   
  533.     /*-----------------------------------------------------------------------*/
  534.     /*   unsigned int       status,                                          */
  535.     /*                      handle;                                          */
  536.     /*   HANDLE_NAME_STRUCT hn;                                              */
  537.     /*                                                                       */
  538.     /*   status = get_handle_name (&hn,                                      */
  539.     /*                             handle);                                  */
  540.     /*-----------------------------------------------------------------------*/
  541. unsigned int get_handle_name    (HANDLE_NAME_STRUCT far *,
  542. unsigned int);
  543.   
  544.     /*-----------------------------------------------------------------------*/
  545.     /*   unsigned int       status,                                          */
  546.     /*                      handle;                                          */
  547.     /*   HANDLE_NAME_STRUCT hn;                                              */
  548.     /*                                                                       */
  549.     /*   status = set_handle_name (&hn,                                      */
  550.     /*                             handle);                                  */
  551.     /*-----------------------------------------------------------------------*/
  552. unsigned int set_handle_name    (HANDLE_NAME_STRUCT far *,
  553. unsigned int);
  554.   
  555.     /*-----------------------------------------------------------------------*/
  556.     /*   unsigned int      status,                                           */
  557.     /*                     hd_count;                                         */
  558.     /*   HANDLE_DIR_STRUCT hd [MAX_HANDLES];                                 */
  559.     /*                                                                       */
  560.     /*   status = get_handle_dir (&hd_count,                                 */
  561.     /*                            hd);                                       */
  562.     /*-----------------------------------------------------------------------*/
  563. unsigned int get_handle_dir (unsigned int far *,
  564. HANDLE_DIR_STRUCT far *);
  565.   
  566.     /*-----------------------------------------------------------------------*/
  567.     /*   unsigned int       status,                                          */
  568.     /*                      handle;                                          */
  569.     /*   HANDLE_NAME_STRUCT hn;                                              */
  570.     /*                                                                       */
  571.     /*   status = search_handle_name (&hn,                                   */
  572.     /*                                &handle);                              */
  573.     /*-----------------------------------------------------------------------*/
  574. unsigned int search_handle_name (HANDLE_NAME_STRUCT far *,
  575. unsigned int far *);
  576.   
  577.     /*-----------------------------------------------------------------------*/
  578.     /*   unsigned int status,                                                */
  579.     /*                max_handle_count;                                      */
  580.     /*                                                                       */
  581.     /*   status = get_total_handles (&max_handle_count);                     */
  582.     /*-----------------------------------------------------------------------*/
  583. unsigned int get_total_handles  (unsigned int far *);
  584.   
  585.     /*-----------------------------------------------------------------------*/
  586.     /*   unsigned int    status,                                             */
  587.     /*                   mode,                                               */
  588.     /*                   handle;                                             */
  589.     /*   MAP_STRUCT      m [MAX_MAPPABLE_REGIONS];                           */
  590.     /*   MAP_JUMP_STRUCT mj;                                                 */
  591.     /*                                                                       */
  592.     /*   m[0].log_page         = 0;                                          */
  593.     /*   m[0].phys_page_or_seg = 0xC000;                                     */
  594.     /*   m[1].log_page         = 1;                                          */
  595.     /*   m[1].phys_page_or_seg = 0xC400;                                     */
  596.     /*   m[2].log_page         = 2;                                          */
  597.     /*   m[2].phys_page_or_seg = 0xC800;                                     */
  598.     /*   m[3].log_page         = 3;                                          */
  599.     /*   m[3].phys_page_or_seg = 0xCC00;                                     */
  600.     /*                                                                       */
  601.     /*   mode                = SEG_MODE;                                     */
  602.     /*   mj.target_function  = 0xC0000000;                                   */
  603.     /*   mj.map_struct_count = 4;                                            */
  604.     /*   mj.ptr_map_struct   = m;                                            */
  605.     /*                                                                       */
  606.     /*   status = alter_map_jump (mode,                                      */
  607.     /*                            &mj,                                       */
  608.     /*                            handle);                                   */
  609.     /*-----------------------------------------------------------------------*/
  610. unsigned int alter_map_jump (unsigned int,
  611. MAP_JUMP_STRUCT far *,
  612. unsigned int);
  613.   
  614.     /*-----------------------------------------------------------------------*/
  615.     /*   unsigned int    status,                                             */
  616.     /*                   mode,                                               */
  617.     /*                   handle;                                             */
  618.     /*   MAP_STRUCT      init_map  [MAX_MAPPABLE_REGIONS];                   */
  619.     /*   MAP_STRUCT      final_map [MAX_MAPPABLE_REGIONS];                   */
  620.     /*   MAP_CALL_STRUCT mc;                                                 */
  621.     /*                                                                       */
  622.     /*   imit_map[0].log_page          = 0;                                  */
  623.     /*   init_map[0].phys_page_or_seg  = 0xC000;                             */
  624.     /*                                                                       */
  625.     /*   final_map[0].log_page         = 1;                                  */
  626.     /*   final_map[0].phys_page_or_seg = 0xC000;                             */
  627.     /*   final_map[1].log_page         = 2;                                  */
  628.     /*   final_map[1].phys_page_or_seg = 0xC400;                             */
  629.     /*                                                                       */
  630.     /*   mode = SEG_MODE;                                                    */
  631.     /*   mc.target_function        = 0xC0000000;                             */
  632.     /*   mc.init_map_struct_count  = 1;                                      */
  633.     /*   mc.ptr_init_map_struct    = init_map;                               */
  634.     /*   mc.final_map_struct_count = 2;                                      */
  635.     /*   mc.ptr_final_map_struct   = final_map;                              */
  636.     /*                                                                       */
  637.     /*   status = alter_map_call (mode,                                      */
  638.     /*                            &mc,                                       */
  639.     /*                            handle);                                   */
  640.     /*-----------------------------------------------------------------------*/
  641. unsigned int alter_map_call (unsigned int,
  642. MAP_CALL_STRUCT far *,
  643. unsigned int);
  644.   
  645.     /*-----------------------------------------------------------------------*/
  646.     /*   unsigned int status,                                                */
  647.     /*                call_stack_space_size;                                 */
  648.     /*                                                                       */
  649.     /*   status = get_alter_map_call_stack_size (&call_stack_space_size);    */
  650.     /*-----------------------------------------------------------------------*/
  651. unsigned int get_alter_map_call_stack_size  (unsigned int far *);
  652.   
  653.     /*-----------------------------------------------------------------------*/
  654.     /*   unsigned int     status;                                            */
  655.     /*   MOVE_XCHG_STRUCT ms;                                                */
  656.     /*                                                                       */
  657.     /*   ms.region_size                 = 640 * 1024;                        */
  658.     /*   ms.source_mem_type             = CONV_MEM;                          */
  659.     /*   ms.source_init_log_page_or_seg = 0x0000;                            */
  660.     /*   ms.source_init_offset          = 0x0000;                            */
  661.     /*   ms.dest_mem_type               = EXP_MEM;                           */
  662.     /*   ms.dest_handle                 = 1;                                 */
  663.     /*   ms.dest_init_log_page_or_seg   = 0;                                 */
  664.     /*   ms.dest_init_offset            = 0x0000;                            */
  665.     /*                                                                       */
  666.     /*   status = move_memory_region (&ms);                                  */
  667.     /*-----------------------------------------------------------------------*/
  668. unsigned int move_memory_region         (MOVE_XCHG_STRUCT far *);
  669.   
  670.     /*-----------------------------------------------------------------------*/
  671.     /*   unsigned int     status;                                            */
  672.     /*   MOVE_XCHG_STRUCT xs;                                                */
  673.     /*                                                                       */
  674.     /*   xs.region_size                 = 640 * 1024;                        */
  675.     /*   xs.source_mem_type             = EXP_MEM;                           */
  676.     /*   xs.source_handle               = 1;                                 */
  677.     /*   xs.source_init_log_page_or_seg = 0;                                 */
  678.     /*   xs.source_init_offset          = 0x0000;                            */
  679.     /*   xs.dest_mem_type               = CONV_MEM;                          */
  680.     /*   xs.dest_init_log_page_or_seg   = 0x0000;                            */
  681.     /*   xs.dest_init_offset            = 0x0000;                            */
  682.     /*                                                                       */
  683.     /*   status = xchg_memory_region (&xs);                                  */
  684.     /*-----------------------------------------------------------------------*/
  685. unsigned int xchg_memory_region         (MOVE_XCHG_STRUCT far *);
  686.   
  687.     /*-----------------------------------------------------------------------*/
  688.     /*   unsigned int           status,                                      */
  689.     /*                          mcr_count;                                   */
  690.     /*   MAPPABLE_REGION_STRUCT mcr [MAX_MAPPABLE_REGIONS];                  */
  691.     /*                                                                       */
  692.     /*   status = get_mappable_conv_regions (&mcr_count,                     */
  693.     /*                                       mcr);                           */
  694.     /*-----------------------------------------------------------------------*/
  695. unsigned int get_mappable_conv_regions  (unsigned int far *,
  696. MAPPABLE_REGION_STRUCT far *);
  697.   
  698.     /*-----------------------------------------------------------------------*/
  699.     /*   unsigned int           status,                                      */
  700.     /*                          mer_count;                                   */
  701.     /*   MAPPABLE_REGION_STRUCT mer [MAX_MAPPABLE_REGIONS];                  */
  702.     /*                                                                       */
  703.     /*   status = get_mappable_exp_regions (&mer_count,                      */
  704.     /*                                      mer);                            */
  705.     /*-----------------------------------------------------------------------*/
  706. unsigned int get_mappable_exp_regions       (unsigned int far *,
  707. MAPPABLE_REGION_STRUCT far *);
  708.   
  709.     /*-----------------------------------------------------------------------*/
  710.     /*   unsigned int           status,                                      */
  711.     /*                          mr_count;                                    */
  712.     /*   MAPPABLE_REGION_STRUCT mr [MAX_MAPPABLE_REGIONS];                   */
  713.     /*                                                                       */
  714.     /*   status = get_mappable_regions (&mr_count,                           */
  715.     /*                                  mr);                                 */
  716.     /*-----------------------------------------------------------------------*/
  717. unsigned int get_mappable_regions           (unsigned int far *,
  718. MAPPABLE_REGION_STRUCT far *);
  719.   
  720.     /*-----------------------------------------------------------------------*/
  721.     /*   unsigned int status,                                                */
  722.     /*                mcr_count;                                             */
  723.     /*                                                                       */
  724.     /*   status = get_mappable_conv_region_count (&mcr_count);               */
  725.     /*-----------------------------------------------------------------------*/
  726. unsigned int get_mappable_conv_region_count (unsigned int far *);
  727.   
  728.     /*-----------------------------------------------------------------------*/
  729.     /*   unsigned int status,                                                */
  730.     /*                mer_count;                                             */
  731.     /*                                                                       */
  732.     /*   status = get_mappable_exp_region_count (&mer_count);                */
  733.     /*-----------------------------------------------------------------------*/
  734. unsigned int get_mappable_exp_region_count  (unsigned int far *);
  735.   
  736.     /*-----------------------------------------------------------------------*/
  737.     /*   unsigned int status,                                                */
  738.     /*                mr_count;                                              */
  739.     /*                                                                       */
  740.     /*   status = get_mappable_region_count (&mr_count);                     */
  741.     /*-----------------------------------------------------------------------*/
  742. unsigned int get_mappable_region_count  (unsigned int far *);
  743.   
  744.     /*-----------------------------------------------------------------------*/
  745.     /*   unsigned int status,                                                */
  746.     /*                pf_count;                                              */
  747.     /*                                                                       */
  748.     /*   status = get_page_frame_count (&pf_count);                          */
  749.     /*-----------------------------------------------------------------------*/
  750. unsigned int get_page_frame_count   (unsigned int far *);
  751.   
  752.     /*-----------------------------------------------------------------------*/
  753.     /*   unsigned int   status                                               */
  754.     /*   HW_INFO_STRUCT hw_info;                                             */
  755.     /*                                                                       */
  756.     /*   status = get_hw_info (&hw_info);                                    */
  757.     /*-----------------------------------------------------------------------*/
  758. unsigned int get_hw_info                    (HW_INFO_STRUCT far *);
  759.   
  760.     /*-----------------------------------------------------------------------*/
  761.     /*   unsigned int status,                                                */
  762.     /*                unalloc_raw_pages;                                     */
  763.     /*                                                                       */
  764.     /*   status = get_unalloc_raw_page_count (&unalloc_raw_pages);           */
  765.     /*-----------------------------------------------------------------------*/
  766. unsigned int get_unalloc_raw_page_count (unsigned int far *);
  767.   
  768.     /*-----------------------------------------------------------------------*/
  769.     /*   unsigned int status,                                                */
  770.     /*                alloc_raw_pages;                                       */
  771.     /*                                                                       */
  772.     /*   status = get_alloc_raw_page_count (&alloc_raw_pages);               */
  773.     /*-----------------------------------------------------------------------*/
  774. unsigned int get_alloc_raw_page_count       (unsigned int far *);
  775.   
  776.     /*-----------------------------------------------------------------------*/
  777.     /*   unsigned int status,                                                */
  778.     /*                total_raw_pages;                                       */
  779.     /*                                                                       */
  780.     /*   status = get_total_raw_page_count (&total_raw_pages);               */
  781.     /*-----------------------------------------------------------------------*/
  782. unsigned int get_total_raw_page_count       (unsigned int far *);
  783.   
  784.     /*-----------------------------------------------------------------------*/
  785.     /*   unsigned int status,                                                */
  786.     /*                std_page_count,                                        */
  787.     /*                handle;                                                */
  788.     /*                                                                       */
  789.     /*   status = alloc_std_pages (std_page_count,                           */
  790.     /*                             &handle);                                 */
  791.     /*-----------------------------------------------------------------------*/
  792. unsigned int alloc_std_pages                (unsigned int,
  793. unsigned int far *);
  794.   
  795.     /*-----------------------------------------------------------------------*/
  796.     /*   unsigned int status,                                                */
  797.     /*                raw_page_count,                                        */
  798.     /*                handle;                                                */
  799.     /*                                                                       */
  800.     /*   status = alloc_raw_pages (raw_page_count,                           */
  801.     /*                             &handle);                                 */
  802.     /*-----------------------------------------------------------------------*/
  803. unsigned int alloc_raw_pages                (unsigned int,
  804. unsigned int far *);
  805.   
  806.     /*-----------------------------------------------------------------------*/
  807.     /*   unsigned int       status,                                          */
  808.     /*                      alt_reg_set;                                     */
  809.     /*   CONTEXT_STRUCT far *far_ptr_alt_context;                            */
  810.     /*                                                                       */
  811.     /*   status = get_alt_reg_set (&alt_reg_set,                             */
  812.     /*                             &far_ptr_alt_context);                    */
  813.     /*-----------------------------------------------------------------------*/
  814. unsigned int get_alt_reg_set        (unsigned int far *,
  815. CONTEXT_STRUCT far * far *);
  816.   
  817.     /*-----------------------------------------------------------------------*/
  818.     /*   unsigned int          status,                                       */
  819.     /*                         alt_reg_set;                                  */
  820.     /*   static CONTEXT_STRUCT alt_context;                                  */
  821.     /*                                                                       */
  822.     /*   status = set_alt_reg_set (alt_reg_set,                              */
  823.     /*                             &alt_context);                            */
  824.     /*-----------------------------------------------------------------------*/
  825. unsigned int set_alt_reg_set        (unsigned int,
  826. CONTEXT_STRUCT far *);
  827.   
  828.     /*-----------------------------------------------------------------------*/
  829.     /*   unsigned int status,                                                */
  830.     /*                context_size;                                          */
  831.     /*                                                                       */
  832.     /*   status = get_alt_context_size (&context_size);                      */
  833.     /*-----------------------------------------------------------------------*/
  834. unsigned int get_alt_context_size   (unsigned int far *);
  835.   
  836.     /*-----------------------------------------------------------------------*/
  837.     /*   unsigned int status,                                                */
  838.     /*                alt_reg_set;                                           */
  839.     /*                                                                       */
  840.     /*   status = alloc_alt_reg_set (&alt_reg_set);                          */
  841.     /*-----------------------------------------------------------------------*/
  842. unsigned int alloc_alt_reg_set  (unsigned int far *);
  843.   
  844.     /*-----------------------------------------------------------------------*/
  845.     /*   unsigned int status,                                                */
  846.     /*                alt_reg_set;                                           */
  847.     /*                                                                       */
  848.     /*   status = dealloc_alt_reg_set (alt_reg_set);                         */
  849.     /*-----------------------------------------------------------------------*/
  850. unsigned int dealloc_alt_reg_set    (unsigned int);
  851.   
  852.     /*-----------------------------------------------------------------------*/
  853.     /*   unsigned int status,                                                */
  854.     /*                DMA_reg_set;                                           */
  855.     /*                                                                       */
  856.     /*   status = alloc_DMA_reg_set (&DMA_reg_set);                          */
  857.     /*-----------------------------------------------------------------------*/
  858. unsigned int alloc_DMA_reg_set  (unsigned int far *);
  859.   
  860.     /*-----------------------------------------------------------------------*/
  861.     /*   unsigned int status,                                                */
  862.     /*                DMA_reg_set,                                           */
  863.     /*                DMA_channel;                                           */
  864.     /*                                                                       */
  865.     /*   status = enable_DMA_reg_set (DMA_reg_set,                           */
  866.     /*                                DMA_channel);                          */
  867.     /*-----------------------------------------------------------------------*/
  868. unsigned int enable_DMA_reg_set (unsigned int,
  869. unsigned int);
  870.   
  871.     /*-----------------------------------------------------------------------*/
  872.     /*   unsigned int status,                                                */
  873.     /*                DMA_reg_set;                                           */
  874.     /*                                                                       */
  875.     /*   status = disable_DMA_reg_set (DMA_reg_set);                         */
  876.     /*-----------------------------------------------------------------------*/
  877. unsigned int disable_DMA_reg_set    (unsigned int);
  878.   
  879.     /*-----------------------------------------------------------------------*/
  880.     /*   unsigned int status,                                                */
  881.     /*                DMA_reg_set;                                           */
  882.     /*                                                                       */
  883.     /*   status = dealloc_DMA_reg_set (DMA_reg_set);                         */
  884.     /*-----------------------------------------------------------------------*/
  885. unsigned int dealloc_DMA_reg_set    (unsigned int);
  886.   
  887.     /*-----------------------------------------------------------------------*/
  888.     /*   unsigned int status;                                                */
  889.     /*                                                                       */
  890.     /*   status = prep_EMM_warmboot();                                       */
  891.     /*-----------------------------------------------------------------------*/
  892. unsigned int prep_EMM_warmboot      (void);
  893.   
  894.     /*-----------------------------------------------------------------------*/
  895.     /*   unsigned int  status;                                               */
  896.     /*   unsigned long access_key;                                           */
  897.     /*                                                                       */
  898.     /*   status = enable_OS_fcns (&access_key);                              */
  899.     /*-----------------------------------------------------------------------*/
  900. unsigned int enable_OS_fcns         (unsigned long far *);
  901.   
  902.     /*-----------------------------------------------------------------------*/
  903.     /*   unsigned int  status                                                */
  904.     /*   unsigned long access_key;                                           */
  905.     /*                                                                       */
  906.     /*   status = disable_OS_fcns (&access_key);                             */
  907.     /*-----------------------------------------------------------------------*/
  908. unsigned int disable_OS_fcns            (unsigned long far *);
  909.   
  910.     /*-----------------------------------------------------------------------*/
  911.     /*   unsigned int  status                                                */
  912.     /*   unsigned long access_key;                                           */
  913.     /*                                                                       */
  914.     /*   status = return_OS_access_key (access_key);                         */
  915.     /*-----------------------------------------------------------------------*/
  916. unsigned int return_OS_access_key       (unsigned long far *);
  917.   
  918.