Subversion Repositories pcie_ds_dma

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/version.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/ioport.h>

#include <linux/list.h>

#include <linux/pci.h>

#include <linux/proc_fs.h>

#include <linux/interrupt.h>

#include <asm/io.h>

#include <asm/uaccess.h>

#include <linux/types.h>

#include <linux/ioport.h>

#include <linux/poll.h>

#include <linux/pci.h>

#include <linux/delay.h>

#include "pexmodule.h"

#include "hardware.h"

#include "pexioctl.h"

#include "ioctlrw.h"

#include "ambpexregs.h"

#include "pexproc.h"

#include "memory.h"

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

MODULE_AUTHOR("Vladimir Karakozov. karakozov@gmail.com");

MODULE_LICENSE("GPL");

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

static dev_t devno = MKDEV(0, 0);

static struct class *pex_class = NULL;

static LIST_HEAD(device_list);

static int boards_count = 0;

static struct mutex pex_mutex;

int dbg_trace = 1;

int err_trace = 1;

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

static int free_memory(struct pex_device *brd)

{

    struct list_head *pos, *n;

    struct mem_t *m = NULL;

    int unlocked = 0;

    spin_lock(&brd->m_MemListLock);

    list_for_each_safe(pos, n, &brd->m_MemList) {

        m = list_entry(pos, struct mem_t, list);

        unlocked = unlock_pages(m->cpu_addr, m->size);

        dma_free_coherent(&brd->m_pci->dev, m->size, m->cpu_addr, m->dma_handle);

        dbg_msg(dbg_trace, "%s(): %d: PA = 0x%zx, VA = %p, SZ = 0x%zx, PAGES = %d\n",

                __FUNCTION__, atomic_read(&brd->m_MemListCount), (size_t)m->dma_handle, m->cpu_addr, m->size, unlocked );

        list_del(pos);

        atomic_dec(&brd->m_MemListCount);

        kfree(m);

    }

    spin_unlock(&brd->m_MemListLock);

    return 0;

}

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

static struct pex_device *file_to_device( struct file *file )

{

    return (struct pex_device*)file->private_data;

}

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

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)

static struct pex_device *inode_to_device( struct list_head *head, struct inode *inode )

{

    struct list_head *p;

    struct pex_device *entry;

    unsigned int minor = MINOR(inode->i_rdev);

    list_for_each(p, head) {

        entry = list_entry(p, struct pex_device, m_list);

        if(entry->m_BoardIndex == minor)

            return entry;

    }

    return NULL;

}

#endif

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

/*

static ssize_t pex_device_read(struct file *file, char __user *data, size_t count, loff_t *ppos)

{

    int error = 0;

    u32 AdmNumber = 0;

    u32 TetrNumber = 0;

    u32 Address = 0;

    struct CDmaChannel *dma = NULL;

    struct pex_device *pDevice = file_to_device(file);

    if(!pDevice) {

        err_msg(err_trace, "%s(): No such device\n", __FUNCTION__);

        return -ENODEV;

    }

    dma = pDevice->m_DmaChannel[0];

    printk("%s(): data = %p\n", __FUNCTION__, data);

    printk("%s(): size = 0x%lx\n", __FUNCTION__, count);

    printk("%s(): ppos = %p\n", __FUNCTION__, ppos);

    error = lock_user_memory( &dma->m_BufDscrVA, data, count);

    if(error < 0) {

        err_msg(err_trace, "%s(): Error in lock_user_memory()\n", __FUNCTION__);

        return -EINVAL;

    }

    dma->m_BlockCount = dma->m_BufDscrVA.PageCount;

    dma->m_ScatterGatherTableEntryCnt = dma->m_BufDscrVA.PageCount;

    dma->m_BlockSize = PAGE_SIZE;

    AdmNumber = 0;

    TetrNumber = 0;

    Address = AdmNumber*ADM_SIZE + TetrNumber*TETRAD_SIZE + TRDadr_DATA*REG_SIZE;

    SetDmaDirection(dma, 1);

    Adjust(dma, 0);

    SetDmaLocalAddress(dma, Address);

    SetAdmTetr(dma, AdmNumber, TetrNumber);

    SetDmaMode(pDevice, 0, AdmNumber, TetrNumber);

    RequestStub(dma,NULL);

    SetScatterGatherListExtUser(dma);

    StartDmaTransfer(dma, 0);

    HwStartDmaTransfer(pDevice, 0);

    error = WaitEvent(&dma->m_BufferEndEvent, 1000);

    if(error < 0) {

        err_msg(err_trace, "%s(): Timeout read operation\n", __FUNCTION__);

    }

    error = unlock_user_memory( &dma->m_BufDscrVA );

    if(error < 0) {

        err_msg(err_trace, "%s(): Error in lock_user_memory()\n", __FUNCTION__);

        return -EINVAL;

    }

    ReleaseStub( dma );

    ReleaseSGList( dma );

    return 0;

}

*/

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

