---

physmem.cc

Go to the documentation of this file.

/***********************************************************************
* File: physmem.cc
* Purpose: Provides the member functions for the PHYSMEM_HANDLE class. This is
* a C++ interface for portable access to physical memory.
* NOTES:
*  On some platforms accessing a block of physical memory is a simple as
* intitializing a pointer and then dereferencing it, but accessing specific
* sections of extended memory under DOS or Windows requires changing the
* descriptor tables and therefore circumventing protected mode security.
* Other platforms require the use of mmap() on memory device files to choose
* a section of memory mapped IO.
***********************************************************************/

#include "rcs_defs.hh"          /* __MSDOS__, RCS_FAR, EXTERN_C_STD_HEADERS  */
#include "dbg_mem.h"            // DEBUG_MALLOC, DEBUG_FREE

#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif


#ifdef UNDER_CE
#include <winbase.h>
#endif

#include <string.h>             /* memcpy(), memset() */
#ifndef NO_STDIO
#include <stdio.h>              // sprintf()
#endif
#include <stdlib.h>             /* malloc() */

#ifdef  lynxosPC

#include <smem.h>
#include <errno.h>

#endif

#ifdef LINUX_VME
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#endif


#ifdef VXWORKS
#include "vxWorks.h"
#include "sysLib.h"             /* sysBusToLocalAdrs() */
#include "vme.h"                /* VME_AM_STD_USR_DATA */
#endif

#ifdef EXTERN_C_STD_HEADERS
}
#endif

#include "physmem.hh"           /* class PHYSMEM_HANDLE */

#if  defined(__MSDOS__) && !defined(__WIN32__)
#include "_physmem.h"           /* read_physmem(), write_physmem(), */
                                /* create_ptr_to_physmem() */
#endif


#include "rcs_prnt.hh"

/* Constructor. */
PHYSMEM_HANDLE::PHYSMEM_HANDLE ()
{
  size = 0;
  offset = 0;
  temp_buf = NULL;
  local_address = (LOCAL_ADDRESS_TYPE) NULL;
  physical_address = 0;
  using_bit3 = 0;
  isvalid = 1;
#if defined(USE_BIT3) && defined(WIN32)
  swap_mode = 0;
  bt_lock_timeout = BT_FOREVER;
  bt_use_lock = 0;
#endif
  total_bytes_moved = 0;
  enable_byte_counting = 0;

}

#if defined(USE_BIT3) && defined(WIN32)

PHYSMEM_HANDLE::PHYSMEM_HANDLE (bt_desc_t _btd, unsigned long _btd_offset,
                                long _size, int _swap_mode)
{
  size = _size;
  temp_buf = NULL;
  offset = 0;
  btd = _btd;
  btd_offset = _btd_offset;
  swap_mode = _swap_mode;
  using_bit3 = 1;
  local_address = (LOCAL_ADDRESS_TYPE) NULL;
  physical_address = 0;
  bt_lock_timeout = BT_FOREVER;
  bt_use_lock = 0;
};

#endif

