/*

 Description

    This module provides support for a multiple device port driver. To

    initialize the driver, the method drvAsynKeithley6485() is called from the

    startup script with the following calling sequence.

        drvAsynKeithley6485(myport,ioport,ioaddr)

        Where:

            myport - Keithley6485 Asyn interface port driver name (i.e. "EP0" )

            ioport - Communication port driver name (i.e. "S0" )

            ioaddr - Communication port device addr

    The method dbior can be called from the IOC shell to display the current

    status of the driver.

*/

/* System related include files */

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

/* EPICS system related include files */

#include <iocsh.h>

#include <epicsStdio.h>

#include <cantProceed.h>

#include <epicsString.h>

#include <epicsExport.h>

#include <errlog.h>

/* EPICS synApps/Asyn related include files */

#include <asynDriver.h>

#include <asynDrvUser.h>

#include <asynInt32.h>

#include <asynFloat64.h>

#include <asynOctet.h>

#include <asynOctetSyncIO.h>

#include <asynStandardInterfaces.h>

/* Define symbolic constants */

#define TIMEOUT         (5.0)

#define BUFFER_SIZE     (100)

typedef enum {Octet=1, Float64=2, Int32=3} Type;

static const char *driver = "drvAsynKeithley648x";      /* String for asynPrint */

/* Declare port driver structure */

struct Port

{

  int devtype; // 1:6485, 2:6487

  char* myport;

  char* ioport;

  int ioaddr;

  int init; // really needed??

  char model[BUFFER_SIZE+1], *serial, *dig_rev, *disp_rev, *brd_rev;

  struct

  {

    int ioErrors;

    int writeReads;

    int writeOnlys;

  } stats;

  struct

  {

    double reading;

    int timestamp;

    union 

    {

      int raw;

      struct 

      {

        unsigned int overflow             : 1;

        unsigned int filter_enabled       : 1;

        unsigned int math_enabled         : 1;

        unsigned int null_enabled         : 1;

        unsigned int limit_test           : 1;

        unsigned int limit_result         : 2;

        unsigned int overvoltage          : 1;

        unsigned int padding              : 1;

        unsigned int zero_check_enabled   : 1;

        unsigned int zero_correct_enabled : 1;

      } bits;

    } status;

    /* 

       Bits:

       0 (OFLO)   — Set to 1 if measurement performed while in over-range 

                    (overflowed reading).

       1 (Filter) — Set to 1 when measurement performed with the averaging 

                    filter enabled.

       2 (Math)   — Set to 1 when measurement performed with CALC1 enabled.

       3 (Null)   — Set to 1 if null for CALC2 is enabled.

       4 (Limits) — Set to 1 if a limit test (CALC2) is enabled.

       5 & 6 (Limit Results) — Provides limit test results:

                Bit 6    Bit 5   

                  0        0      All limit tests passed

                  0        1      CALC2:LIM1 test failed

                  1        0      CALC2:LIM2 test failed

       7 (Overvoltage)  — Set to 1 if measurement performed with an 

                          overvoltage condition on the input.

       9 (Zero Check)   — Set to 1 when zero check is enabled.

      10 (Zero Correct) — Set to 1 when zero correct is enabled.

    */

    int eom;

  } data;

  /* Asyn info */

  asynUser *pasynUser;

  asynUser *pasynUserTrace;  /* asynUser for asynTrace on this port */

  asynStandardInterfaces asynStdInterfaces;

};

struct Command

{

  const char *tag;

  int dev;

  int type;

  int id;

};

/* Declare command structure */

struct GenCommand

{

  asynStatus (*readFunc)(int which, Port *pport, void* data, Type Iface, 

                         size_t *length, int *eom);

  asynStatus (*writeFunc)(int which, Port *pport, void* data, Type Iface);

};

struct SimpleCommand

{

  int type;

  const char *cmd_str;

};

/* Public interface forward references */