static int pex_device_fasync(int fd, struct file *file, int mode)

{

    struct pex_device *pDevice = file->private_data;

    if(!pDevice)

        return -ENODEV;

    return 0;

}

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

static unsigned int pex_device_poll(struct file *filp, poll_table *wait)

{

    unsigned int mask = 0;

    struct pex_device *pDevice = file_to_device(filp);

    if(!pDevice)

        return -ENODEV;

    return mask;

}

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

static int pex_device_open( struct inode *inode, struct file *file )

{

    struct pex_device *pDevice = container_of(inode->i_cdev, struct pex_device, m_cdev);

    if(!pDevice) {

        err_msg(err_trace, "%s(): Open device failed\n", __FUNCTION__);

        return -ENODEV;

    }

    file->private_data = (void*)pDevice;

    dbg_msg(dbg_trace, "%s(): Open device %s\n", __FUNCTION__, pDevice->m_name);

    return 0;

}

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

static int pex_device_close( struct inode *inode, struct file *file )

{

    struct pex_device *pDevice = container_of(inode->i_cdev, struct pex_device, m_cdev);

    if(!pDevice) {

        err_msg(err_trace, "%s(): Close device failed\n", __FUNCTION__);

        return -ENODEV;

    }

    file->private_data = NULL;

    dbg_msg(dbg_trace, "%s(): Close device %s\n", __FUNCTION__, pDevice->m_name);

    return 0;

}

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

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

static long pex_device_ioctl( struct file *file, unsigned int cmd, unsigned long arg )

#else

static int pex_device_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg )

#endif

{

    int error = 0;

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

    struct pex_device *pDevice = file_to_device(file);

#else

    struct pex_device *pDevice = inode_to_device(&device_list, inode);

#endif

    if(!pDevice) {

        err_msg(err_trace, "%s(): ioctl device failed\n", __FUNCTION__);

        return -ENODEV;

    }

    mutex_lock(&pDevice->m_BoardMutex);

    switch(cmd) {

    case IOCTL_PEX_BOARD_INFO:

        error = ioctl_board_info(pDevice, arg);

        break;

    case IOCTL_PEX_MEM_ALLOC:

        error = ioctl_memory_alloc(pDevice, arg);

        break;

    case IOCTL_PEX_MEM_FREE:

        error = ioctl_memory_free(pDevice, arg);

        break;

    case IOCTL_PEX_STUB_ALLOC:

        error = ioctl_stub_alloc(pDevice, arg);

        break;

    case IOCTL_PEX_STUB_FREE:

        error = ioctl_stub_free(pDevice, arg);

        break;

    case IOCTL_AMB_SET_MEMIO:

        error = ioctl_set_mem(pDevice, arg);

        break;

    case IOCTL_AMB_FREE_MEMIO:

        error = ioctl_free_mem(pDevice, arg);

        break;

    case IOCTL_AMB_START_MEMIO:

        error = ioctl_start_mem(pDevice, arg);

        break;

    case IOCTL_AMB_STOP_MEMIO:

        error = ioctl_stop_mem(pDevice, arg);

        break;

    case IOCTL_AMB_STATE_MEMIO:

        error = ioctl_state_mem(pDevice, arg);

        break;

    case IOCTL_AMB_WAIT_DMA_BUFFER:

        error = ioctl_wait_dma_buffer(pDevice, arg);

        break;

    case IOCTL_AMB_WAIT_DMA_BLOCK:

        error = ioctl_wait_dma_block(pDevice, arg);

        break;

    case IOCTL_AMB_SET_SRC_MEM:

        error = ioctl_set_src_mem(pDevice, arg);

        break;

    case IOCTL_AMB_SET_DIR_MEM:

        error = ioctl_set_dir_mem(pDevice, arg);

        break;

    case IOCTL_AMB_SET_DRQ_MEM:

        error = ioctl_set_drq_mem(pDevice, arg);

        break;

    case IOCTL_AMB_RESET_FIFO:

        error = ioctl_reset_fifo(pDevice, arg);

        break;

    case IOCTL_AMB_DONE:

        error = ioctl_done(pDevice, arg);

        break;

    case IOCTL_AMB_ADJUST:

        error = ioctl_adjust(pDevice, arg);

        break;

    default:

        dbg_msg(dbg_trace, "%s(): Unknown command\n", __FUNCTION__);

        error = -EINVAL;

        break;

    }

    mutex_unlock(&pDevice->m_BoardMutex);

    return error;

}

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