PHYSMEM_HANDLE::PHYSMEM_HANDLE (unsigned long _physical_address,
                                long _address_code, long _size)
{
  temp_buf = NULL;
  physical_address = _physical_address;
  size = _size;
  address_code = _address_code;
  local_address = (LOCAL_ADDRESS_TYPE) NULL;
  isvalid = 1;
  offset = 0;
  using_bit3 = 0;
#if defined(USE_BIT3) && defined(WIN32)
  swap_mode = 0;
  bt_lock_timeout = BT_FOREVER;
  bt_use_lock = 0;
#endif

  if (0 == physical_address)
    {
      local_address = (LOCAL_ADDRESS_TYPE) NULL;
      return;
    }
#ifdef VXWORKS
  /* Normally the address should be in "standard" space and address_code */
  /* should equal VME_AM_STD_USR_DATA. */
  /* and the sysBusToLocal will be used to get the address as seen */
  /* from this board. If the conversion doesn't work the user could replace */
  /* address_code with another code from "vme.h". or determine the correct */
  /* address for this particular board to use and bypass the */
  /* sysBusToLocalAdrs() call by setting address_code to zero. */
  /* If this is done though globmem it can be done by adding the line */
  /* vme_code=??? to the buffer line of the config file. */
  /* local address and put the VME address in a different config file. */
  bus_address = (char *) physical_address;
  if (address_code != 0)
    {
      if (OK != sysBusToLocalAdrs (address_code,
                                   (char *) bus_address,
                                   (char **) &local_address))
        {
          rcs_print_error ("sysBusToLocalAdrs returned ERROR. %d %s\n",
                           errno, strerror (errno));
          rcs_print_error ("Try changing vme_code=???");
        }
    }
  else
    {
      local_address = (char *) physical_address;
    }
  return;
#endif


#if defined(__MSDOS__) && !defined(__WIN32__)
#if defined(_Windows)
  selector = 0;
  local_address =
    (LOCAL_ADDRESS_TYPE) create_ptr_to_physmem (physical_address, size,
                                                &selector);
  return;
#else
  if (physical_address < 0x100000L)
    {
      local_address = (char RCS_FAR *) physical_address;
    }
  else
    {
      local_address = NULL;
    }
  return;
#endif
#endif

#if defined(WIN32) && !defined(gnuwin32) && !defined(UNDER_CE)
  if (using_bit3)
    {
      local_address = (char *) _physical_address;
      return;
    }
  DWORD cbReturned;
  ioport = 0;
  hMapMemDriver = NULL;
  hGenPortDriver = NULL;
  switch (address_code)
    {
    case NT_ISA_MEM_ADDRESS:
      pmi.InterfaceType = (INTERFACE_TYPE) Isa; // ISA interface type
      pmi.AddressSpace = (LONG) 0;      // 0 = map memory, 1 = map I/O
      pmi.BusNumber = (ULONG) 0;        // Standard x86 bus
      pmi.BusAddress.HighPart = (LONG) 0x00000000;      // High 32 bits of 64 bit address
      pmi.BusAddress.LowPart = (LONG) physical_address; // address to map
      pmi.Length = (LONG) size;

      /*
       *  Try to open the device
       */
      hMapMemDriver = CreateFile (TEXT ("\\\\.\\MAPMEM"),
                                  GENERIC_READ | GENERIC_WRITE,
                                  0,
                                  NULL,
                                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

      if (!hMapMemDriver)
        {
          rcs_print_error
            ("Can not open MAPMEM driver device. (Error = %d)\n",
             GetLastError ());
          local_address = NULL;
          isvalid = 0;
          return;
        }


      if (!DeviceIoControl (hMapMemDriver,
                            (DWORD) IOCTL_MAPMEM_MAP_USER_PHYSICAL_MEMORY,
                            &pmi,
                            sizeof (PHYSICAL_MEMORY_INFO),
                            &local_address, sizeof (PVOID), &cbReturned, 0))
        {
          rcs_print_error
            ("DeviceIoControl error accessing MAPMEM driver. (Error = %d)\n",
             GetLastError ());
          rcs_print_error
            ("PHYSMEM_HANDLE: Can not create handle to physical memory at 0x%X(%d) of 0x%X(%d) bytes.(address_code = %d)\n",
             physical_address, physical_address, size, size, address_code);
          local_address = NULL;
          isvalid = 0;
          return;
        }
      break;

    case NT_ISA_IO_ADDRESS:
      hGenPortDriver = CreateFile ("\\\\.\\GpdDev",     // Open the Device "file"
                                   GENERIC_READ | GENERIC_WRITE,
                                   0, NULL, OPEN_EXISTING, 0, NULL);

      if (hGenPortDriver == INVALID_HANDLE_VALUE)       // Was the device opened?
        {
          rcs_print_error ("Unable to open the device.\n");
          local_address = NULL;
          ioport = 0;
          isvalid = 0;
        }
      ioport = (WORD) physical_address;
      break;

    default:
      rcs_print_error ("PHYSMEM_HANDLE: Invalid address_code (%d)\n",
                       address_code);
      isvalid = 0;
      return;
    }



  return;

#endif

#ifdef lynxosPC
  sprintf (smem_name, "rcs_physmem%X", physical_address);

  // Remove any use of this name.
  smem_remove (smem_name);

  if ((local_address = (void *)
       smem_create (smem_name, (char *) physical_address, size,
                    SM_READ | SM_WRITE)) == NULL)
    {
      rcs_print_error ("can't get physical memory %X", physical_address);
    }
  return;
#endif

#ifdef LINUX_VME
  {
    int fd = open ("/dev/mem", O_RDWR);
    if (fd < 0)
      {
        perror ("open /dev/mem");
        return;
      }

    /* map it */
    local_address = (LOCAL_ADDRESS_TYPE) mmap (0, size,
                                               PROT_READ | PROT_WRITE,
                                               MAP_FILE | MAP_SHARED,
                                               fd, physical_address);

    /* close the fd since it's no longer used */
    close (fd);
  }
#endif



#if !defined(__MSDOS__) && !defined(_Windows) && !defined(lynxosPC)
  local_address = (LOCAL_ADDRESS_TYPE) physical_address;
#endif


}

/* Destructor. */
PHYSMEM_HANDLE::~PHYSMEM_HANDLE ()
{
#ifdef WIN32
#ifdef USING_BIT3
  if (using_bit3)
    {
      return;
    }
#endif
#if !defined(gnuwin32) && !defined(UNDER_CE)
  DWORD cbReturned;
  if (NULL != hMapMemDriver)
    {
      DeviceIoControl (hMapMemDriver,
                       (DWORD) IOCTL_MAPMEM_UNMAP_USER_PHYSICAL_MEMORY,
                       &pmi,
                       sizeof (PHYSICAL_MEMORY_INFO),
                       &local_address, sizeof (PVOID), &cbReturned, 0);
      CloseHandle (hMapMemDriver);
      hMapMemDriver = NULL;
    }
  if (NULL != hGenPortDriver)
    {
      CloseHandle (hGenPortDriver);
      hGenPortDriver = NULL;
    }
#endif
#endif

#ifdef WIN16
  if (selector)
    {
      FreeSelector (selector);
      selector = 0;
    }
#endif

#ifdef lynxosPC
  smem_create ("", (char *) physical_address, (long int) 0, SM_DETACH);
  smem_remove (smem_name);

#endif

#ifdef LINUX_VME
  if (local_address != 0 && physical_address != 0)
    {
      munmap (local_address, size);
    }
#endif

}


/* Use an ordinary pointer to access memory. */
void
PHYSMEM_HANDLE::set_to_ptr (void *_ptr, long _size)
{
  local_address = (LOCAL_ADDRESS_TYPE) _ptr;
  size = _size;
  offset = 0;
}

static int physmem_read_local_address_is_null_error_print_count = 0;

/***********************************************************
* Read _read_size bytes from physical memory to store at _to.
* Returns: 0 for success or -1 for failure.
**********************************************************/
int
PHYSMEM_HANDLE::read (void *_to, long _read_size)
{
  if (NULL == _to)
    {
      rcs_print_error ("PHYSMEM_HANDLE::read _to = NULL.\n");
      return (-1);
    }
  /* Check sizes. */
  if (_read_size + offset > size)
    {
      rcs_print_error
        ("PHYSMEM_HANDLE: Can't read %ld bytes at offset %ld from buffer of size %ld.\n",
         _read_size, offset, size);
      return (-1);
    }

  if (enable_byte_counting)
    {
      total_bytes_moved += _read_size;
    }

#ifdef USE_BIT3
  if (using_bit3)
    {
      if (swap_mode)
        {
          /* Lock the adaptor */
          if (bt_use_lock)
            {
              bt_status = bt_lock (btd, bt_lock_timeout);
              if (BT_SUCCESS != bt_status)
                {
                  bt_perror (btd, bt_status,
                             "Could not lock the Bit3 device. ");
                  return (-1);
                }
            }

          // Must use character by character copy to ensure bit3 doesn't do stupid
          // redundant swapping.
          volatile char *fp = ((char *) local_address) + offset;
          volatile char *tp = (char *) _to;
          for (int i = 0; i < _read_size; i++)
            {
              *tp = *fp;
              tp++;
              fp++;
            }

          /* Unlock the adaptor  */
          if (bt_use_lock)
            {
              bt_status = bt_unlock (btd);
              if (BT_SUCCESS != bt_status)
                {
                  bt_perror (btd, bt_status,
                             "Could not unlock the Bit3 device. ");
                  return (-1);
                }
            }

          return 0;
        }
      unsigned int bt_bytes_read;
      bt_devaddr_t transfer_addr = btd_offset + offset;
      bt_status =
        bt_read (btd, _to, transfer_addr, _read_size, &bt_bytes_read);
      if (BT_SUCCESS != bt_status)
        {
          bt_perror (btd, bt_status, " bt_read failed ");
          return (-1);
        }
      return (0);
    }
#endif

  /* If local_address has been initialized use it as an ordinary pointer. */
  if (NULL != local_address)
    {
      char RCS_FAR *from;
      from = ((char *) local_address) + offset;
      if (_read_size == 2)
        {
          short *sfrom = (short *) from;
          short sval;
          sval = *sfrom;
          short *sto = (short *) _to;
          *sto = sval;
        }
      else
        {
          memcpy (_to, from, _read_size);
        }
      return (0);
    }

  /* include platform specific ways of accessing phsical memory here. */
#if defined(__MSDOS__) && !defined(__WIN32__)
  return (read_physmem (physical_address + offset, _to, _read_size));
#endif
#if defined(WIN32) && !defined(gnuwin32) && !defined(UNDER_CE)
  if (address_code == NT_ISA_IO_ADDRESS && ioport != 0)
    {
      return read_from_genport (_to, _read_size);
    }
#endif
  if (!(physmem_read_local_address_is_null_error_print_count % 100000))
    {
      rcs_print_error
        ("PHYSMEM_HANDLE: Cannot read from physical memory when local address is NULL.\n");
      rcs_print_error ("(This error has occured %d times.)\n",
                       physmem_read_local_address_is_null_error_print_count +
                       1);
    }
  physmem_read_local_address_is_null_error_print_count++;
  return (-1);
}

static int physmem_write_local_address_is_null_error_print_count = 0;

/***********************************************************
* Write _write_size bytes from memory at _from to physical memory.
* Returns: 0 for success or -1 for failure.
**********************************************************/
int
PHYSMEM_HANDLE::write (void *_from, long _write_size)
{
  if (NULL == _from)
    {
      rcs_print_error ("PHYSMEM_HANDLE:write _from = NULL\n");
      return -1;
    }

  /* Check sizes. */
  if (_write_size + offset > size)
    {
      rcs_print_error
        ("PHYSMEM_HANDLE: Can't write %ld bytes at offset %ld from buffer of size %ld.\n",
         _write_size, offset, size);
      return (-1);
    }
  if (enable_byte_counting)
    {
      total_bytes_moved += _write_size;
    }


#ifdef USE_BIT3
  if (using_bit3)
    {
      if (swap_mode)
        {
          /* Lock the adaptor */
          if (bt_use_lock)
            {
              bt_status = bt_lock (btd, bt_lock_timeout);
              if (BT_SUCCESS != bt_status)
                {
                  bt_perror (btd, bt_status,
                             "Could not lock the Bit3 device. ");
                  return (-1);
                }
            }

          // Must use character by character copy to ensure bit3 doesn't do stupid
          // redundant swapping.
          volatile char *fp = (char *) _from;
          volatile char *tp = ((char *) local_address) + offset;
          for (int i = 0; i < _write_size; i++)
            {
              *tp = *fp;
              tp++;
              fp++;
            }

          /* Unlock the adaptor  */
          if (bt_use_lock)
            {
              bt_status = bt_unlock (btd);
              if (BT_SUCCESS != bt_status)
                {
                  bt_perror (btd, bt_status,
                             "Could not unlock the Bit3 device. ");
                  return (-1);
                }
            }
          return 0;
        }
      unsigned int bt_bytes_read;
      bt_devaddr_t transfer_addr = btd_offset + offset;
      bt_status =
        bt_write (btd, _from, transfer_addr, _write_size, &bt_bytes_read);
      if (BT_SUCCESS != bt_status)
        {
          bt_perror (btd, bt_status, " bt_write failed ");
          return (-1);
        }
      return (0);
    }
#endif

  /* If local_address has been initialized use it as an ordinary pointer. */
  if (NULL != local_address)
    {
      char RCS_FAR *to;
      to = ((char *) local_address) + offset;
      if (_write_size == 2)
        {
          short *sto = (short *) to;
          short sval = *(short *) _from;
          *sto = sval;
        }
      else
        {
          memcpy (to, _from, _write_size);
        }
      return (0);
    }

  /* include platform specific ways of accessing phsical memory here. */
#if  defined(__MSDOS__) && !defined(__WIN32__)
  return (write_physmem (physical_address + offset, _from, _write_size));
#endif
#if defined(WIN32) && !defined(gnuwin32) && !defined(UNDER_CE)
  if (address_code == NT_ISA_IO_ADDRESS && ioport != 0)
    {
      return write_to_genport (_from, _write_size);
    }
#endif
  if (!(physmem_write_local_address_is_null_error_print_count % 100000))
    {
      rcs_print_error
        ("PHYSMEM_HANDLE: Cannot write to physical memory when local address is NULL.\n");
      rcs_print_error ("(This error has occured %d times.)\n",
                       physmem_write_local_address_is_null_error_print_count +
                       1);
    }
  physmem_write_local_address_is_null_error_print_count++;
  return (-1);
}


void
PHYSMEM_HANDLE::memsetf (long _memset_offset, char _byte, long _memset_size)
{
  /* Check sizes. */
  if (_memset_size + _memset_offset > size)
    {
      return;
    }

  /* If local_address has been initialized use it as an ordinary pointer. */
  if (NULL != local_address)
    {
      char *temp_addr;
      temp_addr = ((char *) local_address) + _memset_offset;
      memset (temp_addr, _byte, _memset_size);
      return;
    }
  else
    {
      /* Since local address is not initialized use temp_buf and write to
         access the physical memory in an platform specific way. */
      if (NULL == temp_buf)
        {
          temp_buf = (char *) DEBUG_MALLOC (size);
        }
      if (NULL != temp_buf)
        {
          if (_memset_size + _memset_offset <= size)
            {
              memset (temp_buf, _byte, _memset_size);
              unsigned long old_offset;
              old_offset = offset;
              offset = _memset_offset;
              write (temp_buf, _memset_size);
              offset = old_offset;
            }
          else
            {
              memset (temp_buf, _byte, size - _memset_offset);
              unsigned long old_offset;
              old_offset = offset;
              offset = _memset_offset;
              write (temp_buf, size - offset);
              offset = old_offset;
            }
        }
    }
}



int
PHYSMEM_HANDLE::clear_memory ()
{
  /* If local_address has been initialized use it as an ordinary pointer. */
  if (NULL != local_address)
    {
      memset (local_address, 0, size);
      return (0);
    }
  else
    {
      /* Since local address is not initialized use temp_buf and write to
         access the physical memory in an platform specific way. */
      if (NULL == temp_buf)
        {
          temp_buf = (char *) DEBUG_MALLOC (size);
        }
      if (NULL == temp_buf)
        {
          return (-1);
        }
      memset (temp_buf, 0, size);
      unsigned long old_offset;
      old_offset = offset;
      offset = 0;
      if (-1 == write (temp_buf, size))
        {
          offset = old_offset;
          return (-1);
        }
      offset = old_offset;
    }
  return (0);
}

int
PHYSMEM_HANDLE::valid ()
{
  return isvalid;
}

#if defined(WIN32) && !defined(gnuwin32) && !defined(UNDER_CE)
int
PHYSMEM_HANDLE::read_from_genport (void *_to, long _read_size)
{
  int i;

  if ((_read_size % 4) == 0 && ((ioport + offset) % 4) == 0)
    {
      for (i = 0; i < _read_size / 4; i++)
        {
          if (read_dword_from_genport (((DWORD *) _to) + i, offset + i * 4) <
              0)
            {
              return -1;
            }
        }
      return 0;
    }
  if ((_read_size % 2) == 0 && ((ioport + offset) % 2) == 0)
    {
      for (i = 0; i < _read_size / 2; i++)
        {
          if (read_word_from_genport (((WORD *) _to) + i, i * 2) < 0)
            {
              return -1;
            }
        }
      return 0;
    }
  for (i = 0; i < _read_size; i++)
    {
      if (read_byte_from_genport (((BYTE *) _to) + i, offset + i) < 0)
        {
          return -1;
        }
    }
  return 0;
}

int
PHYSMEM_HANDLE::read_dword_from_genport (DWORD * DataBuffer, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL || DataBuffer == NULL)
    {
      return -1;
    }


  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_READ_PORT_ULONG,     // IO Control code for Read
                                 &PortNumber,   // Buffer to driver.
                                 sizeof (PortNumber),   // Length of buffer in bytes.
                                 DataBuffer,    // Buffer from driver.
                                 4,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in DataBuffer.
                                 NULL   // NULL means wait till op. completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Read  DWORD from IO port 0x%X failed.(Error = %ld)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  if (ReturnedLength != 4)
    {
      rcs_print_error
        ("GenPort driver returned %d bytes on port 0x%X when 4 were expected.\n",
         ReturnedLength, PortNumber);
      return -1;
    }
  return 0;
}

