Subversion Repositories f9daq

Rev

Blame | Last modification | View Log | RSS feed

//****************************************************************************
// Copyright (C) 2000-2006  ARW Elektronik Germany
//
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU 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)
//
//****************************************************************************

//****************************************************************************
// Revision 1.20 support for kernel version=3.13.0-37-generic 2014/10/19  Rok Pestotnik
// fops.c -- the file operations module for the PCICC32 PCI to CAMAC Interface
//
// $Log: fops.c,v $
// Revision 1.19  2006/06/04 12:26:07  klaus
// release_20060604; Version 6.9; pci_{en|dis}able_device() added; remap_page_range reorganized
//
// Revision 1.18  2006/03/28 21:49:49  klaus
// release_20060328; Version 6.8; Support for AMD64 and Kernel 2.6.15
//
// Revision 1.17  2005/03/11 13:23:26  klaus
// simple corrections for to use with kernels 2.4.21
//
// Revision 1.16  2004/08/12 19:59:19  klaus
// conversion to kernel-version 2.6, released version 6.0
//
// Revision 1.15  2004/01/16 18:40:34  klaus
// converted remap_page_range call for kernels >= 2.4.20, contributed by Roberto Bertoni
//
// Revision 1.14  2003/12/04 20:34:49  klaus
// minor change: restore the hardware set intCSR content at release of path, release of version 5.2
//
// Revision 1.13  2003/06/19 08:23:38  klaus
// re-compiled with RH-7.2 (kernel 2.4.10)
//
// Revision 1.12  2003/05/11 11:12:03  klaus
// matched to kernel 2.4 PCI handling, debug messages improved
//
// Revision 1.11  2002/10/08 18:01:46  klaus
// corrections mainly for use with kernel 2.2.19
//
// Revision 1.10  2002/08/06 19:06:50  klaus
// Small changes
//
// Revision 1.9  2002/04/17 19:41:06  klaus
// added support for autoread
//
// Revision 1.8  2002/04/17 18:57:33  klaus
// last changes to release 4.4
//
// Revision 1.7  2002/04/14 18:25:38  klaus
// added interrupt handling, driver 4.4. ...3.5.tar.gz
//
// Revision 1.6  2001/11/20 21:29:24  klaus
// Small changes to correct versioning down to kernel 2.3
//
// Revision 1.5  2001/11/20 20:25:23  klaus
// inserted versioning for kernel 2.4
//
// Revision 1.4  2001/11/20 20:12:50  klaus
// included new header and CVS log
//
// first steps (on my mothers birthday)                        AR   23.02.2000
// MAKE_CC32_ADR serves only F from 0..15                      AR   24.04.2000
// MODVERSIONS included                                        AR   24.04.2000
//  
//****************************************************************************

/*--- INCLUDES -----------------------------------------------------------------------------------*/
#include "common.h"  /* must be the first include */

#include <linux/kernel.h> /* printk() */
#include <linux/mm.h>
#include <linux/module.h> /* MODULE_AUTHOR and MAJOR ... */
#include <linux/pci.h>
#include <asm/errno.h>
#include <asm/types.h>
#include <asm/uaccess.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/poll.h>

#include "fops.h"
#include "list.h"
#include "plx9050.h"
#include "pcicc32.h"      /* the common ioctl commands and structures between driver and application */

/*--- DEFINES ------------------------------------------------------------------------------------*/
MODULE_AUTHOR("klaus.hitschler@gmx.de");
MODULE_DESCRIPTION("Driver for ARW Elektronik PCI CAMAC interface.");
MODULE_SUPPORTED_DEVICE("PCICC32");

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,10)
MODULE_LICENSE("GPL");               // since 2.4.?
#endif

#ifndef MINOR
#define MINOR(x) minor(x)            // since 2.5.?
#endif

#define MAKE_CC32_ADR(N, A, F) (u16)((N << 10) + (A << 6) + ((F & 0xf) << 2))

#define ENABLE_PCIADA_IRQS  (u16)0x0049 /* enable PCIADA IRQs            */
#define DISABLE_PCIADA_IRQS (u16)0x0009 /* disable PCIADA IRQs           */

/*--- EXTERNALS ----------------------------------------------------------------------------------*/
extern int get_module_info(CC32_DESCRIPTOR *wd, u8 *cModuleNumber, u8 *cFPGAVersion);
extern int test_connection(CC32_DESCRIPTOR *wd);
extern List *pcicc32_work_device_header;

