llif26.cpp

Go to the documentation of this file.

/*****************************************************************************
 *
 * File:
 *
 * $RCSfile: llif26.c,v $
 * 
 * Copyright (C) 2001 D-TACQ Solutions Ltd
 * not to be used without owner's permission
 *
 * Description: implementation of device driver interface for LLC
 *
 * $Id: llif26.c,v 1.4 2010/08/26 16:25:52 pgm Exp $
 * $Log: llif26.c,v $
 * Revision 1.4  2010/08/26 16:25:52  pgm
 * more switchable instrumentation
 *
 * Revision 1.3  2007/05/01 19:22:04  pgm
 * linux26 device index from 0
 *
 * Revision 1.2  2007/02/19 15:22:23  pgm
 * *** empty log message ***
 *
 * Revision 1.1  2006/06/19 13:13:30  pgm
 * *** empty log message ***
 *
 * Revision 1.18.4.17  2006/02/22 10:25:47  pgm
 * fix dbg snafu
 *
 *
 *
\*****************************************************************************/

/** @file llif26.c  implementation of device driver interface 
 * for LLC for kernel .2.6x.
 */


#include "local.h"


#include <assert.h>
#include "llif.h"

#include <stdio.h>
#include <stdlib.h>

#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>


//#include "acq32ioctl.h"
#include "acq200_ioctl.h"

int verbose;


#ifndef dbg
#define dbg(level, fmt, arg...)  fprintf(stderr, fmt, ## arg)
#endif

typedef volatile u32 r32;

struct MU {
        int fd;                         // alternate - use ioctl to access
        r32* mailboxes;                 // or mapping (x86 only)
        u32 mailboxes_shadow[4];        // up to dat cache of write values
        u32 mailboxes_lastwrite[4];     // what did we write last ??
        int poll_count;
};

#define FNAME_FMT        "/dev/acq32/acq32.%d."
#define FNAME_FMT_MBOX   FNAME_FMT "raw"

#define FNAME_FMT_HOST   FNAME_FMT "host"

#define FMT_SYS_PARAMS  "/sys/module/acq200_hostdrv/parameters/"
#define FMT_SYS_SLOTS           FMT_SYS_PARAMS "slots"

#define FMT_SYS_DEV "/sys/class/acqX00/acq200.%d/device/"
#define FMT_SYS_DEV_HOST_PA     FMT_SYS_DEV "host_pa"
#define FMT_SYS_DEV_HOST_LEN    FMT_SYS_DEV "host_len"

#define FMT_IMASK       "/dev/acq200/acq200.%d.imask"

static int lookup_device_index(int slot)
{
        static int mapping[16];
        static int valid;
        int rc;
        
        if (!valid){
                char slotdef[128];              
                int ii;
                FILE *fp;               
                
                fp = fopen(FMT_SYS_SLOTS, "r");
                if (!fp){
                        fprintf(stderr, "Failed to open slot mapping:\"%s\"", 
                                FMT_SYS_SLOTS); 
                        exit(errno);
                }
                                
                for (ii = 0; ii < 16; ++ii){
                        mapping[ii] = -1;       
                }
                if (fgets(slotdef, 128, fp)){
                        char *cp;
                        for (cp = slotdef, ii = 0; 
                                ii < 16 && (cp = strtok(cp, ",")) != 0; 
                                cp = 0, ++ii){
                                        
                                int slot_num = atoi(cp);
                                assert(IN_RANGE(slot_num, 0, 15));
                                if (slot_num != 0){
                                        mapping[slot_num] = ii;         
                                }       
                        }
                }                               
                valid = 1;      
        }
        
        rc = mapping[slot];
        if (rc == -1){
                fprintf(stderr, "No device found for slot %d", slot);
                exit(-1);       
        }
        return rc;
}
static unsigned host_len(int iboard) {
        char fname[80];
        char line[80];
        char *my_line;
        unsigned len = 0;
        int rc;
        
        sprintf(fname, FMT_SYS_DEV_HOST_LEN, lookup_device_index(iboard));
        FILE *fp = fopen(fname, "r");
        assert(fp);

        my_line = fgets(line, sizeof(line), fp);
        assert(my_line);
        
        rc = sscanf(my_line, "%u", &len);
        assert(rc);
        return len;
}
static unsigned host_pa(int iboard) {
        char fname[80];
        char line[80];
        char *my_line;
        unsigned pa = 0;
        int rc;

        sprintf(fname, FMT_SYS_DEV_HOST_PA, lookup_device_index(iboard));
        FILE *fp = fopen(fname, "r");
        assert(fp);

        my_line = fgets(line, sizeof(line), fp);
        assert(my_line);
        
        rc = sscanf(my_line, "0x%x", &pa);
        assert(rc);
        return pa;
}