int drvAsynKeithley648x(const char* myport,const char* ioport, int ioaddr);

/* Forward references for asynCommon methods */

static void report(void* ppvt,FILE* fp,int details);

static asynStatus connect(void* ppvt,asynUser* pasynUser);

static asynStatus disconnect(void* ppvt,asynUser* pasynUser);

static asynCommon ifaceCommon = {report,connect,disconnect};

/* Forward references for asynDrvUser methods */

static asynStatus create(void* ppvt,asynUser* pasynUser,const char* drvInfo,

                         const char** pptypeName,size_t* psize);

static asynStatus destroy(void* ppvt,asynUser* pasynUser);

static asynStatus gettype(void* ppvt,asynUser* pasynUser,

                          const char** pptypeName,size_t* psize);

static asynDrvUser ifaceDrvUser = {create,gettype,destroy};

/* Forward references for asynFloat64 methods */

static asynStatus readFloat64(void* ppvt,asynUser* pasynUser,

                              epicsFloat64* value);

static asynStatus writeFloat64(void* ppvt,asynUser* pasynUser,

                               epicsFloat64 value);

static asynFloat64 ifaceFloat64 = {writeFloat64, readFloat64};

/* Forward references for asynInt32 methods */

static asynStatus readInt32(void* ppvt,asynUser* pasynUser,epicsInt32* value);

static asynStatus writeInt32(void* ppvt,asynUser* pasynUser,epicsInt32 value);

static asynInt32 ifaceInt32 =  {writeInt32, readInt32};

/* Forward references for asynOctet methods */

static asynStatus flushOctet( void* ppvt, asynUser* pasynUser);

static asynStatus writeOctet( void* ppvt, asynUser* pasynUser, const char *data,

                              size_t numchars, size_t* nbytes);

static asynStatus readOctet( void* ppvt, asynUser* pasynUser, char* data,

                             size_t maxchars, size_t *nbytes, int *eom);

static asynOctet ifaceOctet = { writeOctet, readOctet, flushOctet};

/* Forward references for external asynOctet interface */

static asynStatus writeOnly(Port* pport, const char* outBuf);

static asynStatus writeRead(Port* pport, const char* outBuf, char* inpBuf,

                            int inputSize, int *eomReason);

static asynStatus readDummy(int which, Port *pport, void *data, Type Iface, 

                            size_t *length, int *eom);

static asynStatus writeDummy(int which, Port *pport, void* data, Type Iface);

static asynStatus readSimpleData( int which, Port *pport, void *data, 

                                  Type Iface, size_t *length, int *eom);

static asynStatus writeSimpleData( int which, Port *pport, void *data, 

                                   Type Iface);

static asynStatus readCache(int which, Port *pport, void *data, 

                            Type Iface, size_t *length, int *eom);

static asynStatus readSensorReading(int which, Port *pport, void* data, 

                                    Type Iface, size_t *length, int *eom);

static asynStatus readRange(int which, Port *pport, void* data, 

                            Type Iface, size_t *length, int *eom);

static asynStatus writeRange(int which, Port *pport, void* data, Type Iface);

static asynStatus readRate(int which, Port *pport, void* data, 

                           Type Iface, size_t *length, int *eom);

static asynStatus writeRate(int which, Port *pport, void* data, Type Iface);

static asynStatus readVoltageSettings(int which, Port *pport, void* data, 

                                            Type Iface, size_t *length, int *eom);

static asynStatus writeVoltageSettings(int which, Port *pport, void* data, 

                                              Type Iface);

static asynStatus readCommon(int which, Port *pport, void* data, 

                             Type Iface, size_t *length, int *eom);

static asynStatus writeCommon(int which, Port *pport, void* data, Type Iface);

// General commands that need special attention go here

enum { VOID_CMD, READ_CMD, RANGE_CMD, RANGE_AUTO_ULIMIT_CMD, 

