drvemIocsh.h File Reference

#include <initHooks.h>
#include <shareLib.h>

Include dependency graph for drvemIocsh.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void epicsShareFunc	mrmEvrSetupPCI (const char *id, const char *pcispec)
void epicsShareFunc	mrmEvrSetupVME (const char *id, int slot, int base, int level, int vector)
void epicsShareFunc	mrmEvrDumpMap (const char *id, int evt, int ram)
void epicsShareFunc	mrmEvrForward (const char *id, const char *events_iocsh)
	Setup Event forwarding to downstream link. More...
void epicsShareFunc	mrmEvrLoopback (const char *id, int rxLoopback, int txLoopback)
void epicsShareFunc	mrmEvrInithooks (initHookState state)
long epicsShareFunc	mrmEvrReport (int level)
void epicsShareFunc	mrmEvrProbe (const char *id)

Variables
epicsShareExtern int	evrmrmVerb
	Extra noise control. More...

Function Documentation

mrmEvrDumpMap()

void epicsShareFunc mrmEvrDumpMap	(	const char *	id,
		int	evt,
		int	ram
	)

Definition at line 870 of file drvemSetup.cpp.

{
try {
    mrf::Object *obj=mrf::Object::getObject(id);
    if(!obj)
        throw std::runtime_error("Object not found");
    EVRMRM *card=dynamic_cast<EVRMRM*>(obj);
    if(!card)
        throw std::runtime_error("Not a MRM EVR");

    printf("Print ram #%d\n",ram);
    if(evt>=0){
        // Print a single event
        printRamEvt(card,evt,ram);
        return;
    }
    for(evt=0;evt<=255;evt++){
        printRamEvt(card,evt,ram);
    }
} catch(std::exception& e) {
    printf("Error: %s\n",e.what());
}
}

mrmEvrForward()

void epicsShareFunc mrmEvrForward	(	const char *	id,
		const char *	events_iocsh
	)

Setup Event forwarding to downstream link.

Control which events will be forwarded to the downstream event link when they are received on the upstream link. Useful when daisy chaining EVRs.

When invoked with the second argument as NULL or "" the current forward mapping is printed.

The second argument to this function is a comma seperated list of event numbers and/or the special token 'all'. If a token is prefixed with '-' then the mapping is cleared, otherwise it is set.

After a cold boot, no events are forwarded until/unless mrmrEvrForward is called.

> mrmEvrForward("EVR1") # Prints current mappings
Events forwarded: ...
> mrmEvrForward("EVR1", "-all") # Clear all forward mappings
# Clear all forward mappings except timestamp transmission
> mrmEvrForward("EVR1", "-all, 0x70, 0x71, 0x7A, 0x7D")
# Forward all except 42
> mrmEvrForward("EVR1", "all, -42")

Parameters

id	EVR identifier
events	A string with a comma seperated list of event specifiers

Definition at line 924 of file drvemSetup.cpp.

{
    char *events=events_iocsh ? epicsStrDup(events_iocsh) : 0;
try {
    mrf::Object *obj=mrf::Object::getObject(id);
    if(!obj)
        throw std::runtime_error("Object not found");
    EVRMRM *card=dynamic_cast<EVRMRM*>(obj);
    if(!card)
        throw std::runtime_error("Not a MRM EVR");

    if(!events || strlen(events)==0) {
        // Just print current mappings
        printf("Events forwarded: ");
        for(unsigned int i=1; i<256; i++) {
            if(card->specialMapped(i, ActionEvtFwd)) {
                printf("%d ", i);
            }
        }
        printf("\n");
        free(events);
        return;
    }

    // update mappings

    const char sep[]=", ";
    char *save=0;

    for(char *tok=strtok_r(events, sep, &save);
        tok!=NULL;
        tok = strtok_r(0, sep, &save)
        )
    {
        if(strcmp(tok, "-all")==0) {
            for(unsigned int i=1; i<256; i++)
                card->specialSetMap(i, ActionEvtFwd, false);

        } else if(strcmp(tok, "all")==0) {
            for(unsigned int i=1; i<256; i++)
                card->specialSetMap(i, ActionEvtFwd, true);

        } else {
            char *end=0;
            long e=strtol(tok, &end, 0);
            if(*end || e==LONG_MAX || e==LONG_MIN) {
                printf("Unable to parse event spec '%s'\n", tok);
            } else if(e>255 || e<-255 || e==0) {
                printf("Invalid event %ld\n", e);
            } else if(e>0) {
                card->specialSetMap(e, ActionEvtFwd, true);
            } else if(e<0) {
                card->specialSetMap(-e, ActionEvtFwd, false);
            }

        }
    }


    free(events);
} catch(std::exception& e) {
    printf("Error: %s\n",e.what());
    free(events);
}
}