static inline int private_mapping_ok(struct vm_area_struct *vma)

{

    return vma->vm_flags & VM_MAYSHARE;

}

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

static int pex_device_mmap(struct file *file, struct vm_area_struct *vma)

{

    size_t size = vma->vm_end - vma->vm_start;

    if (!private_mapping_ok(vma))

        return -ENOSYS;

    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

    if (remap_pfn_range(vma,

                        vma->vm_start,

                        vma->vm_pgoff,

                        size,

                        vma->vm_page_prot)) {

        err_msg(err_trace, "%s(): error in remap_page_range.\n", __FUNCTION__ );

        return -EAGAIN;

    }

    return 0;

}

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

void tasklet_isr( unsigned long Context )

{

    struct CDmaChannel *DmaChannel = (struct CDmaChannel *)Context;

    unsigned long flags = 0;

    spin_lock_irqsave(&DmaChannel->m_DmaLock, flags);

    printk("%s(): [DMA%d] m_CurBlockNum = %d, m_BlockCount = %d\n",

           __FUNCTION__, DmaChannel->m_NumberOfChannel, DmaChannel->m_CurBlockNum, DmaChannel->m_BlockCount );

    DmaChannel->m_State = *DmaChannel->m_pStub;

    SetEvent( &DmaChannel->m_BlockEndEvent );

    if(DmaChannel->m_CurBlockNum >= DmaChannel->m_BlockCount)

    {

        HwCompleteDmaTransfer(DmaChannel->m_Board,DmaChannel->m_NumberOfChannel);

        SetEvent( &DmaChannel->m_BufferEndEvent );

        wake_up_interruptible(&DmaChannel->m_DmaWq);

        printk("%s(): Wake up!\n", __FUNCTION__);

    }

    spin_unlock_irqrestore(&DmaChannel->m_DmaLock, flags);

}

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

static irqreturn_t pex_device_isr( int irq, void *pContext )

