---

globmem.cc

Go to the documentation of this file.

/*************************************************************************
* File: globmem.cc                                                       *
* Authors: Fred Proctor, Will Shackleford                                *
* Purpose: C++ file for the Communication Management System(CMS).        *
* Includes:                                                              *
*          1. Member functions for class GLOBMEM.                        *
* Note: GLOBMEM is used for communication between multiple VxWorks       *
* boards in a single backplane.                                          *
*************************************************************************/

/* Include Files */
#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif

#include <string.h>             /* memcpy(), memset(), strtol() */
#include <stddef.h>             /* size_t */
#include <stdlib.h>             /* calloc() */
#include <ctype.h>              /* isdigit(), toupper(), tolower() */
#include <math.h>               /* fabs() */

#ifdef VXWORKS
#include "vxWorks.h"
#include "sysLib.h"             /* sysBusToLocalAdrs() */
#include "taskLib.h"            /* taskLock() */
#include "semLib.h"
#include "semSmLib.h"
#include "objLib.h"
#include "vme.h"                /* VME_AM_STD_USR_DATA */
#endif

#ifdef EXTERN_C_STD_HEADERS
}
#endif



#ifdef VXWORKS
extern "C"
{
#ifndef POWERPC
#include "spinlock.h"           /* _access functions */
#endif
#include "bus_lock.h"
#include "dma.h"
}
#endif

#include "cms.hh"               /* class CMS */
#include "globmem.hh"           /* class GLOBMEM */
#include "timer.hh"             /* class RCS_TIMER */
#include "rcs_prnt.hh"          /* rcs_print_error() */

#define SEM_DELAY_EPSILON  (1.0E-6)
#define DEFAULT_SEM_DELAY (1.0E-3)
#define SEM_CHECK_TIME_EPSILON (1.0E-7)

#if defined(WIN32) && defined(USE_BIT3)
#include "btapi.h"
#endif

/* External data */
unsigned long (*get_physical_address_func) (char *)
  = (unsigned long (*)(char *)) NULL;


/* Global Definitions. */
static int
convert2lower (char *dest, char *src, int len)
{
  int i;
  for (i = 0; i < len; i++)
    {
      if (src[i] == 0)
        {
          dest[i] = 0;
          return i;
        }
      dest[i] = tolower (src[i]);
    }
  return i;
}

static int
convert2upper (char *dest, char *src, int len)
{
  int i;
  for (i = 0; i < len; i++)
    {
      if (src[i] == 0)
        {
          dest[i] = 0;
          return i;
        }
      dest[i] = toupper (src[i]);
    }
  return i;
}

/* GLOBMEM Member Functions */

#ifdef VXWORKS
int RCS_BOARD_TYPE = UNKNOWN_BOARD_TYPE;
int usrSmObjInitInitialized = 0;
int VxMP_Option_Installed = 0;
int dma_being_used = 0;
#endif


/* Constructor used by cms_config. */
GLOBMEM::GLOBMEM (char *bufline, char *procline, int set_to_server,
                  int set_to_master):
