Subversion Repositories f9daq

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

// 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)

//

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

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

//

// pcicc32.c -- the driver module for the PCICC32 PCI to CAMAC Interface

//              Thanks to A.Rubini's Book and Dirk Muelhlenberg and H.J.Mathes 

//              for their arwvme driver

//

// $Log: main.c,v $

// Revision 1.29  2006/06/04 12:26:07  klaus

// release_20060604; Version 6.9; pci_{en|dis}able_device() added; remap_page_range reorganized

//

// Revision 1.28  2006/03/28 21:49:49  klaus

// release_20060328; Version 6.8; Support for AMD64 and Kernel 2.6.15

//

// Revision 1.27  2005/10/08 13:21:52  klaus

// release 6.7, removed "requested io-memory still claimed" bug at incomplete termination

//

// Revision 1.26  2005/10/07 16:57:10  klaus

// fixed a bug with request_irq with IRQs greater than 127

//

// Revision 1.25  2005/03/11 13:23:26  klaus

// simple corrections for to use with kernels 2.4.21

//

// Revision 1.24  2004/08/12 19:59:19  klaus

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

//

// Revision 1.23  2004/01/16 18:42:26  klaus

// converted remap_page_range call for kernels >= 2.4.20, contributed by Roberto Bertoni,

// release of version 5.3

//

// Revision 1.22  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.21  2003/06/19 08:23:38  klaus

// re-compiled with RH-7.2 (kernel 2.4.10)

//

// Revision 1.20  2003/05/12 20:59:50  klaus

// another improvement at previous place

//

// Revision 1.19  2003/05/12 20:38:28  klaus

// improved debug messages from test of connection

//

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

#define VERSION_HI 6

#define VERSION_LO 9

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

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

//#include <linux/config.h>

#include <linux/sched.h>

#include <linux/proc_fs.h>

#include <linux/pci.h>

#include <asm/types.h>

#include <linux/delay.h>

#include <linux/wait.h>

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)

#include <linux/interrupt.h>

#endif

#include "list.h"

#include "askpci.h"

#include "plxbug.h"

#include "plx9050.h"

#include "fops.h"

#include "pcicc32.h"

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

#define MAJOR_NO                       0                         /* use dynamic assignment */

#define DEVICE_NAME                    "pcicc32"

#if (VERSION_HI < 3)

#define ARWVME_DEVICE_ID               0x9050

#define ARWVME_VENDOR_ID               0x10B5

#define ARWVME_SUBSYSTEM_ID            0x1167

#define ARWVME_SUBSYSTEM_VENDOR_ID     0x9050

#else

#define ARWVME_DEVICE_ID               0x2258

#define ARWVME_VENDOR_ID               0x10B5

#define ARWVME_SUBSYSTEM_ID            0x2258

#define ARWVME_SUBSYSTEM_VENDOR_ID     0x9050

#endif

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

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

extern struct file_operations pcicc32_fops;

/*--- DRIVER GLOBALS ----------------------------------------------------------------------*/

static List *pci_device_header          = NULL;  /* list of all PCIADAs found */

       List *pcicc32_work_device_header = NULL;  /* list of working device interfaces */

static unsigned int nMajor;

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

static int my_interrupt(u16 intCSR)

{

  int result = NOT_MY_INTERRUPT;

  if (intCSR & 0x0040)  // it is global enabled

  {    

    if ((intCSR & 0x0028) == 0x0028) // it is a enabled PCIADA interrupt

      result = PCIADA_INTERRUPT;

    else

      if ((intCSR & 0x0005) == 0x0005) // it is a enabled CC32 interrupt

        result = CC32_INTERRUPT;  

  }

  return result;

}

static irqreturn_t cc32_irqhandler(int irq, void *dev_id, struct pt_regs *regs)

{

  CC32_DESCRIPTOR *wd = (CC32_DESCRIPTOR *)dev_id;

  if (wd)

  {

    // evaluate the reason of the interrupt - if it is mine

    u16 intCSR          = readw(wd->pLCR + PLX9050_INTCSR);

          int which_interrupt = my_interrupt(intCSR);

          if (which_interrupt)

          {

            writew(intCSR & ~0x40, wd->pLCR + PLX9050_INTCSR);       /* disable global interrupts */

            wd->wIrqStatus = (u16)which_interrupt;

            wd->dwInterruptCount++;

            wake_up_interruptible(&wd->event_queue);                 /* stop blocking if any */

          }  

          return IRQ_RETVAL(1);

  }

  return IRQ_RETVAL(0);

}