       RANGE_AUTO_LLIMIT_CMD, RATE_CMD, DIGITAL_FILTER_CONTROL_CMD,

       VOLTAGE_RANGE_CMD, VOLTAGE_CURRENT_LIMIT_CMD,      GEN_CMD_NUMBER };

static GenCommand genCommandTable[GEN_CMD_NUMBER] = 

  {

    { readDummy,           writeDummy},     // VOID

    { readSensorReading,   writeDummy},     // READ

    { readRange,           writeRange},     // RANGE

    { readRange,           writeRange},     // RANGE_AUTO_ULIMIT

    { readRange,           writeRange},     // RANGE_AUTO_LLIMIT

    { readRate,            writeRate},      // RATE

    { readCommon,          writeCommon},    // DIGITAL_FILTER_CONTROL

    { readVoltageSettings, writeVoltageSettings}, // VOLTAGE_RANGE_COMMAND

    { readVoltageSettings, writeVoltageSettings}, // VOLTAGE_CURRENT_LIMIT_COMMAND

  };

// commands that are very simple-minded go here

enum { RESET_CMD, RANGE_AUTO_CMD,

       ZERO_CHECK_CMD, ZERO_CORRECT_CMD, ZERO_CORRECT_ACQUIRE_CMD, 

       MEDIAN_FILTER_CMD, MEDIAN_FILTER_RANK_CMD, 

       DIGITAL_FILTER_CMD, DIGITAL_FILTER_COUNT_CMD, 

       VOLTAGE_CMD, VOLTAGE_STATE_CMD, VOLTAGE_10V_INTERLOCK_CMD, VOLTAGE_INTERLOCK_STATUS_CMD,

       SIMPLE_CMD_NUMBER};

enum { SIMPLE_TRIGGER=0, SIMPLE_OCTET=Octet, SIMPLE_FLOAT64=Float64, 

       SIMPLE_INT32=Int32 };

static SimpleCommand simpleCommandTable[SIMPLE_CMD_NUMBER] = 

  {

    { SIMPLE_TRIGGER, "*RST"},                // RESET DEVICE

    { SIMPLE_INT32,   ":RANGE:AUTO"},         // RANGE_AUTO

    { SIMPLE_INT32,   "SYST:ZCH"},            // ZERO CHECK

    { SIMPLE_INT32,   "SYST:ZCOR"},           // ZERO CORRECT

    { SIMPLE_TRIGGER, "SYST:ZCOR:ACQ"},       // ZERO CORRECT ACQUIRE

    { SIMPLE_INT32,   "MED"},                 // MEDIAN FILTER

    { SIMPLE_INT32,   "MED:RANK"},            // MEDIAN FILTER RANK

    { SIMPLE_INT32,   "AVER"},                // DIGITAL FILTER

    { SIMPLE_INT32,   "AVER:COUN"},           // DIGITAL FILTER COUNT

    { SIMPLE_FLOAT64, "SOUR:VOLT"},           // VOLTAGE

    { SIMPLE_INT32,   "SOUR:VOLT:STAT"},      // VOLTAGE STATE

    { SIMPLE_INT32,   "SOUR:VOLT:INT"},       // VOLTAGE 10V INTERLOCK

    { SIMPLE_INT32,   "SOUR:VOLT:INT:FAIL"},  // VOLTAGE INTERLOCK STATUS

    // { SIMPLE_INT32,   "AVER:"},      // 

    // { SIMPLE_INT32,   "AVER:"},      // 

  };

enum { TIMESTAMP_CMD, STATUS_RAW_CMD, STATUS_OVERFLOW_CMD, STATUS_FILTER_CMD, 

       STATUS_MATH_CMD, STATUS_NULL_CMD, STATUS_LIMITS_CMD, 

       STATUS_OVERVOLTAGE_CMD, STATUS_ZERO_CHECK_CMD, STATUS_ZERO_CORRECT_CMD,