CMS (bufline, procline, set_to_server)
{
  int address_space_code = 0;
  RCS_TIMER timer (1.0);
  char *address_equation;
  char *semdelay_equation;
  physical_address = 0;
  skip_area = 0;
  local_locks = (char *) NULL;
  physmem_handle = (PHYSMEM_HANDLE *) NULL;
  sem_delay = DEFAULT_SEM_DELAY;
  half_size = size / 2;
  half_offset = size / 2;
#ifdef VXWORKS
  board_type = RCS_BOARD_TYPE;
  use_dma = 0;
  bl_info = 0;
  dma_info = 0;
#endif
  lock_bus = 0;

  char *board_type_eq = NULL;
#ifdef VXWORKS
  if (NULL != (board_type_eq = sysModel ()))
    {
      if (!strncmp (board_type_eq, "MVME162", 7))
        {
          board_type = VX_MVME162_BOARD_TYPE;
        }
    }
#endif

#ifdef VXWORKS
  if (NULL != (board_type_eq = strstr (buflineupper, "BD_TYPE=")))
    {
      board_type_eq += 8;
      if (!strncmp (board_type_eq, "MVME162", 7))
        {
          board_type = VX_MVME162_BOARD_TYPE;
        }
    }

  if (NULL != (board_type_eq = strstr (proclineupper, "BD_TYPE=")))
    {
      board_type_eq += 8;
      if (!strncmp (board_type_eq, "MVME162", 7))
        {
          board_type = VX_MVME162_BOARD_TYPE;
        }
    }

#endif


#ifdef VXWORKS

  if (NULL != strstr (buflineupper, "LOCK_BUS"))
    {
      if (board_type == UNKNOWN_BOARD_TYPE)
        {
          rcs_print_error
            ("Can not use lock_bus option with unknown board type.\n");
        }
      else
        {
          lock_bus = 1;
          total_connections = 0;
        }
    }
  lock_task = 1;
  if (NULL != strstr (buflineupper, "NO_TASK_LOCK"))
    {
      lock_task = 0;
    }
  if (NULL != strstr (proclineupper, "NO_TASK_LOCK"))
    {
      lock_task = 0;
    }

  use_test_and_set=1;
  if (NULL != strstr (buflineupper, "NO_TEST_AND_SET"))
    {
      use_test_and_set = 0;
    }

  if (NULL != strstr (proclineupper, "USE_DMA"))
    {
      if (board_type == UNKNOWN_BOARD_TYPE)
        {
          rcs_print_error
            ("Can not use lock_bus option with unknown board type.\n");
        }
      else
        {
          use_dma = 1;
        }
    }
#endif

  if (total_connections <= connection_number && !lock_bus)
    {
      rcs_print_error
        ("GLOBMEM: connection number(%d) must be less than total connections (%d).\n",
         connection_number, total_connections);
      status = CMS_CONFIG_ERROR;
      return;
    }

  address_type = INVALID_ADDRESS_TYPE;
  convert2upper (address_type_name, ProcessName, CMS_CONFIG_LINELEN);
  strcat (address_type_name, "_ADDR=");
  if (NULL != (address_equation = strstr (buflineupper, address_type_name)))
    {
      physical_address =
        get_physical_address (address_equation + strlen (address_type_name));
      address_type = PROCESS_SPECIFIC_ADDRESS;
    }
  if (address_type == INVALID_ADDRESS_TYPE)
    {
      convert2upper (address_type_name, ProcessHost, CMS_CONFIG_LINELEN);
      strcat (address_type_name, "_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = HOST_SPECIFIC_ADDRESS;
        }
    }
#if defined(VXWORKS) || defined(linuxVME)
  if (address_type == INVALID_ADDRESS_TYPE)
    {
      strcpy (address_type_name, "VME_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = VME_ADDRESS;
          strcpy (address_type_name, "VME_CODE=");
          address_space_code = 0;
          if (NULL !=
              (address_equation = strstr (buflineupper, address_type_name)))
            {
              address_space_code = (unsigned long)
                strtol (address_equation + strlen (address_type_name),
                        (char **) NULL, 0);
            }
        }
    }
#endif
#if defined(MSDOS) || defined(WIN32) || defined(_WINDOWS)
  if (address_type == INVALID_ADDRESS_TYPE)
    {
      strcpy (address_type_name, "EISA_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = EISA_ADDRESS;
        }
    }

  if (address_type == INVALID_ADDRESS_TYPE)
    {
      strcpy (address_type_name, "ISA_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = ISA_ADDRESS;
        }
    }

  if (address_type == INVALID_ADDRESS_TYPE)
    {
      strcpy (address_type_name, "PCI_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = PCI_ADDRESS;
        }
    }
#endif
  if (address_type == INVALID_ADDRESS_TYPE)
    {
      strcpy (address_type_name, "GENERIC_ADDR=");
      if (NULL !=
          (address_equation = strstr (buflineupper, address_type_name)))
        {
          physical_address =
            get_physical_address (address_equation +
                                  strlen (address_type_name));
          address_type = GENERIC_ADDRESS;
        }
    }

#if defined(USE_BIT3) && defined(WIN32)
  unit = 0;
  remote_address = 0;
  bt_type = BT_DEV_DEFAULT;
  bt_use_mmap = 0;


  if (physical_address > 0)
    {
      remote_address = physical_address;
    }

  strcpy (address_type_name, "BIT3_OFFSET=");
  if (NULL != (address_equation = strstr (buflineupper, address_type_name)))
    {
      physical_address = remote_address =
        get_physical_address (address_equation + strlen (address_type_name));
      address_type = GENERIC_ADDRESS;
    }

  strcpy (address_type_name, "BIT3_UNIT=");
  if (NULL != (address_equation = strstr (buflineupper, address_type_name)))
    {
      unit = strtol (address_equation + strlen (address_type_name), NULL, 0);
    }

  if (NULL != strstr (buflineupper, "BIT3_USE_MMAP"))
    {
      bt_use_mmap = 1;
    }

  /* Open the unit */
  bt_status = bt_open (&btd,
                       bt_gen_name (unit, bt_type, &devname[0],
                                    BT_MAX_DEV_NAME), BT_RD | BT_WR);
  if (BT_SUCCESS != bt_status)
    {
      bt_perror (btd, bt_status, "Could not open the Bit3 device. ");
      status = CMS_MISC_ERROR;
      return;
    }

  /* Clear any outstanding errors */
  bt_status = bt_clrerr (btd);
  if (BT_SUCCESS != bt_status)
    {
      bt_perror (btd, bt_status,
                 "Could not clear errors from the Bit3 device. ");
      (void) bt_close (btd);
      status = CMS_MISC_ERROR;
      return;
    }

#if 0
  /* Disable byte/word swapping */
  bt_status = bt_set_info (btd, BT_INFO_SWAP, BT_SWAP_NONE);
  if (BT_SUCCESS != bt_status)
    {
      bt_perror (btd, bt_status,
                 "Could not set BT_INFO_SWAP to BT_SWAP_NONE ");
      (void) bt_close (btd);
      status = CMS_MISC_ERROR;
      return;
    }
#endif

  if (!bt_use_mmap)
    {
      physmem_handle = new PHYSMEM_HANDLE (btd, remote_address, size, 0);
    }
  else
    {
      /* Do the actual mmap */
      bt_status = bt_mmap (btd, &remote_p, remote_address, size,
                           BT_RD | BT_WR, BT_SWAP_DEFAULT);
      if (BT_SUCCESS != bt_status)
        {
          bt_perror (btd, bt_status,
                     "Could not memory map the Bit3 device. ");
          (void) bt_close (btd);
          status = CMS_MISC_ERROR;
          return;
        }
      physical_address = (unsigned long) remote_p;

      physmem_handle = new PHYSMEM_HANDLE ();
      physmem_handle->size = size;
      physmem_handle->local_address = (char *) physical_address;
      physmem_handle->swap_mode = 1;
      physmem_handle->using_bit3 = 1;
    }

#endif




  if (address_type == INVALID_ADDRESS_TYPE)
    {
      rcs_print_error ("GLOBMEM: No applicable address specified.\n");
      status = CMS_CONFIG_ERROR;
      return;
    }

#ifndef USE_BIT3
  if (0 == physical_address)
    {
      rcs_print_error ("GLOBMEM: physical address is zero.\n");
      status = CMS_CONFIG_ERROR;
      return;
    }
#endif


#ifdef VXWORKS
  if (lock_bus)
    {
      bl_info = getBusLockInfo (board_type, physical_address);
      if (NULL == bl_info)
        {
          rcs_print_error
            ("Can't get bus lock info for board type %d, and address 0x%X\n",
             board_type, physical_address);
          status = CMS_CONFIG_ERROR;
          return;
        }
    }

  if (use_dma)
    {
      dma_info = getDMAInfo (board_type, physical_address);
      if (NULL == dma_info)
        {
          rcs_print_error
            ("Can't get DMA info for board type %d, and address 0x%X\n",
             board_type, physical_address);
          status = CMS_CONFIG_ERROR;
          use_dma = 0;
          return;
        }
    }

  if (use_dma && lock_bus)
    {
      rcs_print_error
        ("GLOBMEM: Can't use DMA and use the bus lock for mutual exclusion.\n");
      status = CMS_CONFIG_ERROR;
      use_dma = 0;
      return;
    }

  if (use_dma && neutral)
    {
      rcs_print_error ("GLOBMEM:: Can't use DMA with neutral buffers.\n");
      status = CMS_CONFIG_ERROR;
      use_dma = 0;
      return;
    }

  if (use_dma && queuing_enabled)
    {
      rcs_print_error ("GLOBMEM: Can't use DMA with queued buffers.\n");
      status = CMS_CONFIG_ERROR;
      use_dma = 0;
      return;
    }

  /* if(use_dma && dma_being_used)
     {
     rcs_print_error("DMA already used by another process/buffer.\n");
     rcs_print_error("Only 1 NMLConnection can use DMA per board.\n");
     status = CMS_CONFIG_ERROR;
     use_dma = 0;
     return;
     }
   */
  if (use_dma)
    {
      dma_being_used = 1;
    }

#endif

#if !defined(USE_BIT3) || !defined(WIN32)

  physmem_handle = new PHYSMEM_HANDLE (physical_address,
                                       address_space_code, size);

#endif

  if (1 == set_to_master)
    {
      is_local_master = 1;
    }
  else if (-1 == set_to_master)
    {
      is_local_master = 0;
    }

  if (NULL != (semdelay_equation = strstr (proclineupper, "SEMDELAY=")))
    {
      sem_delay = strtod (semdelay_equation + 9, (char **) NULL);
    }
  else if (NULL != (semdelay_equation = strstr (buflineupper, "SEMDELAY=")))
    {
      sem_delay = strtod (semdelay_equation + 9, (char **) NULL);
    }

  /* if this is the master, clear the buffer */
  if (is_local_master)
    {
      physmem_handle->memsetf (0, 0, size);
    }
  local_locks = (char *) NULL;
  int remainder;
  if (split_buffer)
    {
      remainder = (physical_address + total_connections + 2) % 4;
      skip_area = total_connections + 2;
    }
  else
    {
      remainder = (physical_address + total_connections) % 4;
      skip_area = total_connections;
    }
  if (remainder)
    {
      skip_area += (4 - remainder);
    }
  local_locks = (char *) malloc ((long) total_connections);

#ifdef VXWORKS
  bsem = 0;
#endif

  if (min_compatible_version > 2.58 || min_compatible_version < 1E-6)
    {
      if (is_local_master)
        {
          physmem_handle->write (BufferName, 31);
#ifdef VXWORKS
          if (NULL != strstr (buflineupper, "BSEM"))
            {
              if (VxMP_Option_Installed)
                {
#if 0
                  if (!usrSmObjInitInitialized)
                    {
                      if (OK == usrSmObjInit (NULL))
                        {
                          usrSmObjInitInitialized = 1;
                        }
                      else
                        {
                          rcs_print_error ("usrSmObjInit error %d %s",
                                           errno, strerror (errno));
                        }
                    }
                  if (usrSmObjInitInitialized)
                    {
                      physmem_handle->offset = 32;
                      bsem = semBSmCreate (0, SEM_EMPTY);
                      void *glob_bsem = smObjLocalToGlobal ((void *) bsem);
                      physmem_handle->write (&glob_bsem, sizeof (void *));
                    }
#endif
                }
            }
#endif
        }
      else
        {
          char buf_name_check[32];
          physmem_handle->read (buf_name_check, 31);
          buf_name_check[31] = 0;
          if (buf_name_check[0] != BufferName[0]
              && !isalnum (buf_name_check[0]))
            {
              rcs_print_error
                ("GLOBMEM: buffer not initialized, start master.\n");
              status = CMS_NO_MASTER_ERROR;
              return;
            }
          if (strncmp (buf_name_check, BufferName, 31))
            {
              rcs_print_error
                ("GLOBMEM: Buffers %s and %s may have conflicting addresses..\n",
                 buf_name_check, BufferName);
              status = CMS_MISC_ERROR;
              return;
            }
#ifdef VXWORKS
          if (NULL != strstr (buflineupper, "BSEM"))
            {
              if (VxMP_Option_Installed)
                {
#if 0
                  if (!usrSmObjInitInitialized)
                    {
                      if (OK == usrSmObjInit (NULL))
                        {
                          usrSmObjInitInitialized = 1;
                        }
                      else
                        {
                          rcs_print_error ("usrSmObjInit error %d %s",
                                           errno, strerror (errno));
                        }
                    }
                  if (usrSmObjInitInitialized)
                    {
                      physmem_handle->offset = 32;
                      void *glob_bsem = NULL;
                      physmem_handle->read (&glob_bsem, sizeof (void *));
                      bsem = (SEM_ID) smObjGlobalToLocal (glob_bsem);
                    }
#endif
                }
            }
#endif
        }
      skip_area += 36;
      physical_address += 36;
    }

  if (total_subdivisions <= 0)
    {
      total_subdivisions = 1;
    }

  if (split_buffer)
    {
      if (neutral)
        {
          max_message_size =
            (size_without_diagnostics / 2) - skip_area - encoded_header_size;
          max_encoded_message_size =
            size_without_diagnostics - skip_area - total_connections -
            encoded_header_size;
          guaranteed_message_space = max_message_size / 4;
        }
      else
        {
          max_message_size =
            (size_without_diagnostics / 2) - skip_area - sizeof (CMS_HEADER);
          max_encoded_message_size = 4 * max_message_size;
          guaranteed_message_space = max_message_size;
        }
    }
  else
    {
      subdiv_size =
        (size_without_diagnostics - skip_area) / total_subdivisions;
      subdiv_size -= (subdiv_size % 4);
      if (neutral)
        {
          max_message_size = subdiv_size - encoded_header_size;
          max_encoded_message_size = subdiv_size - encoded_header_size;
          guaranteed_message_space = max_message_size / 4;
        }
      else
        {
          max_message_size = subdiv_size - sizeof (CMS_HEADER);
          max_encoded_message_size = 4 * max_message_size;
          guaranteed_message_space = max_message_size;
        }
    }

  if (enc_max_size > 0 && enc_max_size < max_encoded_message_size)
    {
      max_encoded_message_size = enc_max_size;
    }

  handle_to_global_data = physmem_handle;
  fast_mode = split_buffer && !neutral && !queuing_enabled &&
    timeout < SEM_CHECK_TIME_EPSILON && timeout >= 0.0;
#ifdef VXWORKS
  my_lock = (char *) physical_address + connection_number;
  toggle_bit_address = (char *) physical_address + total_connections;
  was_read_address = (char *) physical_address + total_connections + 1;
#endif




#if 0
  rcs_print ("GLOBMEM: size = %ld\n", size);
  rcs_print ("GLOBMEM: size = %ld\n", size);
  rcs_print ("GLOBMEM: total_connections = %ld\n", total_connections);
  rcs_print ("GLOBMEM: skip_area = %d\n", skip_area);
  rcs_print ("GLOBMEM: max_message_size = %ld\n", max_message_size);
  rcs_print ("GLOBMEM: max_encoded_message_size = %ld\n",
             max_encoded_message_size);
  rcs_print ("GLOBMEM: guaranteed_message_space = %ld\n", max_message_size);
#endif
}