/*--- TYPEDEFS -----------------------------------------------------------------------------------*/
typedef struct
{
        CC32_DESCRIPTOR *desc;  /* pointer to my PCIADA & CC32 */
} PRIVATE_DATA;

/*--- FUNCTIONS ----------------------------------------------------------------------------------*/
static void switch_CC32_on(CC32_DESCRIPTOR *desc)
{
        u16 cntrl;
       
        DPRINTK(KERN_DEBUG "pcicc32 : switch_CC32_on()\n");
       
        cntrl  = readw(desc->pLCR + PLX9050_CNTRL);  /* read CONTROL register */
        cntrl |= 0x0180;
        writew(cntrl, desc->pLCR + PLX9050_CNTRL); /* enable access */
}

static void switch_CC32_off(CC32_DESCRIPTOR *desc)
{
        u16 cntrl  = readw(desc->pLCR + PLX9050_CNTRL);  /* read CONTROL register */
       
        DPRINTK(KERN_DEBUG "pcicc32 : switch_CC32_off()\n");
       
  writew(DISABLE_PCIADA_IRQS, desc->pLCR + PLX9050_INTCSR);  /* disable global interrupts */
        cntrl &= ~0x0100;
        writew(cntrl, desc->pLCR + PLX9050_CNTRL);       /* disable access */
}

int pcicc32_ioctl(struct inode *pInode, struct file *pFile, unsigned int cmd, unsigned long arg)
{
        u16 cntrl;
        PRIVATE_DATA *pd    = (PRIVATE_DATA *)pFile->private_data;
  CC32_DESCRIPTOR *wd = pd->desc;
       
        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_ioctl(0x%08x, 0x%08lx)\n", cmd, arg);
       
        if (_IOC_TYPE(cmd) != PCICC32_MAGIC)
          return -EINVAL;
       
        switch(_IOC_NR(cmd))
        {
    case 1: // PCICC32_IOSTATE
                  {
              PCICC32_STATUS *ptr = (PCICC32_STATUS *)arg;  /* makes it simple */
                 
                    if (_IOC_SIZE(cmd) < sizeof(PCICC32_STATUS))
                      return -EINVAL;
                          if (!access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))
                            return -EFAULT;
                               
                          ptr->bConnected = ((wd->bConnected) && (readw(wd->pLCR + PLX9050_CNTRL) & 0x0800)) ? 1 : 0;
                          ptr->bFail      = (readw(wd->pLCR + PLX9050_INTCSR) & 0x0020) ? 1 : 0;
                          ptr->bIrq       = (readw(wd->pLCR + PLX9050_INTCSR) & 0x0004) ? 1 : 0;
                         
                                wd->wIrqStatus  = 0;  // clear the status since it is read                             
                        }
                        break;
                case 2: // PCICC32_IOCNTRL
                  {
                    if (_IOC_SIZE(cmd))
                      return -EINVAL;
                               
                          cntrl  = readw(wd->pLCR + PLX9050_CNTRL);  /* read CONTROL register */
                          writew(cntrl & ~0x0100, wd->pLCR + PLX9050_CNTRL); /* clear USRIO2 */
                          writew(cntrl          , wd->pLCR + PLX9050_CNTRL); /* restore it   */        
                        }
                  break;
          case 3: // PCICC32_CONTROL_INTERRUPTS
            {
              PCICC32_IRQ_CONTROL *ptr = (PCICC32_IRQ_CONTROL *)arg;  /* makes it simple */
              char bEnable = (readw(wd->pLCR + PLX9050_INTCSR) & 0x40) ? 1 : 0;
             
              if (_IOC_SIZE(cmd) < sizeof(PCICC32_IRQ_CONTROL))
                return -EINVAL;
                          if (!access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))
                            return -EFAULT;
             
              DPRINTK(KERN_DEBUG "pcicc32 : Interrupt enable = %d\n", ptr->bEnable);
             
              if (ptr->bEnable)
                writew(ENABLE_PCIADA_IRQS  ,wd->pLCR + PLX9050_INTCSR); // local and global enable
                    else
                      writew(DISABLE_PCIADA_IRQS ,wd->pLCR + PLX9050_INTCSR); // global disable
                     
                    // return last interrupt enable status  
                          ptr->bEnable = bEnable;  
            }
            break;
          case 4: // PCICC32_IOSTATE_BLOCKING
            {
              PCICC32_STATUS *ptr = (PCICC32_STATUS *)arg;  /* makes it simple */
              int err;
                         
                    if (_IOC_SIZE(cmd) < sizeof(PCICC32_STATUS))
                      return -EINVAL;
                   
        // support nonblocking read if requested
        if ((pFile->f_flags & O_NONBLOCK) && (!wd->wIrqStatus))
          return -EAGAIN;
         
        // sleep until data are available
        if ((err = wait_event_interruptible(wd->event_queue, (wd->wIrqStatus))))
                return err;
               
                          if (!access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))
                            return -EFAULT;
                               
                          ptr->bConnected = ((wd->bConnected) && (readw(wd->pLCR + PLX9050_CNTRL) & 0x0800)) ? 1 : 0;
                          ptr->bFail      = (readw(wd->pLCR + PLX9050_INTCSR) & 0x0020) ? 1 : 0;
                          ptr->bIrq       = (readw(wd->pLCR + PLX9050_INTCSR) & 0x0004) ? 1 : 0;
                         
                                wd->wIrqStatus  = 0;  // clear the status since it is read                             
            }
            break;
          case 5: // PCICC32_AUTOREAD_SWITCH
            {
              u16 ctrl, erg;
             
              PCICC32_AUTOREAD *ptr = (PCICC32_AUTOREAD *)arg;  /* makes it simple */
                         
                    if (_IOC_SIZE(cmd) < sizeof(PCICC32_AUTOREAD))
                      return -EINVAL;
                   
                          if (!access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))
                            return -EFAULT;
                         
                          ctrl = readw(wd->pLCR + PLX9050_CNTRL);  
                          if (ptr->bOn)
                          {
                            erg  = ctrl & ~0x0004;
                            erg |= 0x0002;         // switch output to 1, pin to 0 = on
                            writew(erg, wd->pLCR + PLX9050_CNTRL);
                          }
                          else
                          {
                            erg  = ctrl | 0x0006;  // switch output = 1, pin to 1 = off
                            writew(erg, wd->pLCR + PLX9050_CNTRL);
                          }
                         
                                // respond the last state
                          ptr->bOn = (ctrl & 0x0004) ? 0 : 1;
            }
            break;
               
                default:
                  return -EINVAL;
        }
       
        return 0;
}


