---

stgmembs.c

Go to the documentation of this file.

/*
 * stgmembs.cpp
 *
 * A part of the Windows 95 driver for Servo To Go, Incen.'s ISA Bus
 * servo I/O card.
 *
 * This file contains member functions for the ServoToGo class.
 *
 * This work, including the source code, documentation
 * and related data, is placed into the public domain.
 *
 * The orginal author is Don McLane, Servo To Go, Inc.
 *
 * THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY
 * OF ANY KIND, NOT EVEN THE IMPLIED WARRANTY OF
 * MERCHANTABILITY. THE AUTHOR OF THIS SOFTWARE,
 * ASSUMES _NO_ RESPONSIBILITY FOR ANY CONSEQUENCE
 * RESULTING FROM THE USE, MODIFICATION, OR
 * REDISTRIBUTION OF THIS SOFTWARE.
 *
 *
 */

/* ident tag */
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

static char __attribute__((unused)) ident[] = "$Id: stgmembs.c,v 1.5 2001/11/05 16:59:55 wshackle Exp $";


#include "locdefs.h"
#define assert(a)

#include "offsets.h"
#include "stgdefs.h"
#include "locsysio.h"


inline void fOutP(unsigned short port, unsigned char data)
{
  outb(data, port);
}

inline void fOutPW(unsigned short port, unsigned short data)
{
  outw(data, port);
}

inline unsigned char fInP(unsigned short port)
{
  return inb(port);
}

inline unsigned short fInPW(unsigned short port)
{
  return inw(port);
}

static unsigned short wBaseAddress;
static unsigned short wIrq;
static unsigned short wModel;
static unsigned short wNoBoardFlag;
static unsigned short wAxesInSys;
static unsigned short wSaveDirs;
static unsigned char  byIndexPollAxis;
static unsigned char  byIndexPulsePolarity;
static long           lSimDac[MAX_AXIS];
static long           lSimEnc[MAX_AXIS];

static const int      aPortOffset_1[] = {DIO_A, DIO_B, DIO_C, DIO_D};
static const int      aPortOffset_2[] = {PORT_A, PORT_B, PORT_C, PORT_D};

static unsigned char  byEncHighByte[MAX_AXIS];
static unsigned char  byOldByte2[MAX_AXIS];

unsigned short BaseAddress(void)
{
  return wBaseAddress;
}

    unsigned short GetBoardPresence(void) {return wNoBoardFlag;};
    unsigned short GetAxes(void) {return wAxesInSys;};
    unsigned short GetIrq(void) {return wIrq;};
    unsigned short GetAddr(void) {return wBaseAddress;};
    unsigned short GetModel(void) {return wModel;};


/***************************************************************************/
/*                                                                         */
/*                           Constructor                                   */
/*                                                                         */
/***************************************************************************/
void
ServoToGoConstructor(unsigned short wRequestedIrq)
{
#if defined ( STG_LINUX )
    iopl(3);  // get access to I/O ports, must be root.
#endif
    wNoBoardFlag = NO_BOARD;
    Initialize(wRequestedIrq);   // figure out board address, init irq controller
    EncoderInit();
    SelectInterruptPeriod(_1_MILLISECOND);  // initialize timer
    byIndexPulsePolarity = 1;               // default active level high
    if (wModel == MODEL2)
        fOutP(wBaseAddress + CNTRL1, CNTRL1_NOT_SLAVE);
};

/***************************************************************************/
/*                                                                         */
/*                            Destructor                                   */
/*                                                                         */
/***************************************************************************/
void
ServoToGoDestructor(void)
{
  unsigned short nAxis;
    StopInterrupts();

    // set all the DAC outputs to 0.
    for (nAxis = 0; nAxis < MAX_AXIS; nAxis++)
        RawDAC(nAxis, 0);

    // set all the digital I/O bits to input
    DioDirection2(0);
}

/***************************************************************************/
/*                                                                         */
/*                              SetIrq                                     */
/*                                                                         */
/***************************************************************************/
void SetIrq(unsigned short wRequestedIrq)
{
    unsigned char byIntReg;

    if (wNoBoardFlag == NO_BOARD)
        return;

    wIrq = wRequestedIrq;  // assume it's OK for now, check later

    if (wModel == MODEL1)
        byIntReg = 0x80;       // initial value for the high bits in the register
                               // sets auto zero off
    else   // MODEL2
        byIntReg = 0x88;       // cal high too, not calibrating ADC

    // now put low bits into byIntReg to select irq

    switch (wRequestedIrq)
    {
        case 3: break;      // add zero

        case 5: byIntReg |= 4;
                break;

        case 7: byIntReg |= 2;
                break;

        case 9: byIntReg |= 6;
                break;

        case 10: byIntReg |= 5;
                 break;

        case 11: byIntReg |= 7;
                 break;

        case 12: byIntReg |= 3;
                 break;

        case 15: byIntReg |= 1;
                 break;

        default: wIrq = 5;      // ERROR, requested irq not valid, use 5
                 byIntReg |= 4; // There is no safe value, leaving zero
                                // here would select IRQ 3 which is worse
                                // than 5 because IRQ 3 is usually for COM 2
                 break;
    }

    if (wModel == MODEL1)
        fOutP(wBaseAddress + INTC, byIntReg);  // set irq
    else   // MODEL2
        fOutP(wBaseAddress + CNTRL0, byIntReg);
}
/***************************************************************************/
/*                                                                         */
/*                             BaseFind                                    */
/*                                                                         */
/***************************************************************************/

// find the base address of the Servo To Go board

unsigned short BaseFind(void)
{
   short i;
   unsigned short io_add;

   for (i = 15; i >= 0; i--)                    // search all possible addresses
   {
       io_add = i * 0x20 + 0x200;
       if ( BrdtstOK(io_add) )
        return io_add;
   }
   return(0);
}

/***************************************************************************/
/*                                                                         */
/*                             BrdtstOK                                    */
/*                                                                         */
/***************************************************************************/

// check the board tests register, figure out board model