/* Destructor. */
GLOBMEM::~GLOBMEM ()
{

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

  if (bt_use_mmap)
    {
      /* Release the mmap resources */
      bt_status = bt_unmmap (btd, remote_p, size);
      if (BT_SUCCESS != bt_status)
        {
          bt_perror (btd, bt_status, "Could not release the memory map. ");
          (void) bt_close (btd);
          return;
        }
    }

  /* Check for Adaptor bt_status errors */
  bt_status = bt_chkerr (btd);
  if (BT_SUCCESS != bt_status)
    {
      bt_perror (btd, bt_status, "Memory mapped read failed. ");
      (void) bt_close (btd);
      return;
    }

  /* Close the device */
  bt_status = bt_close (btd);
  if (BT_SUCCESS != bt_status)
    {
      bt_perror (btd, bt_status, "Could not close the Bit3 device. ");
      return;
    }

#endif

  if (NULL != physmem_handle)
    {
      if (delete_totally)
        {
          physmem_handle->memsetf (0, 0, size);
        }
      delete physmem_handle;
      physmem_handle = (PHYSMEM_HANDLE *) NULL;
    }
  if (NULL != local_locks)
    {
      free (local_locks);
      local_locks = (char *) NULL;
    }
#ifdef VXWORKS
  if (NULL != bl_info)
    {
      freeBusLockInfo (bl_info);
    }
  if (NULL != dma_info)
    {
      freeDMAInfo (dma_info);
      dma_being_used = 0;
    }
#endif
}

