Subversion Repositories f9daq

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

// Copyright (C) 2000-2004  ARW Elektronik Germany

//

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

//

// This product is not authorized for use as critical component in 

// life support systems without the express written approval of 

// ARW Elektronik Germany.

//  

// Please announce changes and hints to ARW Elektronik

//

// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)

//

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

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

//

// cc32lib.c -- a simple access library for the PCICC32 PCI to CAMAC Interface

//

// $Log: libcc32.c,v $

// Revision 1.9  2004/11/29 20:45:36  klaus

// Bug remove. Still release libcc32.so.2.

//

// Revision 1.8  2004/11/29 20:43:12  klaus

// added _qx functions to get Q and X for every transfer. Release libcc32.so.2.

//

// Revision 1.7  2004/08/13 19:48:25  klaus

// changed license from GPL to LGPL

//

// Revision 1.6  2004/08/12 20:00:41  klaus

// conversion to kernel-version 2.6, released version 6.0

//

// Revision 1.5  2002/05/20 21:24:19  klaus

// Small changes for kernel 2.4.18

//

// Revision 1.4  2002/04/17 19:41:06  klaus

// added support for autoread

//

// Revision 1.3  2002/04/14 18:25:38  klaus

// added interrupt handling, driver 4.4. ...3.5.tar.gz

//

// Revision 1.2  2001/11/20 20:12:50  klaus

// included new header and CVS log

//

//

// first steps                                                 AR   25.02.2000

//

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

/*--- INCLUDES -----------------------------------------------------------------------------------*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/mman.h>

#include <errno.h>

#include <ctype.h>

#include <sys/ioctl.h>

#include "../driver/pcicc32.h" /* PCI common ioctl commands and structures between driver and library  */

#include "libcc32.h"      /* shared header bewteen application and library                        */

/*--- DEFINES ------------------------------------------------------------------------------------*/

#define pwCC32_ADR(adr, N, A, F) (__u16 *)((N << 10) + (A << 6) + ((F & 0xF) << 2) + adr)

#define plCC32_ADR(adr, N, A, F) (__u32 *)((N << 10) + (A << 6) + ((F & 0xF) << 2) + adr)

#define WINDOW_SIZE 32768

/*--- EXTERNALS ----------------------------------------------------------------------------------*/

/*--- TYPEDEFS -----------------------------------------------------------------------------------*/

typedef struct

{

        FILE *f;                  /* the handle of this device */

  int  fileNo;  /* equals fileno(f)          */

        char *base;             /* base of range, got with mmap */

} CC32_DEVICE;

/*--- FUNCTIONS ----------------------------------------------------------------------------------*/

static int cc32_interrupt_control(CC32_HANDLE handle, int enable)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        PCICC32_IRQ_CONTROL control;

  control.bEnable = enable;

  return ioctl(dev->fileNo, PCICC32_CONTROL_INTERRUPTS, &control);

}

static int cc32_xxxx_event(CC32_HANDLE handle, int *nTimeout, int *nLam, int nCode)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        PCICC32_STATUS state;

        int error;

  if ((error = ioctl(dev->fileNo, nCode, &state)))

          return error;

        *nTimeout = state.bFail;

        *nLam     = state.bIrq;

        if (state.bFail)  /* clear error */

        {

                if ((error = ioctl(dev->fileNo, PCICC32_IOCNTRL, 0)))

                        return error;  

        }

        return 0;

}

static int cc32_autoread_control(CC32_HANDLE handle, int nOn)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        PCICC32_AUTOREAD control;

  control.bOn = nOn;

  return ioctl(dev->fileNo, PCICC32_AUTOREAD_SWITCH, &control);

}

static void cc32_get_qx(CC32_DEVICE *dev, int *Q,  int *X)

{

  __u16 wstatus = *pwCC32_ADR(dev->base, 0, 0, 0);

  *Q = (wstatus & 8) ? 1 : 0;

  *X = (wstatus & 4) ? 1 : 0;

}

int cc32_open(char *cszPath, CC32_HANDLE *handle)