unsigned short BrdtstOK(unsigned short BaseAddress)
{
    unsigned short BrdtstAddress;
    unsigned short SerSeq, HighNibble;
    int j;

    BrdtstAddress = BaseAddress + BRDTST;

    SerSeq = 0;
    for ( j = 7; j >= 0; j--)
    {
        HighNibble = fInP(BrdtstAddress) >> 4;
        if (HighNibble & 8)     // is SER set
        {
           // shift bit to position specifed by Q2, Q1, Q0
           // which are the lower three bits.  Put bit in SerSeq.
           SerSeq |= 1 << (HighNibble & 7);
        }
    }
    if (SerSeq == 0x75)        // SER sequence is 01110101
    {
        wModel = MODEL1;
        return 1;              //true
    }
    if (SerSeq == 0x74)        // SER sequence is 01110100
    {
        wModel = MODEL2;
        return 1;              // true
    }
//    wModel = MODEL_NO_ID;
    return 0;  // false
}

/***************************************************************************/
/*                                                                         */
/*                             Initialize                                  */
/*                                                                         */
/***************************************************************************/
void Initialize(unsigned short wRequestedIrq)
{
  /*
   * First find the the base I/O address of the board.
   *
   * only do this in the DOS example.  It's dangerous under 95, and can't be
   * done under NT
   */
   wBaseAddress = BaseFind();
   if (wBaseAddress == 0)
   {
       wNoBoardFlag = NO_BOARD;
   }
   wNoBoardFlag = BOARD_PRESENT;

  /*
   * Initialize the interrupt controller
   */
   if (wModel == MODEL1)
   {
   fOutP(wBaseAddress + MIO_2, 0x92);  // initialize INTC as output reg.
                                       // sets port D to input since we have
                                       // to set it to something.
   SetIrq(wRequestedIrq);              // selects the IRQ in INTC. Now, if a stray
                                       // interrupt is issued (see below) it will
                                       // go to an interrupt that isn't enabled on
                                       // the motherboard yet (if your system is
                                       // set up correctly).
   fOutP( wBaseAddress + ICW1, 0x1a ); // initialize 82C59 as single chip,
                                       // level triggered
   fOutP( wBaseAddress + ICW2, 0x00 ); // icw2 - not used, must write
                                       // could issue stray interrupt here - danger!
   fOutP( wBaseAddress + OCW1, 0xff);  // mask off all interrupt sources (the
                                       // interrupt on the motherboard isn't
                                       // enabled yet, you do that when you install
                                       // your interrupt handler.).
   }
   else   // must be a Model 2
   {
   fOutP(wBaseAddress + MIO_2, 0x8b);  // initialize CNTRL0 as output reg.
                                       // BRDTST to input.
                                       // sets port D, high and low, to input
                                       // since we have to set it to something.
   SetIrq(wRequestedIrq);              // selects the IRQ in CNTRL0. Now, if a stray
                                       // interrupt is issued (see below) it will
                                       // go to an interrupt that isn't enabled on
                                       // the motherboard yet (if your system is
                                       // set up correctly).
   }
};

/***************************************************************************/
/*                                                                         */
/*                              StartADC                                   */
/*                                                                         */
/***************************************************************************/
void StartADC(unsigned short wAxis)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    if (wAxis > 7)
        return;

    if (wModel == MODEL1)
    {
        // do a dummy read from the ADC, just to set the input multiplexer to
        // the right channel
        fInPW(wBaseAddress + ADC_0 + (wAxis << 1));        //lint !e534

        // wait 4 uS for settling time on the multiplexer and ADC
        // you probably shouldn't really have a delay in
        // a driver.
        Timer2Delay(28);

        // now start conversion.
        fOutPW(wBaseAddress + ADC_0 + (wAxis << 1), 0);
    }
    else  // Model 2
    {
        unsigned char Cntrl0;

        Cntrl0 = fInP(wBaseAddress + CNTRL0) & 0x07;  // save irq

        Cntrl0 |= (wAxis << 4) | 0x88;  // shift bits to AD2, AD1, AD0
                                        // set bit 0x80 high for autozero
                                        // set bit 0x08 high, not calibrating
        fOutP(wBaseAddress + CNTRL0, Cntrl0);  // select ADC channel

        // don't have to do a dummy read for a model 2

        // wait 4 uS for settling time on the multiplexer and ADC
        // you probably shouldn't really have a delay in
        // a driver.
        Timer2Delay(28);

        // now start conversion.
        fOutPW(wBaseAddress + ADC, 0);

    }
};

/***************************************************************************/
/*                                                                         */
/*                               RawADC                                    */
/*                                                                         */
/***************************************************************************/
short SpinReadADC(unsigned short wAxis)
{
    short counts;
    short j;

    if (wNoBoardFlag == NO_BOARD)
    {
        return 0;
    }

    if (wAxis > 7)
         return -1;

    if (wModel == MODEL1)
    {
        // make sure conversion is done, assume polling delay is done.
        // EOC (End Of Conversion) is bit 0x08 in IIR (Interrupt Request
        // Register) of Interrupt Controller.  Don't wait forever though
        // bail out eventually.

        for ( j = 0; (!(CurrentIRR() & 0x08)) && (j < 10000); j++);

        counts = ( fInPW(wBaseAddress + ADC_0 + (wAxis << 1)) );
    }
    else
    {
        // is the conversion done?
        for ( j = 0; (fInP(wBaseAddress + BRDTST) & BRDTST_EOC) && (j < 10000); j++);

        // conversion is done, get counts.
        counts = fInPW(wBaseAddress + ADC);
    }

    if (counts & 0x1000)       // is sign bit negative?
        counts |= 0xf000;      // sign extend
    else
        counts &= 0xfff;       // make sure high order bits are zero.

    return counts;
};

long ReadADC(unsigned short wAxis, short *counts_ptr)
{
  short counts;
  if(counts_ptr == 0)
    {
      return 0;
    }
  counts = *counts_ptr;
    if (wNoBoardFlag == NO_BOARD)
    {
        return STG_SUCCESS;
    }

    if (wAxis > 7)
         return STG_FAILURE;

    if (wModel == MODEL1)
    {
        if ( !(CurrentIRR() & 0x08) ) // is the conversion done?
            return STG_FAILURE;                  // no, return failure

        // conversion is done, get counts.
//        counts = fInPW(wBaseAddress + ADC_0 + (wAxis << 1));
//        counts = fInPW(wBaseAddress + ADC_1);  // debug
    }
    else  // Model 2
    {
        // is the conversion done?
        if ( fInP(wBaseAddress + BRDTST) & BRDTST_EOC )
            return STG_FAILURE;                 // no, return failure

        // conversion is done, get counts.
//        counts = fInPW(wBaseAddress + ADC_1);
    }

    counts = fInPW(wBaseAddress + ADC_0 + (wAxis << 1));

    if (counts & 0x1000)       // is sign bit negative?
        counts |= 0xf000;      // sign extend
    else
        counts &= 0xfff;       // make sure high order bits are zero.

    *counts_ptr = counts;
    return STG_SUCCESS;

};