static int request_io_memory(PCIConfigHeader *pPch)

{

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)

        if (check_mem_region(pPch->desc[0].base_address, pPch->desc[0].size))

                return -EBUSY;

        if (check_mem_region(pPch->desc[3].base_address, pPch->desc[3].size))

                return -EBUSY;

        request_mem_region(pPch->desc[0].base_address, pPch->desc[0].size, DEVICE_NAME);

        request_mem_region(pPch->desc[3].base_address, pPch->desc[3].size, DEVICE_NAME);

#endif

        return 0;

}

static void release_io_memory(PCIConfigHeader *pPch)

{

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)

        release_mem_region(pPch->desc[0].base_address, pPch->desc[0].size);

        release_mem_region(pPch->desc[3].base_address, pPch->desc[3].size);

#endif

}

static int translate_addresses(CC32_DESCRIPTOR *pWd, PCIConfigHeader *pPch)    /* differs from PCIVME */

{

        if (pPch->desc[0].type == PCI_BASE_ADDRESS_MEM_TYPE_1M)  /* LCR ISA base addresses */

                pWd->pLCR = bus_to_virt(pPch->desc[0].base_address);

        else

                pWd->pLCR = ioremap(pPch->desc[0].base_address, pPch->desc[0].size);

        if (pPch->desc[3].type == PCI_BASE_ADDRESS_MEM_TYPE_1M)  /* User ISA base addresses */

                pWd->pUsr = bus_to_virt(pPch->desc[3].base_address);

        else

                pWd->pUsr = ioremap(pPch->desc[3].base_address, pPch->desc[3].size);

        return 0;

}

static void un_translate_addresses(CC32_DESCRIPTOR *pWd, PCIConfigHeader *pPch)

{

        if (pPch->desc[0].type != PCI_BASE_ADDRESS_MEM_TYPE_1M)  /* no LCR ISA base addresses */

                iounmap((void *)pWd->pLCR);

        if (pPch->desc[3].type != PCI_BASE_ADDRESS_MEM_TYPE_1M)  

                iounmap((void *)pWd->pUsr);

}

static void soft_init(CC32_DESCRIPTOR *pd)

{

        if (pd)

        {

    init_waitqueue_head(&pd->event_queue);

                pd->pLCR = pd->pUsr = 0;

                pd->pPch = (PCIConfigHeader *)NULL;

                pd->cModuleNumber = 255;

                pd->cFPGAVersion = 255;

                pd->bConnected = 0;

                pd->wInitStep = 0;    

          pd->wIrq = 0xFFFF;          

          pd->dwInterruptCount = 0;

          pd->wIrqStatus = 0;  

        }

}

int test_connection(CC32_DESCRIPTOR *wd)

{

        u16 intCSR_store;

        u16 cntrl_store;

        int i = 1000;

        u32 access_store;

        int error = 0;

        __u32 dwData;

        void *dwAdr = wd->pUsr + MAKE_CC32_ADR(26,0,0);

        cntrl_store  = readw(wd->pLCR + PLX9050_CNTRL);  /* read CONTROL register */

        intCSR_store = readw(wd->pLCR + PLX9050_INTCSR); /* read interrupt + CSR register */

        writew(0, wd->pLCR + PLX9050_INTCSR); /* disable interrupts */

        writew(cntrl_store | 0x0180, wd->pLCR + PLX9050_CNTRL); /* enable access */

        access_store = readl(dwAdr);

        while (i--)

        {

                writel(0x55555555, dwAdr);

                dwData = readl(dwAdr) & 0x00FFFFFF;

                if (0x00555555 != dwData)

                {

                        DPRINTK(KERN_DEBUG "pcicc32 : write 0x55555555, read 0x%08x\n", dwData);

                        error = 1;

                        break;

                }

                writel(0xAAAAAAAA, dwAdr);

                dwData = readl(dwAdr) & 0x00FFFFFF;

                if (0x00AAAAAA != dwData)

                {

                        DPRINTK(KERN_DEBUG "pcicc32 : write 0xAAAAAAAA, read 0x%08x\n", dwData);

                        error = 1;

                        break;

                }

                writel(0xFFFFFFFF, dwAdr);

                dwData = readl(dwAdr) & 0x00FFFFFF;

                if (0x00FFFFFF != dwData)

                {

                        DPRINTK(KERN_DEBUG "pcicc32 : write 0xFFFFFFFF, read 0x%08x\n", dwData);

                        error = 1;

                        break;

                }

                writel(0x00000000, dwAdr);

                dwData = readl(dwAdr) & 0x00FFFFFF;

                if (0x00000000 != dwData)

                {

                        DPRINTK(KERN_DEBUG "pcicc32 : write 0x00000000, read 0x%08x\n", dwData);

                        error = 1;

                        break;

                }

        }

        writew(cntrl_store & ~0x0100, wd->pLCR + PLX9050_CNTRL); /* clear potential interrupt */

        /* restore all contents */

        writel(access_store, dwAdr);

        writew(cntrl_store, wd->pLCR + PLX9050_CNTRL);

        writew(intCSR_store, wd->pLCR + PLX9050_INTCSR);

        return error;  

}