int setMbox( struct MU* m, int ibox, u32 value )      
// set a mail mbox register: ibox {0..3}. return 0 on success
{
        assert( IN_RANGE( ibox, 0, 3 ) );

    
        PRINTF(3)( "setMbox( %d, 0x%08x ) @%p\n", ibox, value,  &m->mailboxes[ibox]);
        m->mailboxes[ibox] = 
                m->mailboxes_shadow[ibox] = 
                m->mailboxes_lastwrite[ibox] = value;    

        return 0;   
}    

void showLastWrites( struct MU* m )
{
        fprintf( stderr, "lastWrites()\n" );
        fprintf( stderr, "0x%08x  0x%08x  0x%08x  0x%08x\n",
                 m->mailboxes_lastwrite[0],
                 m->mailboxes_lastwrite[1],
                 m->mailboxes_lastwrite[2],
                 m->mailboxes_lastwrite[3] );
}
int setMboxBits( struct MU* m, int ibox, u32 bits_to_set )
{
        assert( IN_RANGE( ibox, 0, 3 ) );
    
        m->mailboxes[ibox] = m->mailboxes_shadow[ibox] |= bits_to_set;
        return 0;
}

int clrMboxBits( struct MU* m, int ibox, u32 bits_to_clr )
{
        assert( IN_RANGE( ibox, 0, 3 ) );
    
        m->mailboxes[ibox] = m->mailboxes_shadow[ibox] &= ~bits_to_clr;
        return 0;
}

int setMboxField( struct MU* m, 
                  int ibox, u32 field_mask, u32 field_value )
{
        assert( IN_RANGE( ibox, 0, 3 ) );
    
        m->mailboxes_shadow[ibox] &= ~field_mask;
        m->mailboxes_shadow[ibox] |= field_value;
        m->mailboxes[ibox] = m->mailboxes_shadow[ibox];
        return 0;
}

u32 getMbox( struct MU* m, int ibox )      
// get contents of mailbox register: ibox {0..3}
{
        u32 newval;
    
        assert( IN_RANGE( ibox, 0, 3 ) );

        newval = m->mailboxes[ibox];
    
        if (newval != m->mailboxes_shadow[ibox] ){
                PRINTF(4)( "getMbox( %d ) was:0x%08x now:0x%08x\n", 
                           ibox, m->mailboxes_shadow[ibox],
                           newval);
        }
    
        m->mailboxes_shadow[ibox] = newval;
        return m->mailboxes_shadow[ibox];
}

u32 getMboxShadow(struct MU* m, int ibox)
{
        assert( IN_RANGE( ibox, 0, 3 ) );
        return m->mailboxes_shadow[ibox];
}

u32 pollMboxBits( struct MU* m, int ibox, u32 mask, u32 goal )
{
        int ipoll = 0;
        u32 mbtemp;
    
        while( ( (mbtemp = getMbox( m, ibox ))&mask ) == 0 ){
                if ( (++ipoll&0x3ffff) == 0 ){
                        fprintf( stderr, 
                                 "pollMboxBits() mask:0x%08x goal:0x%08x got:0x%08x\n",
                                 mask, goal, mbtemp       );
                }
        }
    
        PRINTF(4)( "pollMboxBits() returning 0x%08x\n", mbtemp );
        return mbtemp;
}


void setMboxPollcount(struct MU* m, int poll_count)
{
        m->poll_count = poll_count;
}
int getMboxPollcount(struct MU* m)
{
        return m->poll_count;
}