int
PHYSMEM_HANDLE::read_word_from_genport (WORD * DataBuffer, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL || DataBuffer == NULL)
    {
      return -1;
    }


  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_READ_PORT_USHORT,    // IO Control code for Read
                                 &PortNumber,   // Buffer to driver.
                                 sizeof (PortNumber),   // Length of buffer in bytes.
                                 DataBuffer,    // Buffer from driver.
                                 2,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in DataBuffer.
                                 NULL   // NULL means wait till op. completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Read WORD from IO port 0x%X failed.(Error = %ld)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  if (ReturnedLength != 2)
    {
      rcs_print_error
        ("GenPort driver returned %d bytes on port 0x%X when 2 were expected.\n",
         ReturnedLength, PortNumber);
      return -1;
    }
  return 0;
}

int
PHYSMEM_HANDLE::read_byte_from_genport (BYTE * DataBuffer, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL || DataBuffer == NULL)
    {
      return -1;
    }


  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_READ_PORT_UCHAR,     // IO Control code for Read
                                 &PortNumber,   // Buffer to driver.
                                 sizeof (PortNumber),   // Length of buffer in bytes.
                                 DataBuffer,    // Buffer from driver.
                                 1,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in DataBuffer.
                                 NULL   // NULL means wait till op. completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Read BYTE from IO port 0x%X failed.(Error = %ld)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  if (ReturnedLength != 1)
    {
      rcs_print_error
        ("GenPort driver returned %d bytes on port 0x%X when 2 were expected.\n",
         ReturnedLength, PortNumber);
      return -1;
    }
  return 0;
}