/***************************************************************************/
/*                                                                         */
/*                             EncoderInit                                 */
/*                                                                         */
/***************************************************************************/
//
// sets global variable: wAxesInSys
//
void EncoderInit(void)
{
    LONGBYTE enc[8];
    unsigned short wAdd,wA;
    unsigned short const wTestPat = 0x5aa5;
    
    if (wNoBoardFlag == NO_BOARD)
    {
        wAxesInSys = MAX_AXIS;
        return;
    }

    // It is possible that the encoder counts are being held by battery
    // backup, so we'll read the encoders, and save the values
    // Then we'll initialize the encoder chips, since it's more likely that
    // the ecoders were not kept alive by battery and need to be initialized

    EncReadAll(enc);

    // probably the right thing is to sign extend the 24 bits, so, instead
    // of a 24 bit unsigned count, we have +/- 23 bits.

//    for ( i = 0; i < 8; i++)
//    {
//        byEncHighByte[i] = enc[i].Byte[2] & 0x80 ? 0xff : 0;
//        byOldByte2[i] = enc[i].Byte[2];
//    }

    for (wAdd = wBaseAddress + CNT0_C;
                                 wAdd <= wBaseAddress + CNT6_C; wAdd +=4)
    {
        // we're going to be slick and do two chips at a time, that's why
        // the registers are arranged data, data, control, control.  You
        // can do two at a time, by using word operations, instead of
        // byte operations.  Not a big deal for initializing, but reading is
        // done pretty often.

        fOutPW(wAdd, 0x2020);   // master reset

        // Set Counter Command Register - Input Control, OL Load (P3),
        // and Enable Inputs A and B (INA/B).

        fOutPW(wAdd, 0x6868);

        // Set Counter Command Register - Output Control

        fOutPW(wAdd, 0x8080);

        // Set Counter Command Register - Quadrature

        fOutPW(wAdd, 0xc3c3);

        fOutPW(wAdd, 0x0404);  //reset counter to zero
    }

    //  Figure out how many axes are on the card

    for ( wA = wBaseAddress + CNT0_D; wA <= wBaseAddress + CNT6_D; wA +=4)
    {

        // reset address pointer

        fOutPW(wA + 2, 0x0101);

        // write a pattern to the preset register

        fOutPW(wA, wTestPat);
        fOutPW(wA, wTestPat);
        fOutPW(wA, wTestPat);

        // transfer the preset register to the count register

        fOutPW(wA + 2, 0x0909);

        // transfer counter to output latch

        fOutPW(wA + 2, 0x0202);

        // read the output latch and see if it matches

        if (fInPW(wA) != wTestPat)
            break;
        if (fInPW(wA) != wTestPat)
            break;
        if (fInPW(wA) != wTestPat)
            break;

        // now replace the values that you saved previously, in case the
        // encoder was battery backed up

        fOutP(wA, enc[wAxesInSys].Byte[0]);
        fOutP(wA, enc[wAxesInSys].Byte[1]);
        fOutP(wA, enc[wAxesInSys].Byte[2]);

        fOutP(wA + 1, enc[wAxesInSys + 1].Byte[0]);
        fOutP(wA + 1, enc[wAxesInSys + 1].Byte[1]);
        fOutP(wA + 1, enc[wAxesInSys + 1].Byte[2]);

        // transfer the preset register to the count register

        fOutPW(wA + 2, 0x0909);

        wAxesInSys += 2;

        // write zeros to preset register, we don't want to do a master reset
        // (MRST), because then we would need to re-initialize the counter

//        fOutPW(wA, 0);
//        fOutPW(wA, 0);
//        fOutPW(wA, 0);

        // reset counter, BRW and CRY and address pointer (RADR)

//        fOutPW(wA + 2, 0x0505);
    }
};

/***************************************************************************/
/*                                                                         */
/*                        SelectInterruptPeriod                            */
/*                                                                         */
/***************************************************************************/
void SelectInterruptPeriod(long lPeriodSelect)
{
   if (wNoBoardFlag == NO_BOARD)
   {
       return;
   }

   if (lPeriodSelect != MAX_PERIOD)
   {
       fOutP(wBaseAddress + TMRCMD, 0x56);   // timer 1, read/load LSB (MSB is 0)
                                             // mode 3 (square wave)
       fOutP(wBaseAddress + TIMER_1, 0xb4);  // 0xb4 = 180 -> 25 uSec period
   }
   else
   {
       fOutP(wBaseAddress + TMRCMD, 0x76);   // timer 1, read/load LSB then MSB
                                             // mode 3 (square wave)
       fOutP(wBaseAddress + TIMER_1, 0xff);  // LSB
       fOutP(wBaseAddress + TIMER_1, 0xff);  // MSB
   }

   switch (lPeriodSelect)
   {
        case _500_MICROSECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x14);   // 0x14 = 20 = .5 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _1_MILLISECOND:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x28);   // 0x28 = 40 = 1 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _2_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x50);   // 0x50 = 80 = 2 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _3_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x78);   // 0x78 = 120 = 3 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _4_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0xA0);   // 0xA0 = 160 = 4 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _5_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0xC8);   // 0xC8 = 200 = 5 mS
            fOutP(wBaseAddress + TIMER_0, 0x00);
            break;
        case _10_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x90);   // 0x0190 = 400 = 10 mS
            fOutP(wBaseAddress + TIMER_0, 0x01);
            break;
        case _100_MILLISECONDS:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0xA0);   // 0x0FA0 = 4000 = 100 mS
            fOutP(wBaseAddress + TIMER_0, 0x0F);
            break;
        case _1_SECOND:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0x40);   // 0x9C40 = 40000 = 1 S
            fOutP(wBaseAddress + TIMER_0, 0x9c);
            break;
        case MAX_PERIOD:
            fOutP(wBaseAddress + TMRCMD, 0x34);    // timer 0, read/load LSB followed by
                                                   // MSB, mode 2 (real-time interrupt)
            fOutP(wBaseAddress + TIMER_0, 0xff);   // LSB
            fOutP(wBaseAddress + TIMER_0, 0xff);   // MSB
            break;
        default:
            // wrong input? then don't change it
            break;
   }
};