{

    FIFO_STATUS FifoStatus;  //

    struct pex_device* pDevice = (struct pex_device*)pContext;            // our device

    if(!pDevice->m_DmaIrqEnbl && !pDevice->m_FlgIrqEnbl)

        return IRQ_NONE;

    if(pDevice->m_FlgIrqEnbl)

    {  // прерывание от флагов состояния

        /*

            u32 status = ReadOperationWordReg(pDevice, PEMAINadr_BRD_STATUS);

            err_msg(err_trace, "%s(): BRD_STATUS = 0x%X.\n", __FUNCTION__, status);

            if(status & 0x4000)

            {

                    for(int i = 0; i < NUM_TETR_IRQ; i++)

                            if(pDevice->m_TetrIrq[i] != 0)

                            {

                                    u32 status = ReadAmbMainReg(pDevice, pDevice->m_TetrIrq[i].Address);

                                    KdPrint(("CWambpex::WambpexIsr: TetrIrq = %d, Address = 0x%X, IrqInv = 0x%X, IrqMask = 0x%X, Status = 0x%X.\n",

                                                            i, pDevice->m_TetrIrq[i].Address, pDevice->m_TetrIrq[i].IrqInv, pDevice->m_TetrIrq[i].IrqMask, status));

                                    status ^= pDevice->m_TetrIrq[i].IrqInv;

                                    status &= pDevice->m_TetrIrq[i].IrqMask;

                                    KdPrint(("CWambpex::WambpexIsr: TetrIrq = %d, Address = 0x%X, IrqInv = 0x%X, IrqMask = 0x%X, Status = 0x%X.\n",

                                                            i, pDevice->m_TetrIrq[i].Address, pDevice->m_TetrIrq[i].IrqInv, pDevice->m_TetrIrq[i].IrqMask, status));

                                    if(status)

                                    {

                                            KeInsertQueueDpc(&pDevice->m_TetrIrq[i].Dpc, NULL, NULL);

                                            KdPrint(("CWambpex::WambpexIsr - Tetrad IRQ address = %d\n", pDevice->m_TetrIrq[i].Address));

                                            // сброс статусного бита, вызвавшего прерывание

                                            //pDevice->WriteAmbMainReg(pDevice->m_TetrIrq[i].Address + 0x200);

                                            ULONG CmdAddress = pDevice->m_TetrIrq[i].Address + TRDadr_CMD_ADR * REG_SIZE;

                                            pDevice->WriteAmbMainReg(CmdAddress, 0);

                                            ULONG DataAddress = pDevice->m_TetrIrq[i].Address + TRDadr_CMD_DATA * REG_SIZE;

                                            ULONG Mode0Value = pDevice->ReadAmbMainReg(DataAddress);

                                            Mode0Value &= 0xFFFB;

                                            //pDevice->WriteAmbMainReg(CmdAddress, 0);

                                            pDevice->WriteAmbMainReg(DataAddress, Mode0Value);

                                            break;

                                    }

                            }

                return IRQ_HANDLED;

            }

            else // вообще не наше прерывание !!!

                    return IRQ_NONE;    // we did not interrupt

            */

    }

    if(pDevice->m_DmaIrqEnbl)

    {   // прерывание от каналов ПДП

        u32 i=0;

        u32 FifoAddr = 0;

        u32 iChan = pDevice->m_primChan;

        u32 NumberOfChannel = -1;

        for(i = 0; i < MAX_NUMBER_OF_DMACHANNELS; i++)

        {

            if(pDevice->m_DmaChanMask & (1 << iChan))

            {

                FifoAddr = pDevice->m_FifoAddr[iChan];

                FifoStatus.AsWhole = ReadOperationWordReg(pDevice, PEFIFOadr_FIFO_STATUS + FifoAddr);

                if(FifoStatus.ByBits.IntRql)

                {

                    err_msg(err_trace, "%s(): - Channel = %d, Fifo Status = 0x%X\n", __FUNCTION__, iChan, FifoStatus.AsWhole);

                    NumberOfChannel = iChan;

                    pDevice->m_primChan = ((pDevice->m_primChan+1) >= MAX_NUMBER_OF_DMACHANNELS) ? 0 : pDevice->m_primChan+1;

                    break;

                }

            }

            iChan = ((iChan+1) >= MAX_NUMBER_OF_DMACHANNELS) ? 0 : iChan+1;

        }

        if(NumberOfChannel != -1)

        {

            u32 flag = 0;

            err_msg(err_trace, "%s(%d)\n", __FUNCTION__, atomic_read(&pDevice->m_TotalIRQ));

            flag = NextDmaTransfer(pDevice->m_DmaChannel[NumberOfChannel]);

            if(!flag)

            {

                DMA_CTRL_EXT CtrlExt;

                CtrlExt.AsWhole = 0;

                CtrlExt.ByBits.Pause = 1;

                CtrlExt.ByBits.Start = 1;

                WriteOperationWordReg(pDevice, PEFIFOadr_DMA_CTRL + FifoAddr, CtrlExt.AsWhole);

                //err_msg(err_trace, "%s(): - Pause (%d) - m_CurBlockNum = %d, m_DoneBlock = %d\n", __FUNCTION__, atomic_read(&pDevice->m_TotalIRQ),

                //        pDevice->m_DmaChannel[NumberOfChannel]->m_CurBlockNum,

                //        pDevice->m_DmaChannel[NumberOfChannel]->m_DoneBlock);

            }

            //err_msg(err_trace, "%s(): - Flag Clear\n", __FUNCTION__);

            WriteOperationWordReg(pDevice, PEFIFOadr_FLAG_CLR + FifoAddr, 0x10);

            WriteOperationWordReg(pDevice, PEFIFOadr_FLAG_CLR + FifoAddr, 0x00);

            //err_msg(err_trace, "%s(): - Complete\n", __FUNCTION__);

            atomic_inc(&pDevice->m_TotalIRQ);

            return IRQ_HANDLED;

        }

    }

    return IRQ_NONE;    // we did not interrupt

}

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