int
PHYSMEM_HANDLE::write_to_genport (void *_from, long _write_size)
{
  int i;

  if ((_write_size % 4) == 0 && ((ioport + offset) % 4) == 0)
    {
      for (i = 0; i < _write_size / 4; i++)
        {
          if (write_dword_to_genport (((DWORD *) _from)[i], offset + i * 4) <
              0)
            {
              return -1;
            }
        }
      return 0;
    }
  if ((_write_size % 2) == 0 && ((ioport + offset) % 2) == 0)
    {
      for (i = 0; i < _write_size / 2; i++)
        {
          if (write_word_to_genport (((WORD *) _from)[i], offset + i * 2) < 0)
            {
              return -1;
            }
        }
      return 0;
    }
  for (i = 0; i < _write_size; i++)
    {
      if (write_byte_to_genport (((BYTE *) _from)[i], offset + i) < 0)
        {
          return -1;
        }
    }
  return 0;
}


int
PHYSMEM_HANDLE::write_dword_to_genport (DWORD data, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL)
    {
      return -1;
    }
  gpwi.PortNumber = PortNumber;
  gpwi.LongData = data;

  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_WRITE_PORT_ULONG,    // IO Control code for Write
                                 &gpwi, // Buffer to driver.  Holds port & data.
                                 offsetof (GENPORT_WRITE_INPUT, LongData) +
                                 sizeof (gpwi.LongData),        // Length of buffer in bytes.
                                 NULL,  // Buffer from driver.   Not used.
                                 0,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in outbuf.  Should be 0.
                                 NULL   // NULL means wait till I/O completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Write DWORD to IO port 0x%X failed.(Error = %d)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  return 0;
}