       MODEL_CMD, SERIAL_CMD, DIG_REV_CMD, DISP_REV_CMD, BRD_REV_CMD, 

       CACHE_CMD_NUMBER };

#define COMMAND_NUMBER (GEN_CMD_NUMBER + SIMPLE_CMD_NUMBER + CACHE_CMD_NUMBER)

enum { CMD_GEN, CMD_SIMPLE, CMD_CACHE };

enum { DEV_ALL, DEV_6485, DEV_6487};

static Command commandTable[ COMMAND_NUMBER ] = 

  {

    { "VOID",                     DEV_ALL,  CMD_GEN,    VOID_CMD                     },

    { "READ",                     DEV_ALL,  CMD_GEN,    READ_CMD                     },

    { "RANGE",                    DEV_ALL,  CMD_GEN,    RANGE_CMD                    },

    { "RANGE_AUTO_ULIMIT",        DEV_ALL,  CMD_GEN,    RANGE_AUTO_ULIMIT_CMD        },

    { "RANGE_AUTO_LLIMIT",        DEV_ALL,  CMD_GEN,    RANGE_AUTO_LLIMIT_CMD        },

    { "RATE",                     DEV_ALL,  CMD_GEN,    RATE_CMD                     },

    { "DIGITAL_FILTER_CONTROL",   DEV_ALL,  CMD_GEN,    DIGITAL_FILTER_CONTROL_CMD   },

    { "VOLTAGE_RANGE",            DEV_6487, CMD_GEN,    VOLTAGE_RANGE_CMD            },

    { "VOLTAGE_CURRENT_LIMIT",    DEV_6487, CMD_GEN,    VOLTAGE_CURRENT_LIMIT_CMD    },

    { "RESET",                    DEV_ALL,  CMD_SIMPLE, RESET_CMD                    },

    { "RANGE_AUTO",               DEV_ALL,  CMD_SIMPLE, RANGE_AUTO_CMD               },

    { "ZERO_CHECK",               DEV_ALL,  CMD_SIMPLE, ZERO_CHECK_CMD               },

    { "ZERO_CORRECT",             DEV_ALL,  CMD_SIMPLE, ZERO_CORRECT_CMD             },

    { "ZERO_CORRECT_ACQUIRE",     DEV_ALL,  CMD_SIMPLE, ZERO_CORRECT_ACQUIRE_CMD     },

    { "MEDIAN_FILTER",            DEV_ALL,  CMD_SIMPLE, MEDIAN_FILTER_CMD            },

    { "MEDIAN_FILTER_RANK",       DEV_ALL,  CMD_SIMPLE, MEDIAN_FILTER_RANK_CMD       },

    { "DIGITAL_FILTER",           DEV_ALL,  CMD_SIMPLE, DIGITAL_FILTER_CMD           },

    { "DIGITAL_FILTER_COUNT",     DEV_ALL,  CMD_SIMPLE, DIGITAL_FILTER_COUNT_CMD     },

    { "VOLTAGE",                  DEV_6487, CMD_SIMPLE, VOLTAGE_CMD                  },

    { "VOLTAGE_STATE",            DEV_6487, CMD_SIMPLE, VOLTAGE_STATE_CMD            },

    { "VOLTAGE_TENV_INTERLOCK",   DEV_6487, CMD_SIMPLE, VOLTAGE_10V_INTERLOCK_CMD    },

    { "VOLTAGE_INTERLOCK_STATUS", DEV_6487, CMD_SIMPLE, VOLTAGE_INTERLOCK_STATUS_CMD },

    { "MODEL",                    DEV_ALL,  CMD_CACHE,  MODEL_CMD                    },

    { "SERIAL",                   DEV_ALL,  CMD_CACHE,  SERIAL_CMD                   },

    { "DIG_REV",                  DEV_ALL,  CMD_CACHE,  DIG_REV_CMD                  },

    { "DISP_REV",                 DEV_ALL,  CMD_CACHE,  DISP_REV_CMD                 },

    { "BRD_REV",                  DEV_ALL,  CMD_CACHE,  BRD_REV_CMD                  },

    { "TIMESTAMP",                DEV_ALL,  CMD_CACHE,  TIMESTAMP_CMD                },

    { "STATUS_RAW",               DEV_ALL,  CMD_CACHE,  STATUS_RAW_CMD               },

    { "STATUS_OVERFLOW",          DEV_ALL,  CMD_CACHE,  STATUS_OVERFLOW_CMD          },

    { "STATUS_FILTER",            DEV_ALL,  CMD_CACHE,  STATUS_FILTER_CMD            },

    { "STATUS_MATH",              DEV_ALL,  CMD_CACHE,  STATUS_MATH_CMD              },

    { "STATUS_NULL",              DEV_ALL,  CMD_CACHE,  STATUS_NULL_CMD              },

    { "STATUS_LIMITS",            DEV_ALL,  CMD_CACHE,  STATUS_LIMITS_CMD            },

    { "STATUS_OVERVOLTAGE",       DEV_ALL,  CMD_CACHE,  STATUS_OVERVOLTAGE_CMD       },

    { "STATUS_ZERO_CHECK",        DEV_ALL,  CMD_CACHE,  STATUS_ZERO_CHECK_CMD        },

    { "STATUS_ZERO_CORRECT",      DEV_ALL,  CMD_CACHE,  STATUS_ZERO_CORRECT_CMD      },

  };