mrmEvrInithooks()

void epicsShareFunc mrmEvrInithooks

(

initHookState

state

)

Definition at line 722 of file drvemSetup.cpp.

{
    epicsUInt8 lvl;
    switch(state)
    {
    case initHookAfterInterruptAccept:
        // Register hook to disable interrupts on IOC shutdown
        epicsAtExit(&evrShutdown, NULL);
        // First enable interrupts for each EVR
        mrf::Object::visitObjects(&enableIRQ,0);
        // Then enable all used levels
        for(lvl=1; lvl<=7; ++lvl)
        {
            if (vme_level_mask&(1<<(lvl-1))) {
                if(devEnableInterruptLevelVME(lvl))
                {
                    printf("Failed to enable interrupt level %d\n",lvl);
                    return;
                }
            }

        }

        break;
  default:
        break;
    }
}

mrmEvrLoopback()

void epicsShareFunc mrmEvrLoopback	(	const char *	id,
		int	rxLoopback,
		int	txLoopback
	)

Definition at line 992 of file drvemSetup.cpp.

{
try {
    mrf::Object *obj=mrf::Object::getObject(id);
    if(!obj)
        throw std::runtime_error("Object not found");
    EVRMRM *card=dynamic_cast<EVRMRM*>(obj);
    if(!card){
        throw std::runtime_error("Not a MRM EVR");
    }

    epicsUInt32 control = NAT_READ32(card->base,Control);
    control &= ~(Control_txloop|Control_rxloop);
    if (rxLoopback) control |= Control_rxloop;
    if (txLoopback) control |= Control_txloop;
    NAT_WRITE32(card->base,Control, control);

} catch(std::exception& e) {
    printf("Error: %s\n",e.what());
}
}

mrmEvrProbe()

void epicsShareFunc mrmEvrProbe

(

const char *

id

)

mrmEvrReport()

long epicsShareFunc mrmEvrReport

(

int

level

)

Definition at line 371 of file drvemSetup.cpp.

{
    printf("=== Begin MRF EVR support ===\n");
    mrf::Object::visitObjects(&reportCard, (void*)&level);
    printf("=== End MRF EVR support ===\n");
    return 0;
}

mrmEvrSetupPCI()

void epicsShareFunc mrmEvrSetupPCI	(	const char *	id,
		const char *	pcispec
	)

Definition at line 440 of file drvemSetup.cpp.