struct file_operations pex_fops = {

    .owner = THIS_MODULE,

    .read = NULL,

    .write = NULL,

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

    .unlocked_ioctl = pex_device_ioctl,

    .compat_ioctl = pex_device_ioctl,

#else

    .ioctl = pex_device_ioctl,

#endif

    .mmap = pex_device_mmap,

    .open = pex_device_open,

    .release = pex_device_close,

    .fasync = pex_device_fasync,

    .poll = pex_device_poll,

};

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

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

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

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

static const struct pci_device_id pex_device_id[] = {

{

        .vendor =       INSYS_VENDOR_ID,

        .device =       AMBPEX5_DEVID,

        .subvendor =    PCI_ANY_ID,

        .subdevice =    PCI_ANY_ID,

},

{ },

};

MODULE_DEVICE_TABLE(pci, pex_device_id);

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

static int pex_device_probe(struct pci_dev *dev, const struct pci_device_id *id)

{

    int error = 0;

    int i = 0;

    struct pex_device *brd = NULL;

    mutex_lock(&pex_mutex);

    brd = kzalloc(sizeof(struct pex_device), GFP_KERNEL);

    if(!brd) {

        error = -ENOMEM;

        goto do_out;

    }

    INIT_LIST_HEAD(&brd->m_list);

    mutex_init(&brd->m_BoardMutex);

    sema_init(&brd->m_BoardSem, 1);

    spin_lock_init(&brd->m_BoardLock);

    atomic_set(&brd->m_TotalIRQ, 0);

    init_waitqueue_head(&brd->m_WaitQueue);

    init_timer(&brd->m_TimeoutTimer);

    spin_lock_init(&brd->m_MemListLock);

    atomic_set(&brd->m_MemListCount, 0);

    INIT_LIST_HEAD(&brd->m_MemList);

    brd->m_pci = dev;

    brd->m_Interrupt = -1;

    brd->m_DmaIrqEnbl = 0;

    brd->m_FlgIrqEnbl = 0;

    brd->m_class = pex_class;

    set_device_name(brd, dev->device, boards_count);

    dbg_msg(dbg_trace, "%s(): device_id = %x, vendor_id = %x, board name %s\n", __FUNCTION__, dev->device, dev->vendor, brd->m_name);

    error = pci_enable_device(dev);

    if(error) {

        err_msg(err_trace, "%s(): error enabling pci device\n", __FUNCTION__);

        goto do_free_memory;

    }

    if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) || pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64))) {

        printk("%s(): error set pci dma mask\n", __FUNCTION__);

        goto do_disable_device;

    }

    pci_set_master(dev);

    brd->m_BAR0.physical_address = pci_resource_start(dev, 0);

    brd->m_BAR0.size = pci_resource_len(dev, 0);

    brd->m_BAR0.virtual_address = ioremap_nocache(brd->m_BAR0.physical_address, brd->m_BAR0.size);

    if(!brd->m_BAR0.virtual_address) {

        error = -ENOMEM;

        err_msg(err_trace, "%s(): error map device memory at bar%d\n", __FUNCTION__, 0);

        goto do_disable_device;

    }

    dbg_msg(dbg_trace, "%s(): map bar0 %zx -> %p\n", __FUNCTION__, brd->m_BAR0.physical_address, brd->m_BAR0.virtual_address);

    brd->m_BAR1.physical_address = pci_resource_start(dev, 1);

    brd->m_BAR1.size = pci_resource_len(dev, 1);

    brd->m_BAR1.virtual_address = ioremap_nocache(brd->m_BAR1.physical_address, brd->m_BAR1.size);

    if(!brd->m_BAR1.virtual_address) {

        error = -ENOMEM;

        err_msg(err_trace, "%s(): error map device memory at bar%d\n", __FUNCTION__, 0);

        goto do_unmap_bar0;

    }

    dbg_msg(dbg_trace, "%s(): map bar1 %zx -> %p\n", __FUNCTION__, brd->m_BAR1.physical_address, brd->m_BAR1.virtual_address);

    error = request_irq(dev->irq, pex_device_isr, IRQF_SHARED, brd->m_name, brd);

    if( error < 0) {

        error = -EBUSY;

        err_msg( err_trace, "%s(): error in request_irq()\n", __FUNCTION__ );

        goto do_unmap_bar1;

    }

    brd->m_Interrupt = dev->irq;

    cdev_init(&brd->m_cdev, &pex_fops);

    brd->m_cdev.owner = THIS_MODULE;

    brd->m_cdev.ops = &pex_fops;

    brd->m_devno = MKDEV(MAJOR(devno), boards_count);

    error = cdev_add(&brd->m_cdev, brd->m_devno, 1);

    if(error) {

        err_msg(err_trace, "%s(): Error add char device %d\n", __FUNCTION__, boards_count);

        error = -EINVAL;

        goto do_free_irq;

    }

    dbg_msg(dbg_trace, "%s(): Add cdev %d\n", __FUNCTION__, boards_count);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)

    brd->m_device = device_create(pex_class, NULL, brd->m_devno, "%s%d", "pexdrv", boards_count);