/****************************************************************************

 * Define public interface methods

 ****************************************************************************/

int drvAsynKeithley648x(const char *type, const char *myport,

                        const char *ioport, int ioaddr)

{

  int status = asynSuccess;

  Port* pport;

  //  int i;

  asynStandardInterfaces *pInterfaces;

  char inpBuf[BUFFER_SIZE];

  int eomReason;

  pport = (Port*)callocMustSucceed(1,sizeof(Port),"drvAsynKeithley6485");

  pport->myport = epicsStrDup(myport);

  pport->ioport = epicsStrDup(ioport);

  pport->ioaddr = ioaddr;

  pport->devtype = DEV_ALL;

  if( !strcmp("6485", type))

    pport->devtype = DEV_6485;

  if( !strcmp("6487", type))

    pport->devtype = DEV_6487;

  if(pport->devtype == DEV_ALL) // DEV_ALL is not a real device

    {

      errlogPrintf("%s::drvAsynKeithley6485 type has to be "

                   "either \'6485\' or \'6487\'.\n", driver);

      return asynError;

    }

  status = pasynOctetSyncIO->connect(ioport,ioaddr,&pport->pasynUser,NULL);

  if (status != asynSuccess)

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s can't connect "

                   "to asynCommon on Octet server %s address %d.\n",

                   driver, myport, ioport, ioaddr);

      return asynError;

    }

  /* Create asynUser for asynTrace */

  pport->pasynUserTrace = pasynManager->createAsynUser(0, 0);

  pport->pasynUserTrace->userPvt = pport;

  status = pasynManager->registerPort(myport,ASYN_CANBLOCK,1,0,0);

  if( status != asynSuccess) 

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s can't register port\n",

                   driver, myport);

      return asynError;

    }

  pInterfaces = &pport->asynStdInterfaces;

  /* Initialize interface pointers */

  pInterfaces->common.pinterface    = (void *)&ifaceCommon;

  pInterfaces->drvUser.pinterface   = (void *)&ifaceDrvUser;

  pInterfaces->octet.pinterface     = (void *)&ifaceOctet;

  pInterfaces->int32.pinterface     = (void *)&ifaceInt32;

  pInterfaces->float64.pinterface   = (void *)&ifaceFloat64;

  status = pasynStandardInterfacesBase->initialize(myport, pInterfaces,

                                                   pport->pasynUserTrace, 

                                                   pport);

  if (status != asynSuccess) 

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s"

                   " can't register standard interfaces: %s\n",

                   driver, myport, pport->pasynUserTrace->errorMessage);

      return asynError;

    }