int
PHYSMEM_HANDLE::write_word_to_genport (WORD data, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL)
    {
      return -1;
    }
  gpwi.PortNumber = PortNumber;
  gpwi.ShortData = data;

  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_WRITE_PORT_USHORT,   // IO Control code for Write
                                 &gpwi, // Buffer to driver.  Holds port & data.
                                 offsetof (GENPORT_WRITE_INPUT, ShortData) +
                                 sizeof (gpwi.ShortData),       // Length of buffer in bytes.
                                 NULL,  // Buffer from driver.   Not used.
                                 0,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in outbuf.  Should be 0.
                                 NULL   // NULL means wait till I/O completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Write WORD to IO port 0x%X failed. (Error = %d)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  return 0;
}


int
PHYSMEM_HANDLE::write_byte_to_genport (BYTE data, ULONG PortNumber)
{
  // The following is returned by IOCTL.  It is true if the read succeeds.
  BOOL IoctlResult;

  DWORD ReturnedLength;         // Number of bytes returned

  if (hGenPortDriver == NULL)
    {
      return -1;
    }
  gpwi.PortNumber = PortNumber;
  gpwi.CharData = data;

  IoctlResult = DeviceIoControl (hGenPortDriver,        // Handle to device
                                 IOCTL_GPD_WRITE_PORT_UCHAR,    // IO Control code for Write
                                 &gpwi, // Buffer to driver.  Holds port & data.
                                 offsetof (GENPORT_WRITE_INPUT, CharData) +
                                 sizeof (gpwi.CharData),        // Length of buffer in bytes.
                                 NULL,  // Buffer from driver.   Not used.
                                 0,     // Length of buffer in bytes.
                                 &ReturnedLength,       // Bytes placed in outbuf.  Should be 0.
                                 NULL   // NULL means wait till I/O completes.
    );

  if (!IoctlResult)
    {
      rcs_print_error ("Write BYTE to IO port 0x%X failed. (Error = %d)\n",
                       PortNumber, GetLastError ());
      ioport = 0;
      return -1;
    }
  return 0;
}

#endif

---