OpenCores
URL https://opencores.org/ocsvn/pcie_ds_dma/pcie_ds_dma/trunk

Subversion Repositories pcie_ds_dma

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /pcie_ds_dma/trunk/soft/linux/driver/pexdrv
    from Rev 2 to Rev 6
    ↔ Reverse comparison
  •

Rev 2 → Rev 6

/hardware.h
11,6 → 11,8
#define AMBPEX5_DEVID 0x5507
#define AMBPEXARM_DEVID 0x5702
#define AMBFMC106P_DEVID 0x550A
#define AMBFMC114V_DEVID 0x550C
#define AMBKU_SSCOS_DEVID 0x5703
 
//-----------------------------------------------------------------------------
 
26,8 → 28,6
void WriteOperationReg(struct pex_device *brd, u32 RelativePort, u32 Value);
u16 ReadOperationWordReg(struct pex_device *brd, u32 RelativePort);
void WriteOperationWordReg(struct pex_device *brd, u32 RelativePort, u16 Value);
u8 ReadOperationByteReg(struct pex_device *brd, u32 RelativePort);
void WriteOperationByteReg(struct pex_device *brd, u32 RelativePort, u8 Value);
u32 ReadAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort);
u32 ReadAmbMainReg(struct pex_device *brd, u32 RelativePort);
void WriteAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort, u32 Value);
/pexmodule.c
39,7 → 39,7
static LIST_HEAD(device_list);
static int boards_count = 0;
static struct mutex pex_mutex;
int dbg_trace = 0;
int dbg_trace = 1;
int err_trace = 1;
 
//-----------------------------------------------------------------------------
473,6 → 473,18
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{
.vendor = INSYS_VENDOR_ID,
.device = AMBFMC114V_DEVID,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{
.vendor = INSYS_VENDOR_ID,
.device = AMBKU_SSCOS_DEVID,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
},
{ },
};
 
573,9 → 585,9
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", brd->m_name);
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", brd->m_name);
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);
643,6 → 655,7
{
struct list_head *pos, *n;
struct pex_device *brd = NULL;
int i = 0;
 
dbg_msg(dbg_trace, "%s(): device_id = %x, vendor_id = %x\n", __FUNCTION__, dev->device, dev->vendor);
 
658,6 → 671,12
dbg_msg(dbg_trace, "%s(): free_irq() - complete\n", __FUNCTION__);
pex_remove_proc(brd->m_name);
dbg_msg(dbg_trace, "%s(): pex_remove_proc() - complete\n", __FUNCTION__);
for(i = 0; i < MAX_NUMBER_OF_DMACHANNELS; i++) {
if(brd->m_DmaChannel[i]) {
CDmaChannelDelete(brd->m_DmaChannel[i]);
dbg_msg(dbg_trace, "%s(): free DMA channel %d - complete\n", __FUNCTION__, i);
}
}
free_memory(brd);
dbg_msg(dbg_trace, "%s(): free_memory() - complete\n", __FUNCTION__);
device_destroy(pex_class, brd->m_devno);
/exam/pex_test.cpp
15,6 → 15,8
#include <sys/mman.h>
#include <fcntl.h>
 
#include "utypes_linux.h"
#include "brd_info.h"
#include "pexioctl.h"
#include "ambpexregs.h"
 
/exam/Makefile
12,7 → 12,7
CC = $(CROSS_COMPILE)g++
LD = $(CROSS_COMPILE)g++
 
CFLAGS := -D__LINUX__ -g -Wall -I..
CFLAGS := -D__LINUX__ -g -Wall -I.. -I../../../common/utils -I../../../common/board
LFLAGS = -Wl
 
$(TARGET_NAME): $(patsubst %.cpp,%.o, $(wildcard *.cpp))
/pexproc.c
19,7 → 19,7
 
void pex_register_proc( char *name, void *fptr, void *data )
{
create_proc_read_entry( name, 0, NULL, fptr, data );
create_proc_read_entry( name, 0, NULL, fptr, data );
}
 
//--------------------------------------------------------------------
26,11 → 26,74
 
void pex_remove_proc( char *name )
{
remove_proc_entry( name, NULL );
remove_proc_entry( name, NULL );
}
 
//--------------------------------------------------------------------
 
int pex_show_capabilities( char *buf, struct pex_device *brd )
{
int i = 0, res = -1;
char *p = buf;
u8 cap;
u8 cap_id;
 
p += sprintf(p,"\n" );
p += sprintf(p," Device capabilities\n" );
p += sprintf(p,"\n" );
 
res = pci_read_config_byte(brd->m_pci, 0x34, &cap);
if(res < 0) {
p += sprintf(p, " Error read capabilities pointer\n");
goto err_exit;
}
res = pci_read_config_byte(brd->m_pci, cap, &cap_id);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
}
if(cap_id != 0x10) { //not PCI Express capabilities
 
res = pci_read_config_byte(brd->m_pci, cap+1, &cap);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
}
}
res = pci_read_config_byte(brd->m_pci, cap, &cap_id);
if(res < 0) {
p += sprintf(p, " Error read capabilities id\n");
goto err_exit;
} else {
p += sprintf(p, " CAP_ID = 0x%X\n", cap_id);
}
 