/***************************************************************************/
/*                                                                         */
/*                               RawDAC                                    */
/*                                                                         */
/***************************************************************************/
void RawDAC(unsigned short nAxis, long lCounts)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    if ( nAxis > 7 )        // is axis within range?
       return;

    // input / output:
    //
    //    lCounts (decimal) ... -lCounts ... +0x1000 ... volts
    //
    //     0x1000  (4096)     0xfffff000           0       +10
    //          0                      0      0x1000         0
    // 0xfffff001 (-4095)          0xfff      0x1fff       -10

    // So, the domain might be different than you expected. I expected:
    //     0xf000 (-4096)  to  0xfff (4095), rather than
    //     0xf001 (-4095)  to 0x1000 (4096)

    // reverse slope so positive counts give positive voltage
    lCounts = - lCounts;

    // shift for DAC
    lCounts += 0x1000;

    if (lCounts > 0x1FFF)    // clamp + output
    {
        lCounts = 0x1FFF;
    }
    if (lCounts < 0)         // clamp - output
    {
        lCounts = 0;
    }

    if (wNoBoardFlag == NO_BOARD)      // are we simulating?
    {
        lSimDac[nAxis] = lCounts;
        return;
    }

//    nCounts = (USHORT) (lCounts + 0x1000); // correct range for DAC

    fOutPW(wBaseAddress + DAC_0 + (nAxis << 1), (unsigned short)lCounts);
};

/***************************************************************************/
/*                                                                         */
/*                             EncReadAll                                  */
/*                                                                         */
/***************************************************************************/
void EncReadAll(LONGBYTE *lbEnc)
{
    WORDBYTE wbTransfer;
    unsigned short add;
    short i;
    int max_axes = wAxesInSys;
    unsigned short maxAdd;
    if(max_axes != 8)
      {
        max_axes = 4;
      }

//    static unsigned char byOldByte2[MAX_AXIS];
//    static unsigned char byEncHighByte[MAX_AXIS];

    if (wNoBoardFlag == NO_BOARD)
    {
        for (i = 0; i < 8; i++)
        {
            lbEnc[i].Long = lSimEnc[i];
        }
        return;
    }

    // Disable interrupts here?  No, the timer will latch new data in the
    // hardware anyway.  Maybe we should stop the timer?  In an interrupt
    // service routine, you're synchronized with the timer; so the readings
    // will never change while you're reading them.  If you're polling, you
    // would first latch the encoder counts with the EncoderLatch() function.
    // But, the timer could latch the counts again, in the middle of the read.
    // A critical section will help in some extreme cases.

    // reset counter internal addr ptr to point to first byte
    maxAdd = (wBaseAddress + ((max_axes>4)?CNT6_C:CNT2_D));
    for (add = wBaseAddress + CNT0_C; 
         add <= maxAdd;
         add +=4)
        fOutPW(add, 0x0101);

    for (i = 0; i < 3; i++)            // 24 bits means get 3 bytes each
    {
        wbTransfer.Word = fInPW(wBaseAddress + CNT0_D);

        lbEnc[0].Byte[i] = wbTransfer.Byte.high;
        lbEnc[1].Byte[i] = wbTransfer.Byte.low;

        wbTransfer.Word = fInPW(wBaseAddress + CNT2_D);

        lbEnc[2].Byte[i] = wbTransfer.Byte.high;
        lbEnc[3].Byte[i] = wbTransfer.Byte.low;

        if(max_axes >= 8)
          {
            wbTransfer.Word = fInPW(wBaseAddress + CNT4_D);
            
            lbEnc[4].Byte[i] = wbTransfer.Byte.high;
            lbEnc[5].Byte[i] = wbTransfer.Byte.low;

            wbTransfer.Word = fInPW(wBaseAddress + CNT6_D);
            
            lbEnc[6].Byte[i] = wbTransfer.Byte.high;
            lbEnc[7].Byte[i] = wbTransfer.Byte.low;
          }
    }

    // maintain the high byte, to extend the counter to 32 bits
    //
    // base decisions to increment or decrement the high byte
    // on the highest 2 bits of the 24 bit value.  To get the
    // highest 2 bits, use 0xc0 as a mask on byte [2] (the third
    // byte).

    for (i = 0; i < max_axes; i++)
    {
        // check for -1 to 0 transition

        if (    ( (byOldByte2[i]    & 0xc0) == 0xc0 ) // 11xxxxxx
             && ( (lbEnc[i].Byte[2] & 0xc0) == 0 )    // 00xxxxxx
           )
           byEncHighByte[i]++;

        // check for 0 to -1 transition

        if (    ( (byOldByte2[i]    & 0xc0) == 0 )    // 00xxxxxx
             && ( (lbEnc[i].Byte[2] & 0xc0) == 0xc0 ) // 11xxxxxx
           )
           byEncHighByte[i]--;

        lbEnc[i].Byte[3] = byEncHighByte[i];
        byOldByte2[i] = lbEnc[i].Byte[2];    // current byte 2 becomes old one
    }
};

/***************************************************************************/
/*                                                                         */
/*                          ResetIndexLatch(es)                            */
/*                                                                         */
/***************************************************************************/
void ResetIndexLatch()
{
    // routine for Model 1

    fInP(wBaseAddress + ODDRST);        //lint !e534 reset index pulse latch for ODD axis
    fInP(wBaseAddress + BRDTST);        //lint !e534 reset index pulse latch for EVEN axis
}

void ResetIndexLatches(unsigned char byLatchBits)
{
    // routine for Model 2
    fOutP(wBaseAddress + IDL, byLatchBits);
}

/***************************************************************************/
/*                                                                         */
/*                          SelectIndexAxis                                */
/*                       SelectIndexOrExtLatch                             */
/*                                                                         */
/***************************************************************************/
void SelectIndexAxis(unsigned char byAxis)
{
    // routine for Model 1

    // overloaded function.  Use this if you don't need to set polarity

    SelectIndexAxisWithPolarity(byAxis, byIndexPulsePolarity);
}