static long  pcicc32_unlocked_ioctl(struct file *pFile, unsigned int cmd, unsigned long arg){
long retval=0;


#if HAVE_UNLOCKED_IOCTL
    struct mutex  fs_mutex;
   mutex_init(&fs_mutex);
   mutex_lock(&fs_mutex);
#else
   lock_kernel();
#endif

DPRINTK(KERN_DEBUG "%s : pcicc32_unlocked_ioctl(0x%08x), size = %d\n", DEVICE_NAME, cmd, _IOC_SIZE(cmd));
retval = pcicc32_ioctl(NULL, pFile, cmd,arg);

#if HAVE_UNLOCKED_IOCTL
   mutex_unlock(&fs_mutex);
#else
   unlock_kernel();
#endif

return retval;
}

int pcicc32_mmap(struct file *pFile, struct vm_area_struct *vma)
{
        PRIVATE_DATA *pd = (PRIVATE_DATA *)pFile->private_data;
       
        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_mmap()\n");
       
        if (pd->desc->pPch->desc[3].type == PCI_BASE_ADDRESS_MEM_TYPE_1M)
        {
                DPRINTK(KERN_DEBUG "pcicc32 : mmap(address=%p size=%d)\n",
                        virt_to_phys((void *)pd->desc->pUsr), pd->desc->pPch->desc[3].size);

                if (pcicc32_remap_page_range(vma, vma->vm_start,
                        virt_to_phys((void *)pd->desc->pUsr), pd->desc->pPch->desc[3].size, PAGE_SHARED))
                        return -EAGAIN;
        }
        else
        {
                DPRINTK(KERN_DEBUG "pcicc32 : mmap(address=%p size=%d)\n",
                        virt_to_phys((void *)pd->desc->pUsr), pd->desc->pPch->desc[3].size);

                if (pcicc32_remap_page_range(vma, vma->vm_start,
                        pd->desc->pPch->desc[3].base_address, pd->desc->pPch->desc[3].size, PAGE_SHARED))
                        return -EAGAIN;
        }
       
        return 0;
}