#else

    brd->m_device = device_create(pex_class, NULL, brd->m_devno, NULL, "%s%d", "pexdrv", boards_count);

#endif

    if(!brd->m_device ) {

        err_msg(err_trace, "%s(): Error create device for board: %s\n", __FUNCTION__, brd->m_name);

        error = -EINVAL;

        goto do_delete_cdev;

    }

    dbg_msg(dbg_trace, "%s(): Create device file for board: %s\n", __FUNCTION__, brd->m_name);

    brd->m_BoardIndex = boards_count;

    if(pci_set_dma_mask(brd->m_pci, DMA_BIT_MASK(32))) {

        dbg_msg(dbg_trace, "%s():  Error in dma_set_mask_and_coherent() - no suitable DMA available\n", __FUNCTION__);

    }

    if (dma_set_mask_and_coherent(&brd->m_pci->dev, DMA_BIT_MASK(32))) {

            dbg_msg(dbg_trace, "%s():  Error in dma_set_mask_and_coherent() - no suitable DMA available\n", __FUNCTION__);

    }

    InitializeBoard(brd);

    for(i = 0; i < MAX_NUMBER_OF_DMACHANNELS; i++) {

        if(brd->m_DmaChanMask & (1 << i)) {

            brd->m_DmaChannel[i] = CDmaChannelCreate( i,  tasklet_isr, brd,

                                                      &brd->m_pci->dev,

                                                      brd->m_MaxDmaSize[i],

                                                      brd->m_BlockFifoId[i], 1 );

        }

    }

    pex_register_proc(brd->m_name, 0, brd);

    list_add_tail(&brd->m_list, &device_list);

    boards_count++;

    dbg_msg(dbg_trace, "%s(): Board %s - setup complete\n", __FUNCTION__, brd->m_name);

    mutex_unlock(&pex_mutex);

    return error;

do_delete_cdev:

    cdev_del(&brd->m_cdev);

do_free_irq:

    free_irq(brd->m_Interrupt, brd);

do_unmap_bar1:

    iounmap(brd->m_BAR1.virtual_address);

do_unmap_bar0:

    iounmap(brd->m_BAR0.virtual_address);

do_disable_device:

    pci_disable_device(dev);

do_free_memory:

    kfree(brd);

do_out:

    mutex_unlock(&pex_mutex);

    return error;

}