void SelectIndexAxisWithPolarity(unsigned char byAxis, unsigned char byPol)
{
    // routine for Model 1

    //
    // initialize stuff to poll index pulse
    //
    unsigned char byIntc;

    byIndexPollAxis = byAxis;           // save axis to check later
    byIndexPulsePolarity = byPol;       // save polarity as new default
    byAxis &= 0x6;                      // ignore low bit, we check 2 axes at a time
    byAxis <<= 3;                       // shift into position for IXS1, IXS0
    byIntc = fInP(wBaseAddress + INTC); // get a copy of INTC, we'll change
                                        // some bits in it, not all
    byIntc &= ~(IXLVL | IXS1 | IXS0);   // zero bits for axis and polarity
    byIntc |= byAxis;                   // put axes address in INTC
    if (byPol != 0)                     // is index pulse active high?
        byIntc |= IXLVL;
    fOutP(wBaseAddress + INTC, byIntc);

    //    ResetIndexLatch();

    // The latched index pulse should be low now.  If it's not, either something's
    // wrong, or we happened to initialize it while the index pulse was active.
}

void SelectIndexOrExtLatch(unsigned char bySelectBits)
{
    // routine for Model 2

    fOutP(wBaseAddress + SELDI, bySelectBits);
}

void EnableCounterLatchOnIndexOrExt(unsigned char bySelectBits)
{
    // routine for Model 2
    fOutP(wBaseAddress + IDLEN, bySelectBits);
}

/***************************************************************************/
/*                                                                         */
/*                             CurrentIRR                                  */
/*                                                                         */
/***************************************************************************/
unsigned char CurrentIRR(void)
{
    fOutP(wBaseAddress + OCW3, 0x0a);           // IRR on next read
    return fInP(wBaseAddress + IRRreg);
}

/***************************************************************************/
/*                                                                         */
/*                        (Get)IndexPulseLatch(es)                         */
/*                                                                         */
/***************************************************************************/
unsigned short IndexPulseLatch(void)
{
    // routine for Model 1 board

    // poll the latched index pulse of the axis that was previously set up

    unsigned char byIRR, byAxisMask;

    byIRR = CurrentIRR();
    byAxisMask = (byIndexPollAxis & 1) ? LIXODD : LIXEVN;  // even or odd axis?
    if (byIRR & byAxisMask)                          // check latched index pulse
        return 1;
    return 0;

    //
    // a faster, but messier way
    //
    //fOutP(wBaseAddress + OCW3, 0x0a);           // IRR on next read
    //
    //return (   fInP(wBaseAddress + IRR)
    //         & ( (byIndexPollAxis & 1) ? LIXODD : LIXEVN ) // mask for even or odd
    //       );
}

unsigned char GetIndexLatches()
{
    // routine for Model 2 board

    return fInP(wBaseAddress + IDL);
}

/***************************************************************************/
/*                                                                         */
/*                                RawDI                                    */
/*                                                                         */
/***************************************************************************/

// some overloaded functions

unsigned long RawDIAll()
{
    IO32 xInBits;

    if (wNoBoardFlag == NO_BOARD)
    {
        xInBits.all = 0;
        return(xInBits.all);
    }

    if (wModel == MODEL1)
    {
        xInBits.port.A = fInP(wBaseAddress + DIO_A);
        xInBits.port.B = fInP(wBaseAddress + DIO_B);
        xInBits.port.C = fInP(wBaseAddress + DIO_C);
        xInBits.port.D = fInP(wBaseAddress + DIO_D);
    }
    else  // Model 2
    {
        xInBits.port.A = fInP(wBaseAddress + PORT_A);
        xInBits.port.B = fInP(wBaseAddress + PORT_B);
        xInBits.port.C = fInP(wBaseAddress + PORT_C);
        xInBits.port.D = fInP(wBaseAddress + PORT_D);
    }
    return (xInBits.all);
};

unsigned char RawDIBitPort(unsigned char byBitNumber, short nPort)
{
    unsigned char nData;

    if (nPort > 3)
        return 0;
    if (wModel == MODEL1)
        nData = fInP(wBaseAddress + aPortOffset_1[nPort]);
    else // Model 2
        nData = fInP(wBaseAddress + aPortOffset_2[nPort]);
    return nData & (1 << byBitNumber);
}

unsigned char RawDIPort(short nPort)
{
    if (nPort > 3)
        return 0;

    if (wModel == MODEL1)
        return fInP(wBaseAddress + aPortOffset_1[nPort]);
    else
        return fInP(wBaseAddress + aPortOffset_2[nPort]);
}

#if 0
unsigned long RawDIPortBit(long lPort, long lBitNumber)
{
    unsigned short wAddOff = 0;
    unsigned char bPortBits;

    switch (lPort)
    {
    case 0: wAddOff = DIO_A;
            break;
    case 1: wAddOff = DIO_B;
            break;
    case 2: wAddOff = DIO_C;
            break;
    case 3: if (wModel == MODEL1)
                wAddOff = DIO_D;
            else
                wAddOff = PORT_D;
            break;
    }
    bPortBits = fInP(wBaseAddress + wAddOff);
    if ( bPortBits & (1 << lBitNumber) )
        return 1;   // true
    return 0;       // false
}
#endif

/***************************************************************************/
/*                                                                         */
/*                                RawDO                                    */
/*                                                                         */
/***************************************************************************/
//
// Overloaded functions:
//    1) takes a 32 bit value and sets all 32 iobits
//    2) takes which bit, which port, and what value, and sets only that bit
//

void RawDOAll(unsigned long lOutBits)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }
    if (wModel == MODEL1)
    {
        fOutP(wBaseAddress + DIO_A, ((IO32 *)&lOutBits)->port.A);
        fOutP(wBaseAddress + DIO_B, ((IO32 *)&lOutBits)->port.B);
        fOutP(wBaseAddress + DIO_C, ((IO32 *)&lOutBits)->port.C);
        fOutP(wBaseAddress + DIO_D, ((IO32 *)&lOutBits)->port.D);
    }
    else  // Model 2
    {
        fOutP(wBaseAddress + PORT_A, ((IO32 *)&lOutBits)->port.A);
        fOutP(wBaseAddress + PORT_B, ((IO32 *)&lOutBits)->port.B);
        fOutP(wBaseAddress + PORT_C, ((IO32 *)&lOutBits)->port.C);
        fOutP(wBaseAddress + PORT_D, ((IO32 *)&lOutBits)->port.D);
    }
};

void RawDOBitValPort(unsigned char byBitNumber, unsigned char bySet0or1,
                      unsigned short nPort)
{
    unsigned nOffset;
    unsigned char byData;

    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    if (nPort > 3)
        return;

    if (wModel == MODEL1)
        nOffset = aPortOffset_1[nPort];
    else  // Model 2
        nOffset = aPortOffset_2[nPort];

    byData = fInP(wBaseAddress + nOffset);
    if (bySet0or1 == 1)
        byData |= 1 << byBitNumber;
    else
        byData &= ~(1u << byBitNumber);
    fOutP(wBaseAddress + nOffset, byData);
};