unsigned long
GLOBMEM::get_physical_address (char *_address_string)
{
  if (NULL != get_physical_address_func)
    {
      return (get_physical_address_func (_address_string));
    }
  if (NULL == _address_string)
    {
      return (0);
    }
  if (isdigit (_address_string[0]))
    {
      return ((unsigned long) strtoul (_address_string, (char **) NULL, 0));
    }
  /* Handle other ways of specifying an address. */


#if 0
  // Get the address for the OLD Bit3
  //  defined(MSDOS) && defined(USE_BIT3)
  char *bit3_str = "BIT3DP(";
  long bit3_str_len = strlen (bit3_str);

  /* Is it a bit3 address that can be found autimatically */
  if (strlen (_address_string) >= bit3_str_len)
    {
      if (!memcmp (_address_string, bit3_str, bit3_str_len))
        {
          long board_number;
          char *second_arg;
          long offset;
          if (isdigit (_address_string[5]))
            {
              board_number = strtol (_address_string + 5, &second_arg, 0);
              if (',' == second_arg[0])
                {
                  offset = strtol (second_arg + 1, NULL, 0);
                }
              else
                {
                  offset = 0;
                }
            }
          else
            {
              board_number = 0;
              offset = 0;
            }
          return (get_bit3_dp_address (board_number, offset, size));
        }
    }

  bit3_str = "BIT3RR(";
  bit3_str_len = strlen (bit3_str);

  /* Is it a bit3 address that can be found autimatically */
  if (strlen (_address_string) >= bit3_str_len)
    {
      if (!memcmp (_address_string, bit3_str, bit3_str_len))
        {
          long board_number;
          char *second_arg;
          long offset;
          if (isdigit (_address_string[5]))
            {
              board_number = strtol (_address_string + 5, &second_arg, 0);
              if (',' == second_arg[0])
                {
                  offset = strtol (second_arg + 1, NULL, 0);
                }
              else
                {
                  offset = 0;
                }
            }
          else
            {
              board_number = 0;
              offset = 0;
            }
          return (get_bit3_rr_address (board_number, offset, size));
        }
    }
#endif

  /* No Way Found. */
  return (0);
}