int pcicc32_open(struct inode *pInode, struct file *pFile)
{
        CC32_DESCRIPTOR *wd = 0;
        CC32_DESCRIPTOR *desc = 0;
        int i;
        Node *n;
        int nMinor = MINOR(pInode->i_rdev);
        PRIVATE_DATA *pd;
       
        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_open(), Major=%d, Minor=%d\n", MAJOR(pInode->i_rdev), nMinor);
       
        /* search for device */
        i = getNumOfNodesInList(pcicc32_work_device_header);
        n = getFirstNode(pcicc32_work_device_header);
       
        DPRINTK(KERN_DEBUG "pcicc32 : scanning %d devices\n", i);
        while (i--)
        {
                wd  = (CC32_DESCRIPTOR *)getContent(n);
               
                wd->bConnected =  get_module_info(wd, &wd->cModuleNumber, &wd->cFPGAVersion);
                if (wd->bConnected)
                {
                        if  (test_connection(wd))
                        {
                                printk(KERN_ERR "pcicc32 : connection test for module %d failed!\n", wd->cModuleNumber);
                                wd->bConnected = 0;
                        }
                        else
                                if (wd->cModuleNumber == nMinor)
                                {
                                        desc = wd;
                                        break;
                                }
                }
                else
                {
                        DPRINTK(KERN_DEBUG "pcicc32 : module %d not connected!\n", nMinor);
                }
                         
                n = getNextNode(n);
        }
       
        if (desc)
        {
                pFile->private_data = (void *)kmalloc(sizeof(PRIVATE_DATA), GFP_ATOMIC);
                if (!pFile->private_data)
                        return -ENOMEM;
               
                pd = (PRIVATE_DATA *)pFile->private_data;
                pd->desc = wd;
               
                DPRINTK(KERN_DEBUG "pcicc32 : found CC32 module with number %d.\n", nMinor);
        }
        else
        {
                DPRINTK(KERN_DEBUG "pcicc32 : No CC32 module found.\n");

                return -ENODEV;
        }              
               
        switch_CC32_on(wd);
                       
        __MOD_INC_USE_COUNT__;
        return 0;
}

int pcicc32_release(struct inode *pInode, struct file *pFile)
{
        PRIVATE_DATA *pd;

        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_release()\n");
                               
        if (pFile->private_data)
        {
                pd = (PRIVATE_DATA *)pFile->private_data;
                if (pd && pd->desc)    
                {
                        switch_CC32_off(pd->desc);
                        pd->desc = 0;
                }
                       
                kfree_s(pd, sizeof(*pd));    // FREE(pFile->private_data);
        }
       
        __MOD_DEC_USE_COUNT__;
        return 0;
}

//----------------------------------------------------------------------------
// is called at poll or select
static unsigned int pcicc32_poll(struct file *pFile, poll_table *wait)
{
        PRIVATE_DATA    *pd = (PRIVATE_DATA *)pFile->private_data;
  CC32_DESCRIPTOR *wd = pd->desc;
  unsigned int mask   = 0;
 
        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_poll()\n");
       
  poll_wait(pFile, &wd->event_queue, wait);
 
  // return on ops that could be performed without blocking
  if (wd->wIrqStatus)      
    mask |= (POLLIN  | POLLRDNORM);
 
  return mask;
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
struct file_operations pcicc32_fops =
{
        NULL,                   /* lseek */
        NULL,                   /* read  */
        NULL,                   /* write */
        NULL,                   /* readdir */
        pcicc32_poll,   /* poll, since 2.2., replaces select */
        pcicc32_ioctl,  /* ioctl */
        pcicc32_mmap,   /* mmap */
        pcicc32_open,   /* open */
        NULL,           /* flush */
        pcicc32_release,/* release */
};
#else
struct file_operations pcicc32_fops =
{
        unlocked_ioctl :   pcicc32_unlocked_ioctl,              /* ioctl */
//      ioctl:   pcicc32_ioctl,         /* ioctl */
        mmap:    pcicc32_mmap,          /* mmap */
        open:    pcicc32_open,          /* open */
        release: pcicc32_release,       /* release */
  poll:    pcicc32_poll,    /* poll */
};
#endif