{
try {
    bus_configuration bus;

    bus.busType = busType_pci;

    if(mrf::Object::getObject(id)){
        printf("Object ID %s already in use\n",id);
        return;
    }

    /* Linux only
     * kernel driver interface version.
     * 0 - Broken
     * 1 - Use of irqcontrol callback to avoid races for plx pci bridges
     * 2 - Use of new PCI master enable register to avoid races for soft pci bridges
     */
    int kifacever = -1;
    if(checkUIOVersion(1,2,&kifacever))
        return;

    const epicsPCIDevice *cur=0;

    if( devPCIFindSpec(mrmevrs, pcispec, &cur,0) ){
        printf("PCI Device not found on %s\n",
               pcispec);
        return;
    }

    printf("Device %s  %x:%x.%x slot=%s\n",id,cur->bus,cur->device,cur->function,cur->slot);
    printf("Using IRQ %u\n",cur->irq);

    bus.pci.dev = cur;

    const EVRMRM::Config *conf = NULL;
    switch(cur->id.sub_device) {
    case PCI_DEVICE_ID_MRF_PMCEVR_230: conf = &pmc_evr_230; break;
    case PCI_DEVICE_ID_MRF_PXIEVR_230: conf = &cpci_evr_230; break;
    case PCI_DEVICE_ID_MRF_EVRTG_300:  conf = &cpci_evrtg_300; break;
    case PCI_DEVICE_ID_MRF_CPCIEVR300: conf = &cpci_evr_300; break;
    case PCI_DEVICE_ID_MRF_EVRMTCA300: conf = &mtca_evr_300; break;
        // ambiguity
    case PCI_DEVICE_ID_MRF_EVRTG_300E: // aka PCI_SUBDEVICE_ID_PCIE_EVR_300
        switch (cur->id.device) {
        case PCI_DEVICE_ID_EC_30: conf = &cpci_evrtg_300; break;
        case PCI_DEVICE_ID_XILINX_DEV: conf = &pcie_evr_300; break;
        }
        break;
    }

    if(!conf) {
        printf("Unknown PCI EVR variant, making assumptions...\n");
        conf = &cpci_evr_unknown;
    }

    volatile epicsUInt8 *plx = 0, *evr = 0;
    epicsUInt32 evrlen = 0;

    if(devPCIToLocalAddr(cur,0,(volatile void**)(void *)&evr,DEVLIB_MAP_UIO1TO1))
    {
        printf("PCI error: Failed to map BAR 0\n");
        return;
    }
    if(!evr){
        printf("PCI error: BAR 0 mapped to zero? (%08lx)\n", (unsigned long)evr);
        return;
    }
    if( devPCIBarLen(cur,0,&evrlen) ) {
        printf("PCI error: Can't find BAR #0 length\n");
        return;
    }

    switch(cur->id.device) {
    case PCI_DEVICE_ID_PLX_9030:
    case PCI_DEVICE_ID_PLX_9056:
        plx = evr;

        if(devPCIToLocalAddr(cur,2,(volatile void**)(void *)&evr,DEVLIB_MAP_UIO1TO1))
        {
            printf("PCI error: Failed to map BAR 2\n");
            return;
        }
        if(!evr){
            printf("PCI error: BAR 2 mapped to zero? (%08lx)\n", (unsigned long)evr);
            return;
        }
        if( devPCIBarLen(cur,0,&evrlen) ) {
            printf("PCI error: Can't find BAR #0 length\n");
            return;
        }
    }

    // handle various PCI to local bus bridges
    switch(cur->id.device) {
    case PCI_DEVICE_ID_PLX_9030:
        printf("Setup PLX PCI 9030\n");
        /* Use the PLX device on the EVR to swap access on
         * little endian systems so we don't have no worry about
         * byte order :)
         */
#if EPICS_BYTE_ORDER == EPICS_ENDIAN_BIG
        BITSET(LE,32, plx, LAS0BRD, LAS0BRD_ENDIAN);
#elif EPICS_BYTE_ORDER == EPICS_ENDIAN_LITTLE
        BITCLR(LE,32, plx, LAS0BRD, LAS0BRD_ENDIAN);
#endif

        // Disable interrupts on device

        NAT_WRITE32(evr, IRQEnable, 0);

#ifndef __linux__
        /* Enable active high interrupt1 through the PLX to the PCI bus.
         */
        LE_WRITE16(plx, INTCSR, INTCSR_INT1_Enable|
                   INTCSR_INT1_Polarity|
                   INTCSR_PCI_Enable);
#endif
        break;

    case PCI_DEVICE_ID_PLX_9056:
#if EPICS_BYTE_ORDER == EPICS_ENDIAN_BIG
        BITSET(LE,8, plx, BIGEND9056, BIGEND9056_BIG);
#elif EPICS_BYTE_ORDER == EPICS_ENDIAN_LITTLE
        BITCLR(LE,8, plx, BIGEND9056, BIGEND9056_BIG);
#endif

        // Disable interrupts on device

        NAT_WRITE32(evr, IRQEnable, 0);

#ifndef __linux__
        BITSET(LE,32,plx, INTCSR9056, INTCSR9056_PCI_Enable|INTCSR9056_LCL_Enable);
#endif
        break;

    case PCI_DEVICE_ID_EC_30:
    case PCI_DEVICE_ID_MRF_CPCIEVR300:
    case PCI_DEVICE_ID_XILINX_DEV:
        /* the endianness the 300 series devices w/o PLX bridge
         * is a little tricky to setup.  byte order swapping is controlled
         * through the EVR's Control register and access to this register
         * is subject to byte order swapping...
         */

        // Disable EVR and set byte order to big endian
        NAT_WRITE32(evr, Control, 0);
        // Enable byte order swapping if necessary
#if EPICS_BYTE_ORDER == EPICS_ENDIAN_LITTLE
        BE_WRITE32(evr, Control, 0x02000000);
#endif

        // Disable interrupts on device
        NAT_WRITE32(evr, IRQEnable, 0);

#ifndef __linux__
        BITSET32(evr, IRQEnable, IRQ_PCIee);
#endif
        break;
    default:
        printf("Unknown PCI bridge %04x\n", cur->id.device);
        return;
    }

    checkVersion(evr, 3, 6);

    // Acknowledge missed interrupts
    //TODO: This avoids a spurious FIFO Full
    NAT_WRITE32(evr, IRQFlag, NAT_READ32(evr, IRQFlag));

    // Install ISR

    EVRMRM *receiver=new EVRMRM(id,bus,conf,evr,evrlen);

    void *arg=receiver;
#ifdef __linux__
    receiver->isrLinuxPvt = (void*)cur;
#endif

    if(devPCIConnectInterrupt(cur, &EVRMRM::isr_pci, arg, 0)){
        printf("Failed to install ISR\n");
        delete receiver;
        return;
    }else{
        // Interrupts will be enabled during iocInit()
    }


#ifndef __linux__
    if(receiver->version()>=MRFVersion(0, 0xa)) {
        // RTOS doesn't need this, so always enable
        WRITE32(evr, PCI_MIE, EVG_MIE_ENABLE);
    }
#else
    if(receiver->version()>=MRFVersion(0, 0xa) && kifacever>=2) {
        // PCI master enable supported by firmware and kernel module.
        // the kernel will set this bit when devPCIEnableInterrupt() is called
    } else if(cur->id.device==PCI_DEVICE_ID_PLX_9030 ||
              cur->id.device==PCI_DEVICE_ID_PLX_9056) {
        // PLX based devices don't need special handling
        WRITE32(evr, PCI_MIE, EVG_MIE_ENABLE);
    } else if(receiver->version()<MRFVersion(0, 0xa)) {
        // old firmware and (maybe) old kernel module.
        // this will still work, so just complain
        printf("Warning: this configuration of FW and SW is known to have race conditions in interrupt handling.\n"
                     "         Please consider upgrading to FW version 0xA.\n");
        if(kifacever<2)
            printf("         Also upgrade the linux kernel module to interface version 2.");
    } else if(receiver->version()>=MRFVersion(0, 0xa) && kifacever<2) {
        // New firmware w/ old kernel module, this won't work
        throw std::runtime_error("FW version 0xA for this device requires a linux kernel module w/ interface version 2");
    } else {
        throw std::logic_error("logic error in FW/kernel module compatibility check.");
    }

    /* ask the kernel module to enable interrupts */
    printf("Enabling interrupts\n");
    if(devPCIEnableInterrupt(cur)) {
        printf("Failed to enable interrupt\n");
        delete receiver;
        return;
    }
#endif

} catch(std::exception& e) {
    printf("Error: %s\n",e.what());
}
    errlogFlush();
}