struct MU* mmapMbox( int iboard )   
// iboard {1..3}. return 0 on success
{
        char fname[80];

        char* region;
        struct MU* m = (struct MU*)malloc( sizeof(struct MU) );
        unsigned offset;

        assert( m != 0 );
        memset(m, 0, sizeof(struct MU));
        assert( IN_RANGE( iboard, 1, 8 ) );
    
        sprintf( fname, FNAME_FMT_MBOX, iboard );

        if ( (m->fd = open( fname, O_RDWR )) < 0 ){
                fprintf( stderr, "mmap: failed to open device \"%s\" - ", fname );
                perror( "" );
                exit( 1 );
        }

        region = (char*)mmap( NULL, 0x400, PROT_READ|PROT_WRITE, MAP_SHARED, m->fd, 0 );

        if ( region == (void*)-1 ){
                char errbuf[256];
                sprintf(errbuf, "%s %s", "mmap", fname);
                perror(errbuf);
                exit( 1 );
        }
    

        offset = 16;

        PRINTF(1)("mmap %p offset %d\n", region, offset);
        PRINTF(2)("data: %08x %08x %08x %08x\n",
                  ((unsigned*)(region+offset))[0],
                  ((unsigned*)(region+offset))[1],
                  ((unsigned*)(region+offset))[2],
                  ((unsigned*)(region+offset))[3] );


        m->mailboxes = (r32*)((char*)region+offset);

        getMbox( m, 0 );
        getMbox( m, 1 );
        getMbox( m, 2 );
        getMbox( m, 3 );

        return m;
}


/*
 * mmapDmaBuffer obtains a user space buffer
 * in virtual memory, this is mapped linearly
 * in physical memory, this is a series of 128K blocks
 *
 * if the allocated length < 128K, no problem, it's just linear memory
 *
 * clients should use getBusAddr to get the appropriate bus address for offset
 */
 
struct DmaBuffer {
        u32* vaddr;
        int nbytes;
        u32 physaddr;
};

int getDmaBufferLen(struct DmaBuffer* buffer)
{
        return buffer->nbytes;
}


u32 getBusAddr( struct DmaBuffer* d, u32 offset_bytes)
// returns mapped bus address for offset (bytes) 
// warning: client is assumed not to go over the end of a segment
// BUT client has no way of knowng where the end is ...
{
        int idef;
    
        return d->physaddr + offset_bytes;
}

u32* getVaddr( struct DmaBuffer* db, u32 offset_bytes)
{
        if (offset_bytes < db->nbytes){
                PRINTF(4)( "getVaddr %p %d %p\n", db->vaddr, offset_bytes,
                           &db->vaddr[offset_bytes/sizeof(u32)] );
        
                return &db->vaddr[offset_bytes/sizeof(u32)];
        }else{
                return 0;
        }
}

void acq32_enableInts( struct MU* mbx, unsigned mask )
{
        PRINTF(1)( "STUBBED\n");
#if 0
        if ( ioctl( mbx->fd, ACQ32_IOS_INTS_ENABLE, mask ) != 0 ){
                perror( "ioctl ACQ32_IOS_INTS_ENABLE" );
                exit( 1 );
        }
#endif
}
void acq32_maskInts( struct MU* mbx, unsigned mask )
{
        PRINTF(1)( "STUBBED\n");
#if 0
        if ( ioctl( mbx->fd, ACQ32_IOS_INTS_DISABLE, mask ) != 0 ){
                perror( "ioctl ACQ32_IOS_INTS_DISABLE" );
                exit( 1 );
        }
#endif
}