void RawDOBytePort(unsigned char byData, short nPort)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    if (nPort > 3)
        return;

    if (wModel == MODEL1)
        fOutP(wBaseAddress + aPortOffset_1[nPort], byData);
    else  // Model 2
        fOutP(wBaseAddress + aPortOffset_2[nPort], byData);
};

// these next functions use the same constant that the direction functions,
// DioDirection(...) use.  These are prefered, since the same constant can
// be used in both situations, hopefully simplifying the code.

// helper function
short PortBits2Index(short nPort)
{
    int nPortIndex = 9;

    switch(nPort)
    {
    case STG_PORT_A:
        nPortIndex = 0;
        break;
    case STG_PORT_B:
        nPortIndex = 1;
        break;
    case STG_PORT_C_LO:
    case STG_PORT_C_HI:
    case STG_PORT_C:
        nPortIndex = 2;
        break;
    case STG_PORT_D_LO:
    case STG_PORT_D_HI:
    case STG_PORT_D:
        nPortIndex = 3;
        break;
    }
    return nPortIndex;
}

void DigitalOut1(unsigned char byData, short nPortBits)
{
    RawDOBytePort(byData, PortBits2Index(nPortBits));
}

void DigitalOut2(unsigned char byBitNumber, unsigned char bySet0or1,
                      unsigned short nPortBits)
{
    RawDOBitValPort(byBitNumber, bySet0or1, PortBits2Index(nPortBits));
}

/***************************************************************************/
/*                                                                         */
/*                            DioDirection                                 */
/*                                                                         */
/***************************************************************************/
//
// Two overloaded functions, the first takes a port and a direction, the
// second takes a word with bits set for the direction of each port
//
void DioDirection1(unsigned short nPortBits, unsigned short nDirection)
{
  unsigned short nSwDir;  
  // sometimes you want to set the direction of a port, but may not know
    // what direction other ports are.  Here we select the port (or ports)
    // that we want to set the direction of, in nPortBits.  Then the direction,
    // either input or output, with nDirection.
    //

    assert(nDirection <= 1);      // direction is either 0 or 1
    if (nDirection > 1)
        return;

    nSwDir = wSaveDirs;

    if (nDirection == STG_PORT_OUTPUT)
        nSwDir |= nPortBits;
    else
        nSwDir &= ~nPortBits;

    DioDirection2(nSwDir);
}


//                                        Don't care.
//                                        |<------>|
// bits in nSwDir set direction of ports: xxxxxxxxxxbbbbbb
//                                                  ||||||
//                                                  |||||Port A
//       1 = Output                                 ||||PortB
//       0 = Input                                  |||Port C, high nibble
//                                                  ||Port C, low nibble
//                                                  |Port D (port D, low nibble)
//                                                  |(Port D, high nibble)

void DioDirection2(const unsigned short nSwDir)
{
    unsigned char byHwDir;                   // direction bits for hardware
    unsigned long lCurrentData;

    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    // get the current data in the I/O ports.  We'll replace it when we're
    // done.  When you change a port to output, it will start at what the
    // input was (usually high).  This way, bits won't change (except for a
    // glitch) when a port is set to output.

    lCurrentData = RawDIAll();

    byHwDir = 0x9b;                          // initially all ports input

    if (nSwDir & STG_PORT_A)                 // check the bit for A out
         byHwDir &= ~A_DIR_BIT;                  // if output, set bit to 0
    if (nSwDir & STG_PORT_B)
         byHwDir &= ~B_DIR_BIT;
    if (nSwDir & STG_PORT_C_LO)
         byHwDir &= ~C_LOW_DIR_BIT;
    if (nSwDir & STG_PORT_C_HI)
         byHwDir &= ~C_HI_DIR_BIT;

    fOutP(wBaseAddress + ABC_DIR, byHwDir); // set direction for A, B and C

    SetDDir(nSwDir);
    wSaveDirs = nSwDir;                     // save, mostly for other function
    RawDOAll(lCurrentData);
}

void SetDDir(unsigned short nSwDir)
{
    unsigned char byHwDir;                   // direction bits for hardware
    unsigned char bySaveReg, bySaveIMR, bySaveCntrl1, bySaveCntrl0;

    if (wModel == MODEL1)
    {
        bySaveReg = fInP(wBaseAddress + INTC);   // INTC needs to be saved, because
                                                 // MIO_2 reinitializes the 8255 which
                                                 // implements the INTC register.
        byHwDir = 0x92;                          // initialize port D input
        if (nSwDir & STG_PORT_D)                 // is port D output?
             byHwDir &= ~D_DIR_BIT;              // if yes, set bit to 0,
        bySaveIMR = fInP(wBaseAddress + IMR);    // get the current interrupt mask
        fOutP(wBaseAddress + OCW1, 0xff);        // mask off all interrupts
        fOutP(wBaseAddress + MIO_2, byHwDir);    // set direction for port D
        fOutP(wBaseAddress + INTC, bySaveReg);   // restore interrupt control reg.
        fOutP(wBaseAddress + OCW1, bySaveIMR);   // restore interrupt mask
    }
    else  // Model 2
    {
        bySaveCntrl0 = fInP(wBaseAddress + CNTRL0); // CNTRL0 needs to be saved, because
                                                 // D_DIR reinitializes the 8255 which
                                                 // implements the CNTRL0 register.
        byHwDir = 0x8b;                          // initialize CNTRL0 as output reg.
                                                 // BRDTST to input.
                                                 // sets port D, high and low, to input
        if (nSwDir & STG_PORT_D_LO)              // low nibble
            byHwDir &= ~D_LOW_DIR_BIT;
        if (nSwDir & STG_PORT_D_HI)              // high nibble
            byHwDir &= ~D_HI_DIR_BIT;

        bySaveCntrl1 = fInP(wBaseAddress+CNTRL1);// save for interrupt enables

            // don't reset any latches; put in slave state;
            // disable interrupts, so the glitch in CTRL0 doesn't
            // cause an interrupt on wrong irq
        fOutP(wBaseAddress + CNTRL1, 0xf0);

        fOutP(wBaseAddress + D_DIR, byHwDir);    // set port D direction

            // restore CNTRL0, because it was re-initialized, which
            // lost any previous contents.
        fOutP(wBaseAddress + CNTRL0, bySaveCntrl0);

            // re-enable interrupts, and restore slave state, don't
            // reset any latches. (1111xxxx)
        fOutP(wBaseAddress+CNTRL1, (bySaveCntrl1 & 0x0f) | 0xf0);
    }
};