int get_module_info(CC32_DESCRIPTOR *wd, u8 *cModuleNumber, u8 *cFPGAVersion)

{

        u16 intCSR_store;

        u16 cntrl_store;

        int found = 0;

        u16 data;

        cntrl_store  = readw(wd->pLCR + PLX9050_CNTRL);  /* read CONTROL register */

        intCSR_store = readw(wd->pLCR + PLX9050_INTCSR); /* read interrupt + CSR register */

        DPRINTK(KERN_DEBUG "pcicc32 : get_module_info(), cntrl=0x%04x, intCSR=0x%04x\n", cntrl_store, intCSR_store);

        if (cntrl_store & 0x0800) /* a CC32 is connected */

        {

                u16 bla = cntrl_store | 0x0180;

                writew(0, wd->pLCR + PLX9050_INTCSR); /* disable interrupts */

                writew(bla, wd->pLCR + PLX9050_CNTRL); /* enable access */

                data = readw((wd->pUsr + MAKE_CC32_ADR(0,0,0)));

                DPRINTK(KERN_DEBUG "pcicc32 : CC32 status=0x%04x\n", data);

                if ((data & 0xF000) != 0x8000)

                {

                        *cModuleNumber = *cFPGAVersion = 255;

                        printk(KERN_ERR "pcicc32 : Wrong module type connected @ index %d (0x%04x)!\n", wd->wIndex, data);

                }

                else

                {

                        found = 1;

                        *cModuleNumber = (data >> 4) & 0xF;

                        *cFPGAVersion  = (data >> 8) & 0xF;

                }

                writew(cntrl_store & ~0x0080, wd->pLCR + PLX9050_CNTRL); /* clear potential interrupt */

                /* restore all contents */

                writew(cntrl_store, wd->pLCR + PLX9050_CNTRL);

                writew(intCSR_store, wd->pLCR + PLX9050_INTCSR);

        }

        return found;  

}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,19)

static int pcicc32_read_proc(char *buf, char **start, off_t offset, int len)

#else

static int pcicc32_read_proc(char *buf, char **start, off_t offset, int len, int *eof, void *data)

#endif

{

  int i;

  int pos = 0;

  CC32_DESCRIPTOR *pd;

  PCIConfigHeader *ch;

  Node            *n;

  u16                   cntrl;

  char            *cause = "None";

        DPRINTK(KERN_DEBUG "pcicc32 : pcicc32_read_proc()\n");

  pos += sprintf(buf + pos, "\npcicc32 information. Version %d.%d of %s from Klaus Hitschler.\n", VERSION_HI, VERSION_LO, __DATE__);

  i = getNumOfNodesInList(pcicc32_work_device_header);

  pos += sprintf(buf + pos, " ---------------------\n");

  pos += sprintf(buf + pos, " Interfaces found : %d\n", i);

  n = getFirstNode(pcicc32_work_device_header);

  while (i--)

  {

        pd = (CC32_DESCRIPTOR *)getContent(n);

        ch = pd->pPch;

          cntrl = readw(pd->pLCR + PLX9050_CNTRL);

          pos += sprintf(buf + pos, " --- %d ---------------\n", i + 1);

          pos += sprintf(buf + pos, " LCR  phys/virt/size : 0x%08x/0x%p/%d\n", ch->desc[0].base_address, pd->pLCR, ch->desc[0].size);

          pos += sprintf(buf + pos, " User phys/virt/size : 0x%08x/0x%p/%d\n", ch->desc[3].base_address, pd->pUsr, ch->desc[3].size);

          pos += sprintf(buf + pos, " Irq                 : %d\n", pd->wIrq);

          if (pd->bConnected)

          {

                  pos += sprintf(buf + pos, " CC32 is or was      : (software) connected.\n");

                pos += sprintf(buf + pos, " Module-Number       : %d\n", pd->cModuleNumber);

                pos += sprintf(buf + pos, " FPGA-Version        : %d\n", pd->cFPGAVersion);

                }

                else

                  pos += sprintf(buf + pos, " CC32 is or was      : not (software) connected.\n");             

          if (!((cntrl & 0x0800) && (!(cntrl & 0x0600))))

                pos += sprintf(buf + pos, " CC32 is             : powered off or cable disconnected.\n");

          pos += sprintf(buf + pos, " IrqCount            : %d\n", pd->dwInterruptCount);

          if (pd->wIrqStatus & PCIADA_INTERRUPT)

            cause = "Timeout";

          else

            if (pd->wIrqStatus & CC32_INTERRUPT)

              cause = "LAM";     

          pos += sprintf(buf + pos, " Pending IrqStatus   : %s\n", cause);

        n = getNextNode(n);

  }

  pos += sprintf(buf + pos, "\n");

  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,19)

  *eof = 1;

  #endif

  return pos;

}

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,2,19)

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