/* Access the global memory buffer. */
CMS_STATUS
GLOBMEM::main_access (void *_user_data)
{
  if ((blocking_timeout > 1e-6 || blocking_timeout < -1e-6))
    {
      rcs_print_error (" Can not call blocking_read when using GLOBMEM.\n");
      return (status = CMS_NO_BLOCKING_SEM_ERROR);
    }

  /* check pointers */
  char was_read_byte;
  write_just_completed = 0;
  read_only = ((internal_access_type == CMS_CHECK_IF_READ_ACCESS) ||
               (internal_access_type == CMS_READ_ACCESS) ||
               (internal_access_type == CMS_PEEK_ACCESS));

#ifdef VXWORKS
  if (use_dma)
    {
      int dma_status = checkForDMADone (dma_info);
      double time_diff = 0;
      double start_time = 0;
      if (timeout > 1e-6)
        {
          start_time = etime ();
        }
      while (1 != dma_status)
        {
          if (dma_status < 0)
            {
              status = CMS_MISC_ERROR;
              return (status);
            }
          time_diff = etime () - start_time;
          if (time_diff >= (timeout / 2))
            {
              rcs_print_error ("Timed out waiting for DMA Ready!\n");
              status = CMS_TIMED_OUT;
              return (status);
            }
          dma_status = checkForDMADone (dma_info);
        }
    }
#endif

  /* acquire  access */
  if (get_access () == -1)
    {
      return (status);
    }

  physmem_handle->offset = 0;

  /* Perform access function. */
  internal_access (physmem_handle, _user_data);


  if (!read_only && status > 0)
    {
      write_just_completed = 1;
    }
  /* give up  access */
  if (release_access () == -1)
    {
      return (status);
    }
  if (split_buffer && !read_only)
    {
      was_read_byte = 0;
      if (min_compatible_version > 2.58 || min_compatible_version < 1E-6)
        {
          physmem_handle->offset = total_connections + 37;
        }
      else
        {
          physmem_handle->offset = total_connections + 1;
        }
      if (-1 == physmem_handle->write (&was_read_byte, 1))
        {
          rcs_print_error ("GLOBMEM: can not set was read flag.\n");
          release_access ();
          return (status = CMS_MISC_ERROR);
        }
    }
  return (status);
}


int
GLOBMEM::get_access ()
{
#ifdef VXWORKS
  register char *ptr;
  register char *base = (char *) physical_address;
#endif
  char write_char;
  double start_time, time;
  int semaphores_clear = 1;

  if (physmem_handle == NULL)
    {
      rcs_print_error ("GLOBMEM: No handle to physical memory.\n");
      status = CMS_MISC_ERROR;
      return (-1);
    }

#ifdef VXWORKS
  if(use_test_and_set)
    {
      char *tas_address = physmem_handle->local_address + 36;
      if(timeout > 0)
        {
          start_time = etime();
        }
      while(1)
        {
          if(vxTas(tas_address) == TRUE)
            {
              // got it
              return 0;
            }
          if(timeout > 0)
            {
              if(etime() - start_time > timeout)
                {
                  status = CMS_TIMED_OUT;
                  return(-1);
                }
            }
          else if(timeout == 0)
            {
              status = CMS_TIMED_OUT;
              return -1;
            }
          if(sem_delay > SEM_DELAY_EPSILON)
            {
              esleep(sem_delay);
            }
        }
    }
#endif
          

#ifdef VXWORKS
  if (lock_task)
    {
      taskLock ();
    }
#endif

#ifdef VXWORKS
  if (lock_bus)
    {
      return enableBusLock (bl_info);
    }
#endif
  if (read_only)
    {
      if (split_buffer)
        {
          char four = 4;
          physmem_handle->offset = connection_number + 36;
          if (-1 == physmem_handle->write (&four, 1))
            {
              status = CMS_MISC_ERROR;
              rcs_print_error
                ("GLOBMEM: Error occured while reading physical memory.\n");
              return (-1);
            }
          physmem_handle->offset = total_connections + 36;
          if (-1 == physmem_handle->read (&toggle_bit, 1))
            {
              status = CMS_MISC_ERROR;
              rcs_print_error
                ("GLOBMEM: Error occured while reading physical memory.\n");
              return (-1);
            }
          write_char = 2 + toggle_bit;
        }
      else
        {
          write_char = 2;
        }
    }
  else
    {
      physmem_handle->offset = total_connections + 36;
      if (-1 == physmem_handle->read (&toggle_bit, 1))
        {
          status = CMS_MISC_ERROR;
          rcs_print_error
            ("GLOBMEM: Error occured while reading physical memory.\n");
          return (-1);
        }
      write_char = 1;
    }

#ifdef VXWORKS
  ptr = base + connection_number;
  *ptr = write_char;
#else
  physmem_handle->offset = connection_number + 36;
  if (-1 == physmem_handle->write (&write_char, 1))
    {
      status = CMS_MISC_ERROR;
      release_access ();
      rcs_print_error
        ("GLOBMEM: Error occured while writing to physical memory.\n");
      return (-1);
    }
#endif
  if (split_buffer && read_only)
    {
      return 0;
    }
#ifdef VXWORKS
  memcpy (local_locks, base, total_connections);
#else
  physmem_handle->offset = 36;
  if (-1 == physmem_handle->read (local_locks, total_connections))
    {
      status = CMS_MISC_ERROR;
      release_access ();
      rcs_print_error
        ("GLOBMEM: Error occured while reading physical memory.\n");
      return (-1);
    }
#endif
  semaphores_clear = 1;
  for (int i = 0; i < total_connections; i++)
    {
      if (0 != local_locks[i])
        {
          if (i != connection_number &&
              !(read_only && local_locks[i] > 1) &&
              !(split_buffer && 2 + toggle_bit == local_locks[i]))
            {
              semaphores_clear = 0;
              break;
            }
        }
    }
  if (semaphores_clear)
    {
      return 0;
    }

  time = start_time = etime ();
  do
    {
      if (split_buffer)
        {
          physmem_handle->offset = total_connections + 36;
          if (-1 == physmem_handle->read (&toggle_bit, 1))
            {
              status = CMS_MISC_ERROR;
              release_access ();
              rcs_print_error
                ("GLOBMEM: Error occured while reading physical memory.\n");
              return (-1);
            }
        }
#ifdef VXWORKS
      memcpy (local_locks, base, total_connections);
#else
      physmem_handle->offset = 36;
      if (-1 == physmem_handle->read (local_locks, total_connections))
        {
          status = CMS_MISC_ERROR;
          release_access ();
          rcs_print_error
            ("GLOBMEM: Error occured while reading physical memory.\n");
          return (-1);
        }
#endif
      semaphores_clear = 1;
      for (int i = 0; i < total_connections; i++)
        {
          if (0 != local_locks[i])
            {
              if (i != connection_number &&
                  !(read_only && local_locks[i] > 1) &&
                  !(split_buffer && 2 + toggle_bit == local_locks[i]))
                {
                  semaphores_clear = 0;
                  break;
                }
            }
        }
      if (semaphores_clear)
        {
          return (0);
        }
      if (fabs (timeout) < SEM_CHECK_TIME_EPSILON)
        {
          break;
        }
      if (sem_delay > SEM_DELAY_EPSILON)
        {
          release_access ();
#ifdef VXWORKS
          if (lock_task)
            {
              taskUnlock ();
            }
#endif
          esleep (sem_delay);
#ifdef VXWORKS
          if (lock_task)
            {
              taskLock ();
            }
#endif
          if (min_compatible_version > 2.58 || min_compatible_version < 1E-6)
            {
              physmem_handle->offset = connection_number + 36;
            }
          else
            {
              physmem_handle->offset = connection_number;
            }
          if (-1 == physmem_handle->write (&write_char, 1))
            {
              status = CMS_MISC_ERROR;
              release_access ();
              rcs_print_error
                ("GLOBMEM: Error occured while writing to physical memory.\n");
              return (-1);
            }
        }
      time = etime ();
    }
  while (time - start_time < timeout || timeout < 0);

  status = CMS_TIMED_OUT;
  release_access ();
  rcs_print_error
    ("GLOBMEM: Timed out after %lf seconds waiting for access to %s at %lf.\n",
     time - start_time, BufferName, time);
  return (-1);
}