/***************************************************************************/
/*                                                                         */
/*                               MotSim                                    */
/*                                                                         */
/***************************************************************************/
// a motor simulator
//
// takes it's input from lSimDac[]
// writes it's output to lSimEnc[]
//
// This isn't used in the DOS program, it's only used in the Windows 95 driver

void MotSim(void)
{
    static long lState_1[MAX_AXIS] = {0};                    // state variables
    long lScaledUp;
    const short nScale = 10;
    int nAxis;

    for (nAxis = 0; nAxis < MAX_AXIS; nAxis++)
    {
        // The input is guaranteed to be +/- 12 bits
        // Scale up state so we don't loose resolution
        lScaledUp = lSimDac[nAxis] << nScale;

        // note: I assume right shift is sign preserving (for signed value)

        // lag
        lState_1[nAxis] += (lScaledUp - lState_1[nAxis]) >> (4 + nAxis); //lint !e704
                                                          //   ^^^^^^^ time constant
                                                          // is different for each axis

        // integrator (shift out the scale factor and then some)
        lSimEnc[nAxis] += lState_1[nAxis] >> (nScale + 1);               //lint !e704
    }
}

void AutoZeroAdc(void)
{
    // set the Analog to Digital converter to autozero on each conversion

    if (wModel == MODEL1)
        fOutP(wBaseAddress + INTC, fInP(wBaseAddress + INTC) & ~AUTOZERO);
    else   // MODEL2
        fOutP(wBaseAddress + CNTRL0, fInP(wBaseAddress + CNTRL0) | CNTRL0_AZ);
}

void DontAutoZeroAdc(void)
{
    // set the Analog to Digital converter to NOT autozero

    if (wModel == MODEL1)
        fOutP(wBaseAddress + INTC, fInP(wBaseAddress + INTC) | AUTOZERO);
    else   // MODEL2
        fOutP(wBaseAddress + CNTRL0, fInP(wBaseAddress + CNTRL0) & ~CNTRL0_AZ);
}

void CalADC(void)
{
    // Start calibration cycle on ADC chip

    unsigned char Cntrl0;

    if (wModel == MODEL2)   // this function only in Model 2 board.
    {
        Cntrl0 = fInP(wBaseAddress + CNTRL0) & 0x07;       // save irq
        fOutP(wBaseAddress + CNTRL0, Cntrl0);              // cal is low
        // cal pulse should be 60 ns.  The ISA bus is 10 MHz. or 100 ns.
        // so we can just set it back high.
        fOutP(wBaseAddress + CNTRL0, Cntrl0 | 0x08);       // cal is high
    }
}

/***************************************************************************/
/*                                                                         */
/*                            SetEncoderCounts                             */
/*                                                                         */
/***************************************************************************/
void SetEncoderCounts(unsigned short nAxis, long lCounts)
{
    unsigned short wAddress;
    char *ByteUnion = (char *)&lCounts;  // get pointer to lCounts, so you
                                         // can take it apart byte by byte

    wAddress = wBaseAddress + CNT0_D;
    wAddress += (nAxis & 0x6) << 1; // shift to multiply by 2
                                    // pairs of data regs seperated by pairs
                                    // of control regs, skip over control.
    wAddress += nAxis & 1;
    fOutP(wAddress, ByteUnion[0]);
    fOutP(wAddress, ByteUnion[1]);
    fOutP(wAddress, ByteUnion[2]);

    // transfer the preset register to the count register
    fOutP(wAddress + 2, 0x09);

    // set things for the part that extends the 24 bit counter
    // to 32 bits.
    byEncHighByte[nAxis] = ByteUnion[3];
    byOldByte2[nAxis] = ByteUnion[2];
}

/***************************************************************************/
/*                                                                         */
/*                            EncoderLatch                                 */
/*                                                                         */
/***************************************************************************/
void EncoderLatch(void)
{
#if 0
  unsigned short wAdd;
#endif
    int max_axes = wAxesInSys;
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }
    if(max_axes != 8)
      {
        max_axes = 4;
      }

   // normally you'll have the timer latch the data in hardware, but
   // if the timer isn't running, we need to latch it ourselves.
#if 0
   for ( wAdd = wBaseAddress + CNT0_C; wAdd <= wBaseAddress + CNT6_C; wAdd +=4)
       fOutPW(wAdd, 0x0303);
#endif

  /* BUG FIX-- don't go past 4 axes on 4 axis board */
  fOutPW(wBaseAddress + CNT0_C, 0x0303);
  fOutPW(wBaseAddress + CNT2_C, 0x0303);
  if (max_axes > 4) {
    fOutPW(wBaseAddress + CNT4_C, 0x0303);
    fOutPW(wBaseAddress + CNT6_C, 0x0303);
  }

};

/***************************************************************************/
/*                                                                         */
/*                          EncoderResetAddr                               */
/*                                                                         */
/***************************************************************************/
void EncoderResetAddr(void)
{
  unsigned short wAdd;

    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

   // This function resets all the counter's internal address pointers to point
   // to the first byte in the 3 byte sequence

   for (wAdd = wBaseAddress + CNT0_C; wAdd <= wBaseAddress + CNT6_C; wAdd +=4)
       fOutPW(wAdd, 0x0101);
};

unsigned char GetSELDI()
{
    return fInP(wBaseAddress + SELDI);
}

unsigned char GetIDLEN()
{
    return fInP(wBaseAddress + IDLEN);
}

unsigned char GetCNTRL0()
{
    return fInP(wBaseAddress + CNTRL0);
}

unsigned char GetCNTRL1()
{
    return fInP(wBaseAddress + CNTRL1);
}

void ResetWatchdogLatch()
{
    unsigned char byCntrl1 = fInP(wBaseAddress + CNTRL1);
    byCntrl1 &= ~CNTRL1_WDTOUT;                   //set bit low, to reset
    // don't reset other latches
    byCntrl1 |= CNTRL1_INT_G2 | CNTRL1_INT_T2 | CNTRL1_INT_T0;
    fOutP(wBaseAddress + CNTRL1, byCntrl1);
}

unsigned char GetBRDTST()
{
    return fInP(wBaseAddress + BRDTST);
}