struct DmaBuffer* mmapBigBuffer( int iboard, unsigned nbytes )
// maps dma buffer, nbytes long. ret 0 on success
// iboard {1..4}
{
#define FN "mmapDmaBuffer() "
        char fname[80];
        int fd_in;
        caddr_t* region;
        struct DmaBuffer* d = new DmaBuffer;
    
        assert( d != 0 );



        sprintf(fname, FNAME_FMT_HOST, iboard );

        PRINTF(1)(FN"01: open %s\n", fname);
/*
 * (1)open() a path to the device
 */
        if ( (fd_in = open( fname, O_RDWR )) < 0 ){
                fprintf(stderr, "mmap:failed to open device \"%s\" - ", fname);
                perror( "" );
                exit( 1 );
        }

/*
 * (2) mmap() a buffer
 */
        nbytes = host_len(iboard);
        PRINTF(1)(FN"ask for full bigbuf portion %x\n", nbytes);

        region = (caddr_t*)mmap( NULL, nbytes, PROT_READ|PROT_WRITE, MAP_SHARED, fd_in, 0 );

        if ( region == (caddr_t*)-1 ){
                perror( "mmap" );
                exit( 1 );
        }

        d->physaddr = host_pa(iboard);
        d->vaddr = (u32*)region;
        d->nbytes = nbytes;

        memset(region, 'I', nbytes);

        PRINTF(1)( FN "fd_in:%d physaddr 0x%08x vaddr %p len %d\n",
                        fd_in, d->physaddr, d->vaddr, d->nbytes);

#if 0
        FILE *fp = fopen("host0.dat", "w");
        fwrite(d->vaddr, 1, d->nbytes, fp);
        fclose(fp);
#endif
        memset(d->vaddr, 0, d->nbytes);

        PRINTF(1)(FN "written host0.dat, zeroed\n");
        return d;
#undef FN    
}


void mmapValidateDmaBuffer( struct MU* m, int nsamples )
{

}

#define INITBUF_MARKER 0x1100c0de   /* chances of 4 channels all having this val => 0*/



static void udelay(int usecs)
/* a wild guess at a microsecond delay. aim is to "rest" memory to let 
 * external DMA have accesss. We assume this code runs from cache ...
 */
{
        volatile int ii;

        while(usecs--){
                for(ii = 0x10; --ii;){
                        ;
                }
        }
}

void hbPrimeBuffer(struct DmaBuffer *buf)
/* one shot buffer priming pre run */
{
        int len = buf->nbytes - 0x100000;

        assert(len > 0);

        memset32(buf->vaddr, INITBUF_MARKER, len/sizeof(u32));
}

void hbPrimePoll(struct DmaBuffer *buf, int offset, int sample_len)
{
        int end32 = (offset + sample_len)/sizeof(u32);
        volatile u32* marker = &buf->vaddr[end32-2];

        marker[0] = INITBUF_MARKER;
        marker[1] = INITBUF_MARKER;
}
int hbPoll(
        struct DmaBuffer *buf, int offset, int sample_len,
        volatile int *user_abort)
{
        int end32 = (offset + sample_len)/sizeof(u32);
        volatile u32* marker = &buf->vaddr[end32-2];
        int ipoll = 1;
        int reported = 0;

        while (marker[0] == INITBUF_MARKER && marker[1] == INITBUF_MARKER){
                udelay(1);
                ++ipoll;
                if (ipoll > 10000 && !reported){
                        PRINTF(1)("hbPoll looking at %p\n", marker);
                        reported = 1;
                }
                if (*user_abort){
                        break;
                }
        }

        return ipoll;
}

void setPathCleanup(struct MU* m, unsigned cmd)
{
        struct MailboxControl mbc = {};

        if (cmd){
                mbc.mbc_flags = MBC_TO_MBXW(1)|MBC_TO_MBXR(1)|MBC_FLAGS_ONRELEASE;
                mbc.mbxw[0] = cmd;
        }

        int rc = ioctl(m->fd, ACQ200_MBOX_IOWR, &mbc);

        if (rc != 0){
                fprintf(stderr, "ioctl() failed: %d\n", rc);
        }
}

void acq200_setImask(int slot, const char* mask)
{
        char knob[80];
        sprintf(knob, FMT_IMASK, slot);
        FILE *fp = fopen(knob, "w");
        if (fp == 0) {
                perror(knob);
                exit(errno);
        }
        if (fp){
                fprintf(fp, "%s\n", mask? mask: "00000000");
        }
        fclose(fp);
}

void acq200_setImask(int slot, u32* mask)
{
        char knob[80];
        sprintf(knob, FMT_IMASK, slot);
        FILE *fp = fopen(knob, "w");
        if (fp == 0) {
                perror(knob);
                exit(errno);
        }
        if (fp){
                fprintf(fp, "0x%08x\n", mask? mask[0]: 0);
        }
        fclose(fp);
}