// replacement for kernel 2.4.x function

// original from sysdep.h out from the book

// "Linux Device Drivers" by Alessandro Rubini and Jonathan Corbet, published by O'Reilly & Associates.

static struct proc_dir_entry *create_proc_read_entry(const char *name, mode_t mode,

                                        struct proc_dir_entry *base, read_proc_t *read_proc, void * data)

{

  struct proc_dir_entry *res = create_proc_entry(name, mode, base);

  if (res)

  {

    res->read_proc=read_proc;

    res->data=data;

  }

  return res;

}

#endif

int init_module(void)

{

  int i = 0;

  PCIConfigHeader *ch;

  CC32_DESCRIPTOR *wd;

  Node            *n;

  int             result = 0;

  printk(KERN_INFO "pcicc32 : init_module\n");

  /* create list of PCIADAs and work devices */

  pci_device_header          = newList();

  pcicc32_work_device_header = newList();

  /* search for all PCIADA modules */

  while ((ch = GetPCIConfigHeader(ARWVME_VENDOR_ID, ARWVME_DEVICE_ID, i)))

  {

    if (ch->subsystem_id != ARWVME_SUBSYSTEM_ID)

    {

      printk(KERN_ERR "pcicc32 : found 0x%x, 0x%x , but wrong subsystem id 0x%04x!\n",

              ARWVME_VENDOR_ID, ARWVME_DEVICE_ID, ch->subsystem_id);

      i++;

      kfree_s(ch, sizeof(*ch));        // FREE(ch);

      continue;

    }

    if (ch->subsystem_vendor_id != ARWVME_SUBSYSTEM_VENDOR_ID)

    {

      printk(KERN_ERR "pcicc32 : found 0x%x, 0x%x , but wrong subsystem vendor Id 0x%04x!\n",

             ARWVME_VENDOR_ID, ARWVME_DEVICE_ID, ch->subsystem_vendor_id);

      i++;

      kfree_s(ch, sizeof(*ch));        // FREE(ch);

      continue;

    }

    /* test if it is configured as PCICC32 or a PCIVME interface card */

    if (ch->desc[3].size != 0x8000)  

    {

      printk(KERN_ERR "pcicc32 : found, but wrong memory window size 0x%08x!\n", ch->desc[3].size);

      i++;

      kfree_s(ch, sizeof(*ch));        // FREE(ch);

      continue;

    }

    printk(KERN_INFO "pcicc32 : found %d. PCIADA card\n", i + 1);

    addTail(pci_device_header, ch);  /* add this header to list */

    i++;

  }

  /* fix the PLX bug in all PCIADAs */

  i = getNumOfNodesInList(pci_device_header);

  n = getFirstNode(pci_device_header);

  while (i--)

  {

        ch = (PCIConfigHeader *)getContent(n);

        PLX9050BugFix(ch);

        n = getNextNode(n);

  }

  /* create work_devices and translate the access addresses */

  i = getNumOfNodesInList(pci_device_header);

  n = getFirstNode(pci_device_header);

  while (i--)

  {

        wd = (CC32_DESCRIPTOR *)kmalloc(sizeof(CC32_DESCRIPTOR), GFP_ATOMIC);

          soft_init(wd);

          ch  = (PCIConfigHeader *)getContent(n);

          wd->pPch = ch;

          wd->wIndex = i;

          if (!request_io_memory(ch))

          {

            // successful request_io_memory

            wd->wInitStep = 1;

                  if (translate_addresses(wd, ch))

                  {

                          printk(KERN_ERR "pcicc32 : translation of addresses failed!\n");

        release_io_memory(ch);

                          kfree_s(wd, sizeof(*wd));       // FREE(wd);

                  }

                  else

                  {

                    // successful translate_addresses

                    wd->wInitStep = 2;

        if (request_irq(wd->pPch->PCI_dev->irq, cc32_irqhandler, IRQF_DISABLED| IRQF_SHARED, DEVICE_NAME, wd))

              {

                                  printk(KERN_ERR "pcicc32 : can't get irq @ %d\n", wd->pPch->PCI_dev->irq);

          un_translate_addresses(wd, ch);

          release_io_memory(ch);

                            kfree_s(wd, sizeof(*wd));       // FREE(wd);

              }

              else

              {  

                // successful request_irq

                      wd->wInitStep = 3;

                      wd->wIrq = wd->pPch->PCI_dev->irq;

                            addTail(pcicc32_work_device_header, wd);  /* add this device to list */

                            wd->bConnected =  get_module_info(wd, &wd->cModuleNumber, &wd->cFPGAVersion);

                            if (wd->bConnected && test_connection(wd))

                            {

                                    printk(KERN_ERR "pcicc32 : connection test failed!\n");

                                    wd->bConnected = 0;

                            }

                          }

                  }

          }

          else

          {

                  printk(KERN_ERR "pcicc32 : requested io-memory still claimed!\n");

                        kfree_s(wd, sizeof(*wd));       // FREE(wd);

                }

        n = getNextNode(n);

  }

  nMajor = MAJOR_NO;

  result = register_chrdev(nMajor, DEVICE_NAME, &pcicc32_fops);

  if (result < 0)

  {

        printk(KERN_ERR "pcicc32: Can't install driver (%d)\n", result);

    /* untranslate translated addresses */

    i = getNumOfNodesInList(pcicc32_work_device_header);

    n = getFirstNode(pcicc32_work_device_header);

    while (i--)

    {

            wd  = (CC32_DESCRIPTOR *)getContent(n);

            ch = wd->pPch;

            un_translate_addresses(wd, ch);

            n = getNextNode(n);

    }

    /* delete my lists */

    deleteList(pcicc32_work_device_header, (void (*)(void *))NULL);  

    deleteList(pci_device_header, (void (*)(void *))NULL);      

        return result;

  }

  else

  {

        if (nMajor == 0) nMajor = result;

    printk(KERN_INFO "pcicc32 : major #%d assigned.\n", nMajor);

  }

  /* register the proc device */

  return proc_create_data(DEVICE_NAME, 0, NULL, &pcicc32_fops, NULL) ? 0 : -ENODEV;

}