/***************************************************************************/
/*                                                                         */
/*                            IndexPulse                                   */
/*                                                                         */
/***************************************************************************/
short IndexPulse(void)
{
    // poll for the index pulse of the axis that was previously set up.
    // Normally you would look at the latched pulse.  This function will
    // probably only get used during testing.

    unsigned char byIRR, byAxisMask;

    byIRR = CurrentIRR();
    byAxisMask = (byIndexPollAxis & 1) ? IXODD : IXEVN;  // even or odd axis?

    // The raw index pulse isn't inverted by the hardware if the index pulse is
    // low active (only the latched pulse is).  For consistancy, we'll invert
    // the pulse in software.

    if (byIndexPulsePolarity == 0)                       // if pulse is low true
        byIRR ^= byAxisMask;                             // flip bit

    if (byIRR & byAxisMask)                              // check index pulse
        return 1;
    return 0;
}

/***************************************************************************/
/*                                                                         */
/*                             StopTimer                                   */
/*                                                                         */
/***************************************************************************/
void StopTimer()
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    // stop the timer by putting it into one shot mode, it will never get
    // a trigger

    // bug bug this doesn't work

    fOutP(wBaseAddress + TMRCMD, 0x0a);    // timer 0, mode 1
}

/***************************************************************************/
/*                                                                         */
/*                           Timer2 functions                              */
/*                                                                         */
/***************************************************************************/
void Timer2Delay(unsigned short counts)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    StartTimer2TerminalCount(counts);

    while (PollTimer2());
}

void StartTimer2TerminalCount(unsigned short count)
{
  char *pByte;
   if (wNoBoardFlag == NO_BOARD)
   {
       return;
   }

   pByte = (char *)&count;
   fOutP(wBaseAddress + TMRCMD, 0xb0);       // timer 2, read/load LSB followed
                                             // by MSB, mode 0 (terminal count)
   fOutP(wBaseAddress + TIMER_2, *pByte++);  // LSB (little endian)
   fOutP(wBaseAddress + TIMER_2, *pByte);    // MSB
}

void StartTimer2RTI(unsigned short count)
{
  char *pByte;
   if (wNoBoardFlag == NO_BOARD)
   {
       return;
   }

   pByte = (char *)&count;
   fOutP(wBaseAddress + TMRCMD, 0xb4);       // timer 2, read/load LSB followed
                                             // by MSB, mode 2 (real time int).
   fOutP(wBaseAddress + TIMER_2, *pByte++);  // LSB (little endian)
   fOutP(wBaseAddress + TIMER_2, *pByte);    // MSB
}

unsigned short ReadTimer2TerminalCount(void)
{
    unsigned short count;
    char *pByte = (char *)&count;
    fOutP(wBaseAddress + TMRCMD, 0x80);       // timer 2, latch
    *pByte++ = fInP(wBaseAddress + TIMER_2);  // LSB
    *pByte   = fInP(wBaseAddress + TIMER_2);  // MSB
    return count;
}

short PollTimer2(void)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return 0;
    }

    if (wModel == MODEL1)
        return !(CurrentIRR() & TP2);  // mask selects bit for TP2
    else   // MODEL 2
    {
        unsigned char byRegCntrl1, byNewCntrl1;

        byRegCntrl1 = fInP(wBaseAddress + CNTRL1);
        if (byRegCntrl1 & CNTRL1_INT_T2)
        {
            // If it's set, we want to reset the latch, by writing a zero
            // to CNTRL1_INT_T2.

            // When we write to CNTRL1, we don't want to change SLAVE, IEN_G2
            // IEN_T2, or IEN_T0 -- the lower 4 bits.  So, we start with

            byNewCntrl1 = byRegCntrl1 & 0x0f;     // (0000xxxx)

            // We don't want to reset WDTOUT, INT_G2, or INT_T0--we only want
            // to reset ...T2. (1101xxxx)

            byNewCntrl1 |= CNTRL1_WDTOUT | CNTRL1_INT_G2 | CNTRL1_INT_T0;

            fOutP(wBaseAddress + CNTRL1, byNewCntrl1);  // reset bit

            return 1;  // true
        }
    }
    return 0;      // false
}

void MaskTimer2Interrupt()
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }

    if (wModel == MODEL1)
        fOutP(wBaseAddress + OCW1, CurrentIRR() | TP2);
    else   // Model 2
        // we want to save the state of the slave mode, and set the
        // high nibble bits high, so you don't reset any latches.
        // bit pattern: 1111x000  where x is don't change
        fOutP(wBaseAddress + CNTRL1,
            (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | 0xf0);
}

void UnMaskTimer2Interrupt()
{
    if (wModel == MODEL1)
        fOutP(wBaseAddress + OCW1, CurrentIRR() & ~TP2);
    else   // Model 2
    {
        // we want to save the state of the slave mode, and set the
        // high nibble bits high, so you don't reset any latches.
        // bit pattern: 1111x010 where x is don't change
        fOutP(wBaseAddress + CNTRL1,
            (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | CNTRL1_IEN_T2);
    }
}

/***************************************************************************/
/*                                                                         */
/*                           StartInterrupts                               */
/*                                                                         */
/***************************************************************************/
void StartInterrupts(void)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }
    if (wModel == MODEL1)
        fOutP(wBaseAddress + OCW1, ~0x04);   // enable interrupt for timer 0
    else  // MODEL2
        // we want to save the state of the slave mode, and set the
        // high nibble bits high, so you don't reset any latches.
        // 1111x001, where x means don't change
    {
        fOutP(wBaseAddress + CNTRL1, CNTRL1_IEN_T0 | CNTRL1_NOT_SLAVE);
    }
};

/***************************************************************************/
/*                                                                         */
/*                           StopInterrupts                                */
/*                                                                         */
/***************************************************************************/
void  StopInterrupts(void)
{
    if (wNoBoardFlag == NO_BOARD)
    {
        return;
    }
    if (wModel == MODEL1)
        fOutP(wBaseAddress + OCW1, 0xff);     // disable all interrupts
    else  // MODEL2
        // we want to save the state of the slave mode, and set the
        // high nibble bits high, so you don't reset any latches.
        // disable all interrupts, since only one can be enabled at
        // a time (currently).  If more than one was enabled, it's
        // an error (currently).
        // 1111x000, where x means not changed.
        fOutP(wBaseAddress + CNTRL1,
            (fInP(wBaseAddress + CNTRL1) & CNTRL1_NOT_SLAVE) | 0xf0);
};

---