int
GLOBMEM::release_access ()
{
  char zero = 0;
  if (NULL == physmem_handle)
    {
      status = CMS_MISC_ERROR;
      return (-1);
    }



#ifdef VXWORKS
  if (lock_bus)
    {
      return disableBusLock (bl_info);
    }
#endif

#ifdef VXWORKS
  if(use_test_and_set)
    {
      long * tas_address = (long *)
        ((char *) physmem_handle->local_address + 36);
      *tas_address = 0;
      return 0;
    }
#endif

  if (split_buffer &&
      (internal_access_type == CMS_WRITE_ACCESS ||
       internal_access_type == CMS_WRITE_IF_READ_ACCESS) &&
      status > 0 && write_just_completed)
    {
      toggle_bit = !toggle_bit;
      if (min_compatible_version > 2.58 || min_compatible_version < 1E-6)
        {
          physmem_handle->offset = total_connections + 36;
        }
      else
        {
          physmem_handle->offset = total_connections;
        }
      if (-1 == physmem_handle->write (&toggle_bit, 1))
        {
          rcs_print_error
            ("GLOBMEM: Error occured while reading physical memory.\n");
          status = CMS_MISC_ERROR;
          return (-1);
        }
    }
  if (min_compatible_version > 2.58 || min_compatible_version < 1E-6)
    {
      physmem_handle->offset = connection_number + 36;
    }
  else
    {
      physmem_handle->offset = connection_number;
    }
  if (-1 == physmem_handle->write (&zero, 1))
    {
      rcs_print_error
        ("GLOBMEM: Error occured while writing to physical memory.\n");
      rcs_print_error ("GLOBMEM: Can not release physical memory.\n");
      status = CMS_MISC_ERROR;
      return (-1);
    }
#ifdef VXWORKS
  if (lock_task)
    {
      taskUnlock ();
    }
#endif

  return (0);
}

static unsigned long zero = 0;
static unsigned long one = 0x01010101;

#ifdef VXWORKS

int
GLOBMEM::check_if_transfers_complete ()
{
  if (!use_dma)
    {
      return 1;
    }
  else
    {
      return checkForDMADone (dma_info);
    }
}