void cleanup_module(void)

{

  int i;

  PCIConfigHeader *ch;

  CC32_DESCRIPTOR *wd;

  Node            *n;

  unregister_chrdev(nMajor, DEVICE_NAME);

  DPRINTK(KERN_DEBUG "pcicc32 : cleanup_module()\n");

  /* unregister the proc device */

  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,19)

  proc_unregister(&proc_root, pcimod_proc_entry.low_ino);

  #else

  remove_proc_entry(DEVICE_NAME, NULL);

  #endif

  /* untranslate translated addresses */

  i = getNumOfNodesInList(pcicc32_work_device_header);

  n = getFirstNode(pcicc32_work_device_header);

  while (i--)

  {

          wd  = (CC32_DESCRIPTOR *)getContent(n);

        ch = wd->pPch;

          switch (wd->wInitStep)

          {

            case 3:  writew(readw(wd->pLCR + PLX9050_INTCSR) & ~0x40, wd->pLCR + PLX9050_INTCSR);  // disable global interrupts

               free_irq(wd->wIrq, wd);  

            case 2:  un_translate_addresses(wd, ch);

            case 1:  release_io_memory(ch);

            default: wd->wInitStep = 0;

          }

    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)

    if ((ch) && (ch->PCI_dev))

                  pci_disable_device(ch->PCI_dev);

    #endif              

        n = getNextNode(n);

  }

  /* delete my lists */

  deleteList(pcicc32_work_device_header, (void (*)(void *))NULL);  

  deleteList(pci_device_header, (void (*)(void *))NULL);

  printk(KERN_INFO "pcicc32 : cleanup_module successful.\n");

  return;

}