if(cap_id != 0x10) {
p += sprintf(p, " Can't find PCI Express capabilities\n");
goto err_exit;
}
 
for(i=0; i<9; i++) {
u32 reg = 0;
int j = cap + 4*i;
res = pci_read_config_dword(brd->m_pci, j, &reg);
if(res < 0) {
p += sprintf(p, " Error read capabilities sructure: offset %x\n", j);
goto err_exit;
}
p += sprintf(p, " %x: = 0x%X\n", j, reg);
}
 
err_exit:
 
return (p-buf);
}
 
//--------------------------------------------------------------------
 
int pex_proc_info( char *buf,
char **start,
off_t off,
38,63 → 101,68
int *eof,
void *data )
{
int iBlock = 0;
char *p = buf;
struct pex_device *brd = (struct pex_device*)data;
int iBlock = 0;
char *p = buf;
struct pex_device *brd = (struct pex_device*)data;
 
if(!brd) {
p += sprintf(p," Invalid device pointer\n" );
*eof = 1;
return p - buf;
}
if(!brd) {
p += sprintf(p," Invalid device pointer\n" );
*eof = 1;
return p - buf;
}
 
p += sprintf(p," Device information\n" );
p += pex_show_capabilities(p, brd);
 
p += sprintf(p, " m_TotalIRQ = %d\n", atomic_read(&brd->m_TotalIRQ));
p += sprintf(p,"\n" );
p += sprintf(p," Device information\n" );
 
for(iBlock = 0; iBlock < brd->m_BlockCnt; iBlock++)
{
u32 FifoAddr = 0;
u16 val = 0;
p += sprintf(p, " m_TotalIRQ = %d\n", atomic_read(&brd->m_TotalIRQ));
 
FifoAddr = (iBlock + 1) * PE_FIFO_ADDR;
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_ID + FifoAddr);
 
if((val & 0x0FFF) != PE_EXT_FIFO_ID)
continue;
 
p += sprintf(p,"\n" );
p += sprintf(p," PE_EXT_FIFO %d\n", iBlock+1 );
p += sprintf(p,"\n" );
for(iBlock = 0; iBlock < brd->m_BlockCnt; iBlock++)
{
u32 FifoAddr = 0;
u16 val = 0;
 
p += sprintf(p," BLOCK_ID = %x\n", (val & 0x0FFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_VER + FifoAddr);
p += sprintf(p," BLOCK_VER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_ID + FifoAddr);
p += sprintf(p," FIFO_ID = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_NUM + FifoAddr);
p += sprintf(p," FIFO_NUMBER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_SIZE + FifoAddr);
p += sprintf(p," RESOURCE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_CTRL + FifoAddr);
p += sprintf(p," DMA_MODE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_CTRL + FifoAddr);
p += sprintf(p," DMA_CTRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_STATUS + FifoAddr);
p += sprintf(p," FIFO_STATUS = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FLAG_CLR + FifoAddr);
p += sprintf(p," FLAG_CLR = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRL + FifoAddr);
p += sprintf(p," PCI_ADRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRH + FifoAddr);
p += sprintf(p," PCI_ADRH = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_LOCAL_ADR + FifoAddr);
p += sprintf(p," LOCAL_ADR = %x\n", (val & 0xFFFF) );
}
FifoAddr = (iBlock + 1) * PE_FIFO_ADDR;
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_ID + FifoAddr);
 
*eof = 1;
if((val & 0x0FFF) != PE_EXT_FIFO_ID)
continue;
 
return p - buf;
p += sprintf(p,"\n" );
p += sprintf(p," PE_EXT_FIFO %d\n", iBlock+1 );
p += sprintf(p,"\n" );
 
p += sprintf(p," BLOCK_ID = %x\n", (val & 0x0FFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_BLOCK_VER + FifoAddr);
p += sprintf(p," BLOCK_VER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_ID + FifoAddr);
p += sprintf(p," FIFO_ID = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_NUM + FifoAddr);
p += sprintf(p," FIFO_NUMBER = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_SIZE + FifoAddr);
p += sprintf(p," RESOURCE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_CTRL + FifoAddr);
p += sprintf(p," DMA_MODE = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_DMA_CTRL + FifoAddr);
p += sprintf(p," DMA_CTRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FIFO_STATUS + FifoAddr);
p += sprintf(p," FIFO_STATUS = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_FLAG_CLR + FifoAddr);
p += sprintf(p," FLAG_CLR = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRL + FifoAddr);
p += sprintf(p," PCI_ADRL = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_PCI_ADDRH + FifoAddr);
p += sprintf(p," PCI_ADRH = %x\n", (val & 0xFFFF) );
val = ReadOperationWordReg(brd, PEFIFOadr_LOCAL_ADR + FifoAddr);
p += sprintf(p," LOCAL_ADR = %x\n", (val & 0xFFFF) );
}
 
*eof = 1;
 
return p - buf;
}
 
//--------------------------------------------------------------------
/insert
4,32 → 4,69
# This script is loading modules in the kernel.
#
 
kernel=`uname -r | grep 2.6`
status ()
{
if [ $1 -eq 0 ] ; then
echo "[SUCCESS]"
else
echo "[FAILED]"
 
if [ ${kernel} = "" ]
if [ $2 -eq 1 ] ; then
echo "... loading aborted."
exit 1
fi
fi
}
 
echo
 
kernel=`uname -r | grep 2.4`
 
if [ $kernel ]
then
module=ambpex.o
module=pexdrv.o
mname=${module%.o}
else
module=`find *.ko`
mname=${module%.ko}
fi
module="pexdrv.ko"
 
if [ ${module} = "" ]
device=pexdrv
mode="666"
 
chmod 777 /dev/shm
 
if [ ${module} ]
then
echo No kernel module found. ${module}
exit
echo -n " Find ${module} module : "
status $? 0
else
echo Find ${module} - kernel module.
echo -n " Kernel module not found : "
status 1 0
exit
fi
 
/sbin/insmod ./$module $* || exit 1
was_loaded=`/sbin/lsmod | cut -c 1-6 | grep $device`
 
sleep 1
if [ ${was_loaded} ]
then
echo -n " Remove loaded module : "
/sbin/rmmod $device
status $? 0
else
echo Loading module: ${module}
fi
 
devfiles=`ls /dev/* | grep AMB`
echo -n " Loading pexdrv module : "
insmod ./${module}
 
#echo ${devfiles}
until [ -e /dev/pexdrv0 ]
do
sleep 1.5
done
 
chmod -v 666 ${devfiles}
chmod 666 /dev/pexdrv*
 
status $? 0
 
echo
/ioctlrw.c
15,6 → 15,7
#include "pexioctl.h"
#include "hardware.h"
#include "ambpexregs.h"
#include "brd_info.h"
 
//--------------------------------------------------------------------
 
/dmachan.c
79,6 → 79,8
// а при повторных только отображаем выделенную память на пользовательское пространство
if(!dma->m_UseCount)
{
dma_addr_t pa = (dma_addr_t)0;
 
dma->m_MemType = bMemType;
dma->m_BlockCount = *pCount;
dma->m_BlockSize = size;
86,7 → 88,7
// выделяем память под описатели блоков (системный, и логический адрес для каждого блока)
dma->m_pBufDscr.SystemAddress = (void*)dma_alloc_coherent( dma->m_dev,
dma->m_BlockCount * sizeof(SHARED_MEMORY_DESCRIPTION),
&dma->m_pBufDscr.LogicalAddress, GFP_KERNEL);
&pa, GFP_KERNEL);
if(!dma->m_pBufDscr.SystemAddress)
{
printk("<0>%s(): Not memory for buffer descriptions\n", __FUNCTION__);
93,6 → 95,7
return -ENOMEM;
}
 
dma->m_pBufDscr.LogicalAddress = (size_t)pa;
dma->m_ScatterGatherTableEntryCnt = 0;
}
 
/pexioctl.h
93,18 → 93,6
PEX_MAKE_IOCTL(PEX_DEVICE_TYPE, PEX_ADJUST)
 
//-----------------------------------------------------------------------------
// board configuration data structure
struct board_info {
size_t PhysAddress[6]; // OUT
void* VirtAddress[6]; // OUT
size_t Size[6]; // OUT
size_t InterruptLevel; // OUT
size_t InterruptVector;// OUT
unsigned short vendor_id; // OUT
unsigned short device_id; // OUT
};
 
//-----------------------------------------------------------------------------
// memory block structure
struct memory_block {
size_t phys;
/Makefile
1,6 → 1,7
 
KERNELVER := $(shell uname -r)
EXTRA_CFLAGS += -O2
EXTRA_CFLAGS += -I $(PWD)/../../common/board
 
ifneq ($(KERNELRELEASE),)
 
14,7 → 15,7
PWD := $(shell pwd)
 
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) $(DIRS)
$(MAKE) -C $(KERNELDIR) M=$(PWD) EXTRA_CFLAGS="$(EXTRA_CFLAGS)"
 
endif
 
29,3 → 30,6
ifeq (.depend, $(wildcard .depend))
include .depend
endif
 
install:
./insert
/hardware.c
27,8 → 27,10
case AMBPEX8_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBPEX8", index); break;
case ADP201X1AMB_DEVID: snprintf(brd->m_name, 128, "%s%d", "ADP201X1AMB", index); break;
case ADP201X1DSP_DEVID: snprintf(brd->m_name, 128, "%s%d", "ADP201X1DSP", index); break;
case AMBPEXARM_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBPEXARM_DEVID", index); break;
case AMBFMC106P_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC106P_DEVID", index); break;
case AMBPEXARM_DEVID: snprintf(brd->m_name, 128, "%s%d", "D2XT005", index); break;
case AMBFMC106P_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC106P", index); break;
case AMBFMC114V_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBFMC114V", index); break;
case AMBKU_SSCOS_DEVID: snprintf(brd->m_name, 128, "%s%d", "AMBKU_SSCOS", index); break;
default:
snprintf(brd->m_name, sizeof(brd->m_name), "%s%d", "Unknown", index); break;
}
113,8 → 115,12
if((AMBPEX8_DEVID != deviceID) &&
(ADP201X1AMB_DEVID != deviceID) &&
(AMBPEX5_DEVID != deviceID) &&
(AMBPEXARM_DEVID != deviceID))
(AMBPEXARM_DEVID != deviceID) &&
(AMBFMC114V_DEVID != deviceID)) {
 
dbg_msg(dbg_trace, "%s(): Unsupported device id: 0x%X.\n", __FUNCTION__, deviceID);
return -ENODEV;
}
 
temp = ReadOperationWordReg(brd, PEMAINadr_PLD_VER);
 
265,7 → 271,9
 
u16 ReadOperationWordReg(struct pex_device *brd, u32 RelativePort)
{
return readw((u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
u32 tmpVal = readl((u32*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
return (tmpVal & 0xFFFF);
//return readw((u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
272,25 → 280,13
 
void WriteOperationWordReg(struct pex_device *brd, u32 RelativePort, u16 Value)
{
writew( Value, (u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
u32 tmpVal = Value;
//writew( Value, (u16*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
writel( tmpVal, (u32*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
u8 ReadOperationByteReg(struct pex_device *brd, u32 RelativePort)
{
return readb((u8*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
void WriteOperationByteReg(struct pex_device *brd, u32 RelativePort, u8 Value)
{
writeb( Value, (u8*)((u8*)brd->m_BAR0.virtual_address + RelativePort));
}
 
//--------------------------------------------------------------------
 
u32 ReadAmbReg(struct pex_device *brd, u32 AdmNumber, u32 RelativePort)
{
u8* pBaseAddress = (u8*)brd->m_BAR1.virtual_address + AdmNumber * ADM_SIZE;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.