dlls/krnl386.exe16/int67.c

   1 /*
   2  * Int67 (EMS) emulation
   3  *
   4  * Copyright 2002 Jukka Heinonen
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include "wine/winbase16.h"
  23 #include "dosexe.h"
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(int);
  27
  28 /*
  29  * EMS page size == 16 kilobytes.
  30  */
  31 #define EMS_PAGE_SIZE (16*1024)
  32
  33 /*
  34  * Linear address of EMS page.
  35  */
  36 #define EMS_PAGE_ADDRESS(base,page) (((char*)base) + EMS_PAGE_SIZE * page)
  37
  38 /*
  39  * Maximum number of pages that can be allocated using EMS.
  40  */
  41 #define EMS_MAX_PAGES 1024
  42
  43 /*
  44  * Maximum number of EMS handles (allocated blocks).
  45  */
  46 #define EMS_MAX_HANDLES 256
  47
  48 /*
  49  * Global EMM Import Record.
  50  * Applications can get address of this record
  51  * and directly access allocated memory if they use
  52  * IOCTL interface.
  53  *
  54  * FIXME: Missing lots of fields, packing is not correct.
  55  */
  56
  57 static struct {
  58   struct {
  59     UCHAR hindex;  /* handle number */
  60     BYTE  flags;   /* bit 0: normal handle rather than system handle */
  61     char  name[8]; /* handle name */
  62     WORD  pages;   /* allocated pages */
  63     void *address; /* physical address*/
  64   } handle[EMS_MAX_HANDLES];
  65
  66   /* Wine specific fields... */
  67
  68   int   used_pages;     /* Number of allocated pages. */
  69   void *frame_address;  /* Address of 64k EMS page frame */
  70   WORD  frame_selector; /* Segment of 64k EMS page frame */
  71
  72   struct {
  73     UCHAR hindex;       /* handle number */
  74     WORD  logical_page; /* logical page */
  75   } mapping[4];
  76
  77   struct {
  78     UCHAR hindex;       /* handle number */
  79     WORD  logical_page; /* logical page */
  80   } mapping_save_area[EMS_MAX_HANDLES][4];
  81
  82 } *EMS_record;
  83
  84 /**********************************************************************
  85  *          EMS_init
  86  *
  87  * Allocates and initialized page frame and EMS global import record.
  88  */
  89 static void EMS_init(void)
  90 {
  91   /*
  92    * Start of 64k EMS frame.
  93    */
  94   ULONG base = 0xc0000;
  95
  96   if(EMS_record)
  97     return;
  98
  99   EMS_record = HeapAlloc(GetProcessHeap(),
 100                          HEAP_ZERO_MEMORY,
 101                          sizeof(*EMS_record));
 102
 103   EMS_record->frame_address = (void *)base;
 104   EMS_record->frame_selector = base >> 4;
 105 }
 106
 107 /**********************************************************************
 108  *          EMS_alloc
 109  *
 110  * Get handle and allocate memory.
 111  */
 112 static void EMS_alloc( CONTEXT *context )
 113 {
 114   int hindex = 1; /* handle zero is reserved for system */
 115
 116   while(hindex < EMS_MAX_HANDLES && EMS_record->handle[hindex].address)
 117     hindex++;
 118
 119   if(hindex == EMS_MAX_HANDLES) {
 120     SET_AH( context, 0x85 ); /* status: no more handles available */
 121   } else {
 122     int   pages = BX_reg(context);
 123     void *buffer = HeapAlloc( GetProcessHeap(), 0, pages * EMS_PAGE_SIZE );
 124
 125     if(!buffer) {
 126       SET_AH( context, 0x88 ); /* status: insufficient pages available */
 127     } else {
 128       EMS_record->handle[hindex].address = buffer;
 129       EMS_record->handle[hindex].pages = pages;
 130       EMS_record->used_pages += pages;
 131
 132       SET_DX( context, hindex ); /* handle to allocated memory*/
 133       SET_AH( context, 0 );      /* status: ok */
 134     }
 135   }
 136 }
 137
 138 /**********************************************************************
 139  *          EMS_access_name
 140  *
 141  * Get/set handle name.
 142  */
 143 static void EMS_access_name( CONTEXT *context )
 144 {
 145   char *ptr;
 146   int hindex = DX_reg(context);
 147   if(hindex < 0 || hindex >= EMS_MAX_HANDLES) {
 148     SET_AH( context, 0x83 ); /* invalid handle */
 149     return;
 150   }
 151
 152   switch (AL_reg(context)) {
 153   case 0x00: /* get name */
 154     ptr = PTR_REAL_TO_LIN(context->SegEs, DI_reg(context));
 155     memcpy(ptr, EMS_record->handle[hindex].name, 8);
 156     SET_AH( context, 0 );
 157     break;
 158
 159   case 0x01: /* set name */
 160     ptr = PTR_REAL_TO_LIN(context->SegDs, SI_reg(context));
 161     memcpy(EMS_record->handle[hindex].name, ptr, 8);
 162     SET_AH( context, 0 );
 163     break;
 164
 165   default:
 166     INT_BARF(context,0x67);
 167     break;
 168   }
 169 }
 170
 171 /**********************************************************************
 172  *          EMS_map
 173  *
 174  * Map logical page into physical page.
 175  */
 176 static BYTE EMS_map( WORD physical_page, WORD new_hindex, WORD new_logical_page )
 177 {
 178   int   old_hindex;
 179   int   old_logical_page;
 180   void *physical_address;
 181
 182   if(physical_page > 3)
 183     return 0x8b; /* status: invalid physical page */
 184
 185   old_hindex = EMS_record->mapping[physical_page].hindex;
 186   old_logical_page = EMS_record->mapping[physical_page].logical_page;
 187   physical_address = EMS_PAGE_ADDRESS(EMS_record->frame_address, physical_page);
 188
 189   /* unmap old page */
 190   if(old_hindex) {
 191     void *ptr = EMS_PAGE_ADDRESS(EMS_record->handle[old_hindex].address,
 192                                  old_logical_page);
 193     memcpy(ptr, physical_address, EMS_PAGE_SIZE);
 194   }
 195
 196   /* map new page */
 197   if(new_hindex && new_logical_page != 0xffff) {
 198     void *ptr = EMS_PAGE_ADDRESS(EMS_record->handle[new_hindex].address,
 199                                  new_logical_page);
 200
 201     if(new_hindex >= EMS_MAX_HANDLES || !EMS_record->handle[new_hindex].address)
 202       return 0x83; /* status: invalid handle */
 203
 204     if(new_logical_page >= EMS_record->handle[new_hindex].pages)
 205       return 0x8a; /* status: invalid logical page */
 206
 207     memcpy(physical_address, ptr, EMS_PAGE_SIZE);
 208     EMS_record->mapping[physical_page].hindex = new_hindex;
 209     EMS_record->mapping[physical_page].logical_page = new_logical_page;
 210   } else {
 211     EMS_record->mapping[physical_page].hindex = 0;
 212     EMS_record->mapping[physical_page].logical_page = 0;
 213   }
 214
 215   return 0; /* status: ok */
 216 }
 217
 218 /**********************************************************************
 219  *          EMS_map_multiple
 220  *
 221  * Map multiple logical pages into physical pages.
 222  */
 223 static void EMS_map_multiple( CONTEXT *context )
 224 {
 225   WORD *ptr = PTR_REAL_TO_LIN(context->SegDs, SI_reg(context));
 226   BYTE  status = 0;
 227   int   i;
 228
 229   for(i=0; i<CX_reg(context) && !status; i++, ptr += 2)
 230     switch(AL_reg(context)) {
 231     case 0x00:
 232       status = EMS_map( ptr[1],
 233                        DX_reg(context), ptr[0] );
 234       break;
 235     case 0x01:
 236       status = EMS_map( (ptr[1] - EMS_record->frame_selector) >> 10,
 237                        DX_reg(context), ptr[0] );
 238       break;
 239     default:
 240       status = 0x8f; /* status: undefined subfunction */
 241     }
 242
 243   SET_AH( context, status );
 244 }
 245
 246 /**********************************************************************
 247  *          EMS_free
 248  *
 249  * Free memory and release handle.
 250  */
 251 static void EMS_free( CONTEXT *context )
 252 {
 253   int hindex = DX_reg(context);
 254   int i;
 255
 256   if(hindex < 0 || hindex >= EMS_MAX_HANDLES) {
 257     SET_AH( context, 0x83 ); /* status: invalid handle */
 258     return;
 259   }
 260
 261   if(!EMS_record->handle[hindex].address) {
 262     SET_AH( context, 0 ); /* status: ok */
 263     return;
 264   }
 265
 266   EMS_record->used_pages -= EMS_record->handle[hindex].pages;
 267
 268   /* unmap pages */
 269   for(i=0; i<4; i++)
 270     if(EMS_record->mapping[i].hindex == hindex)
 271       EMS_record->mapping[i].hindex = 0;
 272
 273   /* free block */
 274   HeapFree( GetProcessHeap(), 0, EMS_record->handle[hindex].address );
 275   EMS_record->handle[hindex].address = 0;
 276
 277   SET_AH( context, 0 );    /* status: ok */
 278 }
 279
 280 /**********************************************************************
 281  *          EMS_save_context
 282  *
 283  * Save physical page mappings into handle specific save area.
 284  */
 285 static void EMS_save_context( CONTEXT *context )
 286 {
 287   WORD h = DX_reg(context);
 288   int  i;
 289
 290   for(i=0; i<4; i++) {
 291     EMS_record->mapping_save_area[h][i].hindex = EMS_record->mapping[i].hindex;
 292     EMS_record->mapping_save_area[h][i].logical_page = EMS_record->mapping[i].logical_page;
 293   }
 294
 295   SET_AX( context, 0 ); /* status: ok */
 296 }
 297
 298
 299 /**********************************************************************
 300  *          EMS_restore_context
 301  *
 302  * Restore physical page mappings from handle specific save area.
 303  */
 304 static void EMS_restore_context( CONTEXT *context )
 305 {
 306   WORD handle = DX_reg(context);
 307   int  i;
 308
 309   for(i=0; i<4; i++) {
 310     int hindex       = EMS_record->mapping_save_area[handle][i].hindex;
 311     int logical_page = EMS_record->mapping_save_area[handle][i].logical_page;
 312
 313     if(EMS_map( i, hindex, logical_page )) {
 314       SET_AX( context, 0x8e ); /* status: restore of mapping context failed */
 315       return;
 316     }
 317   }
 318
 319   SET_AX( context, 0 ); /* status: ok */
 320 }
 321
 322 /**********************************************************************
 323  *          DOSVM_Int67Handler
 324  *
 325  * Handler for interrupt 67h EMS routines.
 326  */
 327 void WINAPI DOSVM_Int67Handler( CONTEXT *context )
 328 {
 329   switch (AH_reg(context)) {
 330
 331   case 0x40: /* EMS - GET MANAGER STATUS */
 332     SET_AH( context, 0 ); /* status: ok */
 333     break;
 334
 335   case 0x41: /* EMS - GET PAGE FRAME SEGMENT */
 336     EMS_init();
 337     SET_BX( context, EMS_record->frame_selector ); /* segment of page frame */
 338     SET_AH( context, 0 );                          /* status: ok */
 339     break;
 340
 341   case 0x42: /* EMS - GET NUMBER OF PAGES */
 342     EMS_init();
 343     /* unallocated 16k pages */
 344     SET_BX( context, EMS_MAX_PAGES - EMS_record->used_pages );
 345     /* total number of 16k pages */
 346     SET_DX( context, EMS_MAX_PAGES );
 347     /* status: ok */
 348     SET_AH( context, 0 );
 349     break;
 350
 351   case 0x43: /* EMS - GET HANDLE AND ALLOCATE MEMORY */
 352     EMS_init();
 353     EMS_alloc(context);
 354     break;
 355
 356   case 0x44: /* EMS - MAP MEMORY */
 357     EMS_init();
 358     SET_AH( context, EMS_map( AL_reg(context), DX_reg(context), BX_reg(context) ) );
 359     break;
 360
 361   case 0x45: /* EMS - RELEASE HANDLE AND MEMORY */
 362     EMS_init();
 363     EMS_free(context);
 364     break;
 365
 366   case 0x46: /* EMS - GET EMM VERSION */
 367     SET_AL( context, 0x40 ); /* version 4.0 */
 368     SET_AH( context, 0 );    /* status: ok */
 369     break;
 370
 371   case 0x47: /* EMS - SAVE MAPPING CONTEXT */
 372     EMS_init();
 373     EMS_save_context(context);
 374     break;
 375
 376   case 0x48: /* EMS - RESTORE MAPPING CONTEXT */
 377     EMS_init();
 378     EMS_restore_context(context);
 379     break;
 380
 381   case 0x49: /* EMS - reserved - GET I/O PORT ADDRESSES */
 382   case 0x4a: /* EMS - reserved - GET TRANSLATION ARRAY */
 383     INT_BARF(context,0x67);
 384     break;
 385
 386   case 0x4b: /* EMS - GET NUMBER OF EMM HANDLES */
 387     SET_BX( context, EMS_MAX_HANDLES ); /* EMM handles */
 388     SET_AH( context, 0 );               /* status: ok */
 389     break;
 390
 391   case 0x4c: /* EMS - GET PAGES OWNED BY HANDLE */
 392   case 0x4d: /* EMS - GET PAGES FOR ALL HANDLES */
 393   case 0x4e: /* EMS - GET OR SET PAGE MAP */
 394   case 0x4f: /* EMS 4.0 - GET/SET PARTIAL PAGE MAP */
 395     INT_BARF(context,0x67);
 396     break;
 397
 398   case 0x50: /* EMS 4.0 - MAP/UNMAP MULTIPLE HANDLE PAGES */
 399     EMS_init();
 400     EMS_map_multiple(context);
 401     break;
 402
 403   case 0x51: /* EMS 4.0 - REALLOCATE PAGES */
 404   case 0x52: /* EMS 4.0 - GET/SET HANDLE ATTRIBUTES */
 405     INT_BARF(context,0x67);
 406     break;
 407
 408   case 0x53: /* EMS 4.0 - GET/SET HANDLE NAME */
 409     EMS_init();
 410     EMS_access_name(context);
 411     break;
 412
 413   case 0x54: /* EMS 4.0 - GET HANDLE DIRECTORY */
 414   case 0x55: /* EMS 4.0 - ALTER PAGE MAP AND JUMP */
 415   case 0x56: /* EMS 4.0 - ALTER PAGE MAP AND CALL */
 416   case 0x57: /* EMS 4.0 - MOVE/EXCHANGE MEMORY REGION */
 417   case 0x58: /* EMS 4.0 - GET MAPPABLE PHYSICAL ADDRESS ARRAY */
 418     INT_BARF(context,0x67);
 419     break;
 420
 421   case 0x59: /* EMS 4.0 - GET EXPANDED MEMORY HARDWARE INFORMATION */
 422     if(AL_reg(context) == 0x01) {
 423       EMS_init();
 424       /* unallocated raw pages */
 425       SET_BX( context, EMS_MAX_PAGES - EMS_record->used_pages );
 426       /* total number raw pages */
 427       SET_DX( context, EMS_MAX_PAGES );
 428       /* status: ok */
 429       SET_AH( context, 0 );
 430     } else
 431       INT_BARF(context,0x67);
 432     break;
 433
 434   case 0x5a: /* EMS 4.0 - ALLOCATE STANDARD/RAW PAGES */
 435   case 0x5b: /* EMS 4.0 - ALTERNATE MAP REGISTER SET */
 436   case 0x5c: /* EMS 4.0 - PREPARE EXPANDED MEMORY HARDWARE FOR WARM BOOT */
 437   case 0x5d: /* EMS 4.0 - ENABLE/DISABLE OS FUNCTION SET FUNCTIONS */
 438     INT_BARF(context,0x67);
 439     break;
 440
 441   case 0xde: /* Virtual Control Program Interface (VCPI) */
 442     if(AL_reg(context) == 0x00) {
 443       /*
 444        * VCPI INSTALLATION CHECK
 445        * (AH_reg() != 0) means VCPI is not present
 446        */
 447       TRACE("- VCPI installation check\n");
 448       return;
 449     } else
 450       INT_BARF(context,0x67);
 451     break;
 452
 453   default:
 454     INT_BARF(context,0x67);
 455   }
 456 }
 457
 458
 459 /**********************************************************************
 460  *          EMS_Ioctl_Handler
 461  *
 462  * Handler for interrupt 21h IOCTL routine for device "EMMXXXX0".
 463  */
 464 void EMS_Ioctl_Handler( CONTEXT *context )
 465 {
 466   assert(AH_reg(context) == 0x44);
 467
 468   switch (AL_reg(context)) {
 469   case 0x00: /* IOCTL - GET DEVICE INFORMATION */
 470       RESET_CFLAG(context); /* operation was successful */
 471       SET_DX( context, 0x4080 ); /* bit 14 (support ioctl read) and
 472                                  * bit 7 (is_device) */
 473       break;
 474
 475   case 0x02: /* EMS - GET MEMORY MANAGER INFORMATION */
 476       /*
 477        * This is what is called "Windows Global EMM Import Specification".
 478        * Undocumented of course! Supports three requests:
 479        * GET API ENTRY POINT
 480        * GET EMM IMPORT STRUCTURE ADDRESS
 481        * GET MEMORY MANAGER VERSION
 482        */
 483       INT_BARF(context,0x21);
 484       break;
 485
 486   case 0x07: /* IOCTL - GET OUTPUT STATUS */
 487       RESET_CFLAG(context); /* operation was successful */
 488       SET_AL( context, 0xff ); /* device is ready */
 489       break;
 490
 491   default:
 492       INT_BARF(context,0x21);
 493       break;
 494   }
 495 }