vxTIInterruptService.cc

Go to the documentation of this file.

/*----------------------------------------------------------------------------*
*  Copyright (c) 2005        Southeastern Universities Research Association, *
*                            Thomas Jefferson National Accelerator Facility  *
*                                                                            *
*    This software was developed under a United States Government license    *
*    described in the NOTICE file included as part of this distribution.     *
*                                                                            *
*    E.Wolin, 26-Apr-2005, Jefferson Lab                                     *
*                                                                            *
*    Authors: Elliott Wolin                                                  *
*             wolin@jlab.org                    Jefferson Lab, MS-6B         *
*             Phone: (757) 269-7365             12000 Jefferson Ave.         *
*             Fax:   (757) 269-5519             Newport News, VA 23606       *
*                                                                            *
*----------------------------------------------------------------------------*/


#include <vxTIInterruptService.hxx>


using namespace std;
using namespace codaObject;



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------


namespace codaObject {

  static int dispatcher(int ptr) {
    return ((vxTIInterruptService*)ptr)->dispatchInterrupt();
  }
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------


vxTIInterruptService::vxTIInterruptService(unsigned short *base_addr, int dispatchPriority, int interruptLevel, short interruptVector) 
  : myBaseAddr(base_addr), myInterruptTaskId(0), mySemId(NULL),
    myDispatchPriority(dispatchPriority), myInterruptLevel(interruptLevel),
    myInterruptVector(interruptVector) {
}


//-----------------------------------------------------------------------------


vxTIInterruptService::~vxTIInterruptService(void) throw() {
  deleteInterrupt();
}


//-----------------------------------------------------------------------------


void vxTIInterruptService::ISR(int sem) {
  semGive((SEM_ID)sem);
}
  

//-----------------------------------------------------------------------------


int vxTIInterruptService::dispatchInterrupt(void) {
  
  unsigned int trigType;
  
  // loop forever
  while(true) {
    
      // sleep on semaphore
    semTake((SEM_ID)mySemId,WAIT_FOREVER);
    
    // read 8-bit trigger type
    trigType = (*((volatile unsigned short*)(myAddr+3)))&0xff;
    
    // call user interrupt routine if specified
    if(myIntObj!=NULL)myIntObj->interrupt(trigType);

    // reenable interrupt
    *(myAddr+2)=TI_INTERRUPT_REENABLE;
  }
}


//-----------------------------------------------------------------------------


bool vxTIInterruptService::setupInterrupt(void) {

    // get local address
    sysBusToLocalAdrs(TI_VME_ACCESS_MODE,(char*)myBaseAddr,(char**)&myAddr);
    
    // reset board
    *(myAddr+0)=TI_RESET;
    
    // set interrupt vector
    *(myAddr+1)=TI_INTERRUPT_VECTOR;

    // create new semaphore
    mySemId = semBCreate(SEM_Q_FIFO,SEM_EMPTY);

    // disconnect current interrupt service routine
    intDisconnect((int)INUM_TO_IVEC(TI_INTERRUPT_VECTOR));

    // connect new interrupt service routine
    intConnect(INUM_TO_IVEC(TI_INTERRUPT_VECTOR),(void(*)(...))&ISR,(int)mySemId);

    // spawn task waiting on semaphore
    myInterruptTaskId = taskSpawn("tiIntHandler",myDispatchPriority,0,20000,(int(*)(...))&dispatcher,
                                  (int)this,0,0,0,0, 0,0,0,0,0);
    
    return(true);
}


//-----------------------------------------------------------------------------


bool vxTIInterruptService::enableInterrupt(void) {


  // enable hardware interrupts
  sysIntEnable(TI_INTERRUPT_LEVEL);


  // enable external triggers
  *(myAddr+0)=TI_MODE;

  return(true);
}


//-----------------------------------------------------------------------------


bool vxTIInterruptService::deleteInterrupt(void) {

  // disable triggers and interrupts (pause might be 0x5)
  *(myAddr+0)=0;
  

  // disconnect interrupt service routine
  intDisconnect((int)INUM_TO_IVEC(TI_INTERRUPT_VECTOR));


  // delete interrupt task
  if(myInterruptTaskId!=0) {
    taskDelete(myInterruptTaskId);
    myInterruptTaskId=0;
  }


  // delete semaphore
  if(mySemId!=NULL) {
    semDelete(mySemId);
    mySemId=NULL;
  }

  return(true);
}
  

//-----------------------------------------------------------------------------

---