mrmEvrSetupVME()

void epicsShareFunc mrmEvrSetupVME	(	const char *	id,
		int	slot,
		int	base,
		int	level,
		int	vector
	)

Definition at line 753 of file drvemSetup.cpp.

{
try {
    bus_configuration bus;
    const EVRMRM::Config *conf = &vme_evrrf_230;

    bus.busType = busType_vme;
    bus.vme.slot = slot;
    bus.vme.address = base;
    bus.vme.irqLevel = level;
    bus.vme.irqVector = vector;

    if(mrf::Object::getObject(id)){
        printf("ID %s already in use\n",id);
        return;
    }

    struct VMECSRID info;

    volatile unsigned char* csr=devCSRTestSlot(vmeevrs,slot,&info);
    if(!csr){
        printf("No EVR in slot %d\n",slot);
        return;
    }

    printf("Setting up EVR in VME Slot %d\n",slot);

    printf("Found vendor: %08x board: %08x rev.: %08x\n",
           info.vendor, info.board, info.revision);

    // Set base address

  /* Use function 0 for 16-bit addressing (length 0x00800 bytes)
   * and function 1 for 24-bit addressing (length 0x10000 bytes)
   * and function 2 for 32-bit addressing (length 0x40000 bytes)
   *
   * All expose the same registers, but not all registers are
   * visible through functions 0 or 1.
   */

    CSRSetBase(csr, 2, base, VME_AM_EXT_SUP_DATA);

    {
        epicsUInt32 temp=CSRRead32((csr) + CSR_FN_ADER(2));

        if(temp != CSRADER((epicsUInt32)base,VME_AM_EXT_SUP_DATA)) {
            printf("Failed to set CSR Base address in ADER2.  Check VME bus and card firmware version.\n");
            return;
        }
    }

    volatile unsigned char* evr;
    char *Description = allocSNPrintf(40, "EVR-%d '%s' slot %d",
                                      info.board & MRF_BID_SERIES_MASK,
                                      id, slot);

    if(devRegisterAddress(Description, atVMEA32, base, EVR_REGMAP_SIZE, (volatile void**)(void *)&evr))
    {
        printf("Failed to map address %08x\n",base);
        return;
    }

    epicsUInt32 junk;
    if(devReadProbe(sizeof(junk), (volatile void*)(evr+U32_FWVersion), (void*)&junk)) {
        printf("Failed to read from MRM registers (but could read CSR registers)\n");
        return;
    }

    checkVersion(evr, 4, 5);

    // Read offset from start of CSR to start of user (card specific) CSR.
    size_t user_offset=CSRRead24(csr+CR_BEG_UCSR);
    // Currently that value read from the UCSR pointer is
    // actually little endian.
    user_offset= (( user_offset & 0x00ff0000 ) >> 16 ) |
                 (( user_offset & 0x0000ff00 )       ) |
                 (( user_offset & 0x000000ff ) << 16 );
    volatile unsigned char* user_csr=csr+user_offset;

    NAT_WRITE32(evr, IRQEnable, 0); // Disable interrupts

    EVRMRM *receiver=new EVRMRM(id, bus, conf, evr, EVR_REGMAP_SIZE);

    if(level>0 && vector>=0) {
        CSRWrite8(user_csr+UCSR_IRQ_LEVEL,  level&0x7);
        CSRWrite8(user_csr+UCSR_IRQ_VECTOR, vector&0xff);

        printf("Using IRQ %d:%2d\n",
               CSRRead8(user_csr+UCSR_IRQ_LEVEL),
               CSRRead8(user_csr+UCSR_IRQ_VECTOR)
               );

        // Acknowledge missed interrupts
        //TODO: This avoids a spurious FIFO Full
        NAT_WRITE32(evr, IRQFlag, NAT_READ32(evr, IRQFlag));

        level&=0x7;
        // VME IRQ level will be enabled later during iocInit()
        vme_level_mask|=1<<(level-1);

        if(devConnectInterruptVME(vector&0xff, &EVRMRM::isr_vme, receiver))
        {
            printf("Failed to connection VME IRQ %d\n",vector&0xff);
            delete receiver;
            return;
        }

        // Interrupts will be enabled during iocInit()
    }

} catch(std::exception& e) {
    printf("Error: %s\n",e.what());
}
    errlogFlush();
}

Variable Documentation

evrmrmVerb

epicsShareExtern int evrmrmVerb

Extra noise control.

Controls level of extra diagnositic output from the EVR MRM device support. Error messages are always printed.

0 - No output 1 - Basic Startup 2 - Extended startup some "write" 3 - All "write" (output record processing) 4 - Some "read" (input record processing) and IRQ

Definition at line 33 of file drvemIocsh.h.