#ifdef vxWorks

  /* Send a sacrificial clear status to vxworks device (i.e. VME)*/

  /* This fixes a problem with *IDN? call when starting from a cold boot */

  /* with the SBS IP-Octal hardware. */

  if( writeOnly(pport,"") )

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s failed to write\n",

                   driver, myport);

      return asynError;

    }

#endif

  /* Reset device */

  if( writeOnly(pport,"*CLS") )

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s failed to clear\n",

                   driver, myport);

      return asynError;

    }

  /* Identification query */

  if( writeRead(pport,"*IDN?",inpBuf,sizeof(inpBuf),&eomReason) )

    {

      errlogPrintf("%s::drvAsynKeithley6485 port %s failed to "

                   "acquire identification\n", driver, myport);

      return asynError;

    }

  strcpy(pport->model,inpBuf);

  // char *model, *serial, *dig_rev, *disp_rev, *brd_rev;

  pport->serial = strchr( pport->model, ',');

  pport->serial = strchr( pport->serial + 1, ',');

  *(pport->serial) = '\0';

  pport->serial++;

  pport->dig_rev = strchr( pport->serial, ',');

  *(pport->dig_rev) = '\0';

  pport->dig_rev++;

  pport->disp_rev = strchr( pport->dig_rev, '/');

  *(pport->disp_rev) = '\0';

  pport->disp_rev++;

  pport->brd_rev = strchr( pport->disp_rev, '/');

  *(pport->brd_rev) = '\0';

  pport->brd_rev++;

  /* Complete initialization */

  pport->init=1;

  pport->data.reading = 0.0;

  pport->data.timestamp = 0;

  pport->data.status.raw = 0;

  return asynSuccess;

}

/****************************************************************************

 * Define private read and write parameter methods

 ****************************************************************************/

static asynStatus readDummy(int which, Port *pport, void *data, Type Iface, 

                            size_t *length, int *eom)

{

  return asynSuccess;

}

static asynStatus writeDummy(int which, Port *pport, void *data, Type Iface)

{

  return asynSuccess;

}

///

static asynStatus readSimpleData( int which, Port *pport, void *data, 

                                  Type Iface, size_t *length, int *eom)

{

  asynStatus status;

  char outBuf[BUFFER_SIZE];

  char inpBuf[BUFFER_SIZE];

  int len;

  // Trigger will automatically not work

  if( simpleCommandTable[which].type != Iface)

    return asynSuccess;

  sprintf( outBuf, "%s?", simpleCommandTable[which].cmd_str);

  status = writeRead( pport, outBuf, inpBuf, BUFFER_SIZE, &pport->data.eom);

  if( status != asynSuccess)

    return status;

  switch( Iface)

    {

    case Float64:

      *((epicsFloat64 *) data) = atof(inpBuf);

      break;

    case Int32:

      *((epicsInt32 *) data) = atoi(inpBuf);

      break;

    case Octet:

      len = strlen( inpBuf);

      if( len > 39)

        inpBuf[39] = '\0';

      strcpy( (char *) data, inpBuf);

      break;

    }

  return asynSuccess;

}

static asynStatus writeSimpleData( int which, Port *pport, void *data, 

                                    Type Iface)

{

  char outBuf[BUFFER_SIZE];

  if( simpleCommandTable[which].type == SIMPLE_TRIGGER )

    sprintf( outBuf, "%s", simpleCommandTable[which].cmd_str);

  else

    {

      if( simpleCommandTable[which].type != Iface )

        return asynSuccess;

      switch( simpleCommandTable[which].type & Iface)

        {

        case Float64:

          sprintf( outBuf, "%s %g", simpleCommandTable[which].cmd_str, 

                   *((epicsFloat64*) data) );

          break;