xms.c

/*
   XMS driver for DOSMid

   Copyright (c) 2014,2015 Mateusz Viste
   All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/

#include <dos.h>
#include <stdlib.h>

#include "xms.h" /* include self for control */

/* a function pointer to save the XMS driver address */
void far (*xmsdrv)(void);

/* descriptor for XMS moves */
struct xms_move {
  long count;             /* number of bytes to move */
  unsigned int srchandle; /* source handle (0 for real memory) */
  long srcoffset;         /* source offset (or far pointer) */
  unsigned int dsthandle; /* destination handle (0 for real memory) */
  long dstoffset;         /* destination offset (or far pointer) */
};

/* used by xms_push() and xms_pull() to call the xms driver for data copy.
   returns 0 on success, non-zero otherwise */
static int xms_move(struct xms_move far *xmove) {
  unsigned int resax = 0;
  unsigned char resbl = 0;
  __asm {
    push bp                  ; save BP
    push ds                  ; save DS
    push si                  ; save SI
    mov ah, 0x0b             ; xms function is 0x0b
    lds si, [xmove]          ;
    call dword ptr [xmsdrv]  ; call the XMS driver
    pop si                   ; restore original SI
    pop ds                   ; restore original DS
    pop bp                   ; restore original BP
    mov resax, ax            ; save exit status
    mov resbl, bl            ; save result
  }
  /* check result */
  if (resax == 1) return(0);  /* AX = 0001h if the move is successful, 0000h otherwise */
  return(resbl);
}


/* returns the largest available block of free XMS memory */
static unsigned int xms_memfree(void) {
  unsigned int res = 0;
  __asm {
    mov ah, 0x08
    call dword ptr [xmsdrv]  ; call the XMS driver
    mov res, ax              ; AX = Size of the largest free block in K-bytes
  }
  return(res);
}

/* checks if a XMS driver is installed, inits it and allocates a memory block of memsize K-bytes.
 * if memsize is 0, then the maximum possible block will be allocated.
 * returns the amount of allocated memory (in K-bytes) on success, 0 otherwise. */
unsigned int xms_init(struct xms_struct *xms, unsigned int memsize) {
  union REGS regs;
  struct SREGS sregs;
  unsigned int axres = 0, dxres = 0;
  unsigned freemem;
  /* check that an XMS driver is present */
  regs.x.ax = 0x4300;
  int86(0x2F, &regs, &regs);
  if (regs.h.al != 0x80) return(-1);
  /* fetch the driver's API address */
  regs.x.ax = 0x4310;
  int86x(0x2F, &regs, &regs, &sregs);
  xmsdrv = (void far (*)()) MK_FP(sregs.es, regs.x.bx);
  xms->handle = 0;
  xms->memsize = 0;
  /* if memsize is 0, allocate as much as we can */
  freemem = xms_memfree();
  if ((memsize == 0) || (freemem < memsize)) memsize = freemem;
  if (memsize == 0) return(0);
  /* allocate the memory block */
  __asm {
    mov ah, 0x09
    mov dx, memsize
    call dword ptr [xmsdrv]  ; call the XMS driver
    mov dxres, dx
    mov axres, ax
  }
  xms->handle = dxres;
  if (axres != 1) return(0); /* if allocation failed... */
  xms->memsize = memsize;
  xms->memsize <<= 10; /* memsize is in kbytes, but we want to have it in bytes now */
  return(memsize);
}

/* free XMS memory */
void xms_close(struct xms_struct *xms) {
  unsigned int handle;
  handle = xms->handle;
  __asm {
    mov ah, 0x0a
    push dx                   ; save DX
    mov dx, handle            ; DX = Handle to the block to be freed
    call dword ptr [xmsdrv]   ; call the XMS driver
    pop dx;                   ; restore original DX
  }
}

/* copies a chunk of memory from conventional memory into the XMS block.
   returns 0 on sucess, non-zero otherwise. */
int xms_push(struct xms_struct *xms, void far *src, unsigned int len, long xmsoffset) {
  int res;
  struct xms_move xmove, far *ptr;
  ptr = &xmove;
  /* prepare the xms move struct */
  xmove.count = len;
  xmove.srchandle = 0; /* handle == 0 means 'see in conv. memory' */
  xmove.srcoffset = (unsigned long)src;
  xmove.dsthandle = xms->handle;
  xmove.dstoffset = xmsoffset;
  /* call the xms api */
  res = xms_move(ptr);
  return(res);
}

/* copies a chunk of memory from the XMS block into conventional memory.
   returns 0 on success, non-zero otherwise. */
int xms_pull(struct xms_struct *xms, long xmsoffset, void far *dst, unsigned int len) {
  int res;
  struct xms_move xmove, far *ptr;
  ptr = &xmove;
  /* prepare the xms move struct */
  xmove.count = len;
  xmove.srchandle = xms->handle;
  xmove.srcoffset = xmsoffset;
  xmove.dsthandle = 0; /* handle == 0 means 'see in conv. memory' */
  xmove.dstoffset = (unsigned long)dst;
  /* call the xms api */
  res = xms_move(ptr);
  return(res);
}