{

        CC32_DEVICE *dev;

        *handle = (CC32_HANDLE)0;

        dev = (CC32_DEVICE *)malloc(sizeof(CC32_DEVICE));

        if (!dev) return errno;

        dev->fileNo = 0;

        dev->base   = (char *)0;

        if (!(dev->f = fopen(cszPath,"rw")))

  {

                int error = errno;

                free(dev);

                printf("Cannot Open Device %s\n",cszPath);

                return error;

        }

        dev->fileNo = fileno(dev->f);

        dev->base = (char *)mmap(0, WINDOW_SIZE, PROT_READ, MAP_FILE | MAP_PRIVATE, dev->fileNo, 0);

        if (dev->base == (char *)-1)

        {

                int error = errno;

                fclose(dev->f);

                free(dev);

                printf("Cannot MMap Device %s\n",cszPath);

                return error;  

        }

        *handle = (CC32_HANDLE)dev;

        return 0;

}

int cc32_close(CC32_HANDLE handle)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        int error = 0;

        if (dev)

        {

                munmap(dev->base, WINDOW_SIZE);

                if (dev->f)

                        fclose(dev->f);

                else

                        error = -EINVAL;

                free(dev);

        }

        else

                error = -EINVAL;

        return error;

}

__u16 cc32_read_word(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        return *pwCC32_ADR(dev->base, N, A, F);

}

__u16 cc32_read_word_qx(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, int *Q, int *X)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        __u32 erg = *plCC32_ADR(dev->base, N, A, F);

        *Q = (erg & 0x80000000) ? 1 : 0;

        *X = (erg & 0x40000000) ? 1 : 0;

        return erg & 0x0000FFFF; // get only the lower 16 bits

}

__u32 cc32_read_long_all(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        return *plCC32_ADR(dev->base, N, A, F);;

}

__u32 cc32_read_long(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        __u32 erg = *plCC32_ADR(dev->base, N, A, F);

        return erg & 0x00FFFFFF;

}

__u32 cc32_read_long_qx(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, int *Q, int *X)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        __u32 erg = *plCC32_ADR(dev->base, N, A, F);

        *Q = (erg & 0x80000000) ? 1 : 0;

        *X = (erg & 0x40000000) ? 1 : 0;

        return erg & 0x00FFFFFF;

}

void cc32_write_word(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, __u16 uwData)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        *pwCC32_ADR(dev->base, N, A, F) = uwData;

}

void cc32_write_word_qx(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, __u16 uwData, int *Q, int *X)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        *pwCC32_ADR(dev->base, N, A, F) = uwData;

  cc32_get_qx(dev, Q,  X);

}

void cc32_write_long(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, __u32 ulData)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        *plCC32_ADR(dev->base, N, A, F) = ulData;

}

void cc32_write_long_qx(CC32_HANDLE handle, unsigned int N, unsigned int A, unsigned int F, __u32 ulData, int *Q, int *X)

{

        CC32_DEVICE *dev = (CC32_DEVICE *)handle;

        *plCC32_ADR(dev->base, N, A, F) = ulData;

  cc32_get_qx(dev, Q,  X);

}

int cc32_poll_event(CC32_HANDLE handle, int *nTimeout, int *nLam)

{

  return cc32_xxxx_event(handle, nTimeout, nLam, PCICC32_IOSTATE);

}

int cc32_wait_event(CC32_HANDLE handle, int *nTimeout, int *nLam)

{

  return cc32_xxxx_event(handle, nTimeout, nLam, PCICC32_IOSTATE_BLOCKING);

}

int cc32_interrupt_disable(CC32_HANDLE handle)

{

  return cc32_interrupt_control(handle, 0);

}

int cc32_interrupt_enable(CC32_HANDLE handle)

{

  return cc32_interrupt_control(handle, 1);

}

int cc32_autoread_on(CC32_HANDLE handle)

{

  return cc32_autoread_control(handle, 1);

}

int cc32_autoread_off(CC32_HANDLE handle)

{

  return cc32_autoread_control(handle, 0);

}