CMS_STATUS
GLOBMEM::write (void *user_data)
{
  register char *ptr;
  register char current_lock;
  register int semaphores_clear;
  char was_read_byte = 0;

  if (use_dma)
    {
      int dma_status = checkForDMADone (dma_info);
      double time_diff = 0;
      double start_time = 0;
      if (timeout > 1e-6)
        {
          start_time = etime ();
        }
      while (1 != dma_status)
        {
          if (dma_status < 0)
            {
              status = CMS_MISC_ERROR;
              return (status);
            }
          time_diff = etime () - start_time;
          if (time_diff >= (timeout / 2))
            {
              rcs_print_error ("Timed out waiting for DMA Ready!");
              status = CMS_TIMED_OUT;
              return (status);
            }
          dma_status = checkForDMADone (dma_info);
        }
      if (DMAClearScheduledTransfersList (dma_info) < 0)
        {
          rcs_print_error ("DMAClearScheduledTransfers error.\n");
          status = CMS_MISC_ERROR;
          return (status);
        }

      disable_final_write_raw_for_dma = 1;
      if (get_access () < 0)
        {
          return (status);
        }
      read_only = 0;
      if (split_buffer)
        {
          toggle_bit = *toggle_bit_address;
          if (internal_access_type == CMS_WRITE_IF_READ_ACCESS)
            {
              if (min_compatible_version > 2.58
                  || min_compatible_version < 1e-6)
                {
                  physmem_handle->offset = total_connections + 37;
                }
              else
                {
                  physmem_handle->offset = total_connections + 1;
                }
              physmem_handle->read (&was_read_byte, 1);
              header.was_read = (was_read_byte == toggle_bit + 1);
              if (!header.was_read)
                {
                  status = CMS_WRITE_WAS_BLOCKED;
                  release_access ();
                  return (status);
                }
              internal_access_type = CMS_WRITE_ACCESS;
            }
          if (read_only == toggle_bit)
            {
              physmem_handle->offset = skip_area;
              physmem_handle->size = half_size;
            }
          else
            {
              physmem_handle->offset = half_offset;
              physmem_handle->size = size;
            }
        }
      else
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = size;
        }
      write_raw (user_data);
      if (DMAScheduleLocalToVMETransfer
          (dma_info,
           (void
            *) ((unsigned long) (physmem_handle->local_address +
                                 physmem_handle->offset +
                                 sizeof (CMS_HEADER))), user_data,
           header.in_buffer_size) < 0)
        {
          rcs_print_error ("DMAScheduleLocalToVMETransfer error.");
          status = CMS_MISC_ERROR;
          return (status);
        }
      if (split_buffer)
        {
          toggle_bit = !toggle_bit;
          if (toggle_bit)
            {
              if (DMAScheduleLocalToVMETransfer
                  (dma_info, toggle_bit_address, &one, 1) < 0)
                {
                  rcs_print_error ("DMAScheduleLocalToVMETransfer error.");
                  status = CMS_MISC_ERROR;
                  return (status);
                }
            }
          else
            {
              if (DMAScheduleLocalToVMETransfer
                  (dma_info, toggle_bit_address, &zero, 1) < 0)
                {
                  rcs_print_error ("DMAScheduleLocalToVMETransfer error.");
                  status = CMS_MISC_ERROR;
                  return (status);
                }
            }

        }
      if (DMAScheduleLocalToVMETransfer (dma_info, my_lock, &zero, 1) < 0)
        {
          rcs_print_error ("DMAScheduleLocalToVMETransfer error.");
          status = CMS_MISC_ERROR;
          return (status);
        }
      if (DMAStartTransfers (dma_info))
        {
          rcs_print_error ("DMAStartTransfers error.");
          status = CMS_MISC_ERROR;
          return (status);
        }
      return (status);
    }

  if (fast_mode)
    {
      if (lock_bus)
        {
          enableBusLock (bl_info);
          toggle_bit = *toggle_bit_address;
        }
      else
        {
          *my_lock = 1;
          toggle_bit = *toggle_bit_address;

          semaphores_clear = 1;
          ptr = (char *) physical_address;
          for (; ptr < toggle_bit_address; ptr++)
            {
              if (0 != (current_lock = *ptr))
                {
                  if (ptr != my_lock && !(2 + toggle_bit == current_lock))
                    {
                      semaphores_clear = 0;
                      break;
                    }
                }
            }
          if (!semaphores_clear)
            {
              *my_lock = 0;
              status = CMS_TIMED_OUT;
              return (status);
            }
        }

      if (!toggle_bit)
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = half_size;
        }
      else
        {
          physmem_handle->offset = half_offset;
          physmem_handle->size = size;
        }

      /* Perform access function. */
      write_raw (user_data);


      if (status > 0)
        {
          *was_read_address = 0;
          *toggle_bit_address = !toggle_bit;
        }
      if (lock_bus)
        {
          disableBusLock (bl_info);
        }
      else
        {
          *my_lock = 0;
        }
      if (((int) bsem) > 0 && ((int) bsem) != ERROR)
        {
          if (OK != semFlush (bsem))
            {
              rcs_print_error ("semFlush returned ERROR. %d %s\n",
                               errno, strerror (errno));
            }
        }
      return (status);
    }
  internal_access_type = CMS_WRITE_ACCESS;
  main_access (user_data);
  if (((int) bsem) > 0 && ((int) bsem) != ERROR)
    {
      if (OK != semFlush (bsem))
        {
          rcs_print_error ("semFlush returned ERROR. %d %s\n",
                           errno, strerror (errno));
        }
    }
  return (status);
}



CMS_STATUS
GLOBMEM::write_if_read (void *user_data)
{
  register char *ptr;
  register char current_lock;
  register int semaphores_clear;
  if (fast_mode)
    {
      if (lock_bus)
        {
          enableBusLock (bl_info);
          toggle_bit = *toggle_bit_address;
        }
      else
        {
          *my_lock = 1;
          toggle_bit = *toggle_bit_address;

          semaphores_clear = 1;
          ptr = (char *) physical_address;
          for (; ptr < toggle_bit_address; ptr++)
            {
              if (0 != (current_lock = *ptr))
                {
                  if (ptr != my_lock && !(2 + toggle_bit == current_lock))
                    {
                      semaphores_clear = 0;
                      break;
                    }
                }
            }
          if (!semaphores_clear)
            {
              *my_lock = 0;
              status = CMS_TIMED_OUT;
              return (status);
            }
        }

      if (!toggle_bit)
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = half_size;
        }
      else
        {
          physmem_handle->offset = half_offset;
          physmem_handle->size = size;
        }

      if (!(*was_read_address))
        {
          *my_lock = 0;
          return (status = CMS_WRITE_WAS_BLOCKED);
        }

      /* Perform access function. */
      write (user_data);


      if (status > 0)
        {
          *was_read_address = 0;
          *toggle_bit_address = !toggle_bit;
        }
      if (lock_bus)
        {
          disableBusLock (bl_info);
        }
      else
        {
          *my_lock = 0;
        }
      return (status);
    }
  internal_access_type = CMS_WRITE_IF_READ_ACCESS;
  main_access (user_data);
  if (((int) bsem) > 0 && ((int) bsem) != ERROR)
    {
      if (OK != semFlush (bsem))
        {
          rcs_print_error ("semFlush returned ERROR. %d %s\n",
                           errno, strerror (errno));
        }
    }
  return (status);
}

static int bread_not_implemented_error_printed = 0;
CMS_STATUS
GLOBMEM::blocking_read (double btimeout)
{
  if (btimeout < 1e-6 && btimeout > -1e-6)
    {
      return read ();
    }
  if (!bread_not_implemented_error_printed)
    {
      rcs_print_error ("BLOCKING READ NOT IMPLEMENTED FOR GLOBMEM.\n");
      bread_not_implemented_error_printed = 1;
    }
  status = CMS_NO_IMPLEMENTATION_ERROR;
#if 0
  register char *ptr;
  register char current_lock;
  register int semaphores_clear;
  if (fast_mode)
    {
      *my_lock = 4;
      *my_lock = 2 + (toggle_bit = *toggle_bit_address);
      if (toggle_bit)
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = half_size;
        }
      else
        {
          physmem_handle->offset = half_offset;
          physmem_handle->size = size;
        }

      /* Perform access function. */
      read_raw ();

      *my_lock = 0;
      if (status == CMS_READ_OLD && ((int) bsem) > 0 && btimeout > 1e-6
          || btimeout < -1e-6)
        {
          int ticks = (int) (btimeout * sysClkRateGet ());
          if (btimeout < 0)
            {
              ticks = WAIT_FOREVER;
            }
          if (OK != semTake (bsem, ticks))
            {
              if (ticks > 0 && errno == S_objLib_OBJ_TIMEOUT)
                {
                  status = CMS_TIMED_OUT;
                  return (status);
                }
              else
                {
                  rcs_print_error ("semTake returned ERROR. %d %s",
                                   errno, strerror (errno));
                  status = CMS_MISC_ERROR;
                  return (status);
                }
            }
          *my_lock = 4;
          *my_lock = 2 + (toggle_bit = *toggle_bit_address);
          if (toggle_bit)
            {
              physmem_handle->offset = skip_area;
              physmem_handle->size = half_size;
            }
          else
            {
              physmem_handle->offset = half_offset;
              physmem_handle->size = size;
            }

          /* Perform access function. */
          read_raw ();

          *my_lock = 0;
        }
      return (status);
    }
  internal_access_type = CMS_READ_ACCESS;
  main_access (data);
  if (status == CMS_READ_OLD && bsem > 0 && btimeout > 1e-6
      || btimeout < -1e-6)
    {
      int ticks = (int) (btimeout * sysClkRateGet ());
      if (btimeout < 0)
        {
          ticks = WAIT_FOREVER;
        }
      if (OK != semTake (bsem, ticks))
        {
          if (ticks > 0 && errno == S_objLib_OBJ_TIMEOUT)
            {
              status = CMS_TIMED_OUT;
              return (status);
            }
          else
            {
              rcs_print_error ("semTake returned ERROR. %d %s",
                               errno, strerror (errno));
              status = CMS_MISC_ERROR;
              return (status);
            }
        }
      main_access (data);
    }
#endif
  return (status);
}

CMS_STATUS
GLOBMEM::read ()
{
  if (fast_mode)
    {
      if (lock_bus)
        {
          enableBusLock (bl_info);
          toggle_bit = *toggle_bit_address;
        }
      else
        {
          *my_lock = 4;
          *my_lock = 2 + (toggle_bit = *toggle_bit_address);
        }

      if (toggle_bit)
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = half_size;
        }
      else
        {
          physmem_handle->offset = half_offset;
          physmem_handle->size = size;
        }

      /* Perform access function. */
      read_raw ();

      if (lock_bus)
        {
          disableBusLock (bl_info);
        }
      else
        {
          *my_lock = 0;
        }
      return (status);
    }
  internal_access_type = CMS_READ_ACCESS;
  main_access (data);
  return (status);
}

CMS_STATUS
GLOBMEM::peek ()
{
  if (fast_mode)
    {
      if (lock_bus)
        {
          enableBusLock (bl_info);
          toggle_bit = *toggle_bit_address;
        }
      else
        {
          *my_lock = 4;
          *my_lock = 2 + (toggle_bit = *toggle_bit_address);
        }

      if (toggle_bit)
        {
          physmem_handle->offset = skip_area;
          physmem_handle->size = half_size;
        }
      else
        {
          physmem_handle->offset = half_offset;
          physmem_handle->size = size;
        }

      /* Perform access function. */
      read_raw ();

      if (lock_bus)
        {
          disableBusLock (bl_info);
        }
      else
        {
          *my_lock = 0;
        }
      return (status);
    }
  internal_access_type = CMS_PEEK_ACCESS;
  main_access (data);
  return (status);
}

#endif

---