/* bspVmeDmaList.c:
* implementation of generic parts of the 'linked-list VME DMA' API.
*/
/*
* Authorship
* ----------
* This software was created by
* Till Straumann <strauman@slac.stanford.edu>, 2006, 2007,
* Stanford Linear Accelerator Center, Stanford University.
*
* Acknowledgement of sponsorship
* ------------------------------
* This software was produced by
* the Stanford Linear Accelerator Center, Stanford University,
* under Contract DE-AC03-76SFO0515 with the Department of Energy.
*
* Government disclaimer of liability
* ----------------------------------
* Neither the United States nor the United States Department of Energy,
* nor any of their employees, makes any warranty, express or implied, or
* assumes any legal liability or responsibility for the accuracy,
* completeness, or usefulness of any data, apparatus, product, or process
* disclosed, or represents that its use would not infringe privately owned
* rights.
*
* Stanford disclaimer of liability
* --------------------------------
* Stanford University makes no representations or warranties, express or
* implied, nor assumes any liability for the use of this software.
*
* Stanford disclaimer of copyright
* --------------------------------
* Stanford University, owner of the copyright, hereby disclaims its
* copyright and all other rights in this software. Hence, anyone may
* freely use it for any purpose without restriction.
*
* Maintenance of notices
* ----------------------
* In the interest of clarity regarding the origin and status of this
* SLAC software, this and all the preceding Stanford University notices
* are to remain affixed to any copy or derivative of this software made
* or distributed by the recipient and are to be affixed to any copy of
* software made or distributed by the recipient that contains a copy or
* derivative of this software.
*
* ------------------ SLAC Software Notices, Set 4 OTT.002a, 2004 FEB 03
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <bsp/bspVmeDmaList.h>
#include "bspVmeDmaListP.h"
#define DEBUG
typedef struct VMEDmaListNodeRec_ {
VMEDmaListNode p, n; /* linkage */
DmaDescriptor d; /* real descriptor */
void *usrData;
VMEDmaListClass class; /* pointer to 'class' record */
} VMEDmaListNodeRec;
#define LCHUNK 10
#ifdef DEBUG
static void
lprint(VMEDmaListNode d)
{
printf("n 0x%08lx, p: 0x%08lx, n: 0x%08lx d: 0x%08lx\n",
(uint32_t)d, (uint32_t)d->p, (uint32_t)d->n, (uint32_t)d->d);
}
#endif
static VMEDmaListNode
lalloc(VMEDmaListClass pc)
{
VMEDmaListNode rval;
int i;
if ( !pc->freeList ) {
/* alloc block of 10 descriptors */
pc->freeList = calloc( (LCHUNK), sizeof(*pc->freeList));
if ( ! (pc->freeList) ) {
return 0;
}
/* link together and set 'class' pointer */
for (i=0; i<(LCHUNK)-1; i++) {
pc->freeList[i].n = &pc->freeList[i+1];
pc->freeList[i].class = pc;
}
pc->freeList[i].n = 0;
pc->freeList[i].class = pc;
/* Allocate 'real' descriptor memory */
if ( pc->desc_alloc ) {
for (i=0; i<(LCHUNK); i++) {
if ( ! (pc->freeList[i].d = pc->desc_alloc()) ) {
int j;
if ( pc->desc_free ) {
for (j=0; j<i; j++)
pc->desc_free(pc->freeList[i].d);
}
free(pc->freeList);
pc->freeList = 0;
return 0;
}
}
} else {
int blksize;
uint32_t algnmsk = pc->desc_align - 1;
char *memptr;
/* ignore their 'free' method */
pc->desc_free = 0;
blksize = (pc->desc_size + algnmsk) & ~algnmsk;
if ( ! (memptr = malloc(blksize*(LCHUNK) + pc->desc_align - 1)) ) {
free(pc->freeList);
pc->freeList = 0;
return 0;
}
/* align memory ptr; must not be freed() anymore */
memptr = (char*)( ((uint32_t)memptr + algnmsk) & ~ algnmsk );
for ( i = 0; i<(LCHUNK); i++, memptr+=blksize ) {
memset(memptr, 0, blksize);
pc->freeList[i].d = (DmaDescriptor)memptr;
}
}
}
rval = pc->freeList;
pc->freeList = pc->freeList->n;
rval->n = rval->p = 0;
return rval;
}
static int
lfree(VMEDmaListNode d)
{
if ( d->p || d->n )
return -1;
d->n = d->class->freeList;
d->class->freeList = d;
return 0;
}
static int
lenq(VMEDmaListNode a, VMEDmaListNode d)
{
if ( a ) {
/* enqueue */
if ( d->n || d->p )
return -1;
if ( (d->n = a->n) )
a->n->p = d;
d->p = a;
a->n = d;
} else {
/* dequeue */
if ( d->n )
d->n->p = d->p;
if ( d->p )
d->p->n = d->n;
d->n = d->p = 0;
}
return 0;
}
int
BSP_VMEDmaListDescriptorStartTool(volatile void *controller, int channel, VMEDmaListNode n)
{
if ( !n )
return -1;
return n->class->desc_start(controller, channel, n->d);
}
VMEDmaListNode
BSP_VMEDmaListDescriptorSetupTool(
VMEDmaListNode n,
uint32_t attr_mask,
uint32_t xfer_mode,
uint32_t pci_addr,
uint32_t vme_addr,
uint32_t n_bytes)
{
if ( !n )
return 0;
if ( n->class->desc_setup(n->d, attr_mask, xfer_mode, pci_addr, vme_addr, n_bytes) ) {
return 0;
}
return n;
}
VMEDmaListNode
BSP_VMEDmaListDescriptorNewTool(
VMEDmaListClass pc,
uint32_t attr_mask,
uint32_t xfer_mode,
uint32_t pci_addr,
uint32_t vme_addr,
uint32_t n_bytes)
{
VMEDmaListNode n;
if ( !(n=lalloc(pc)) )
return 0; /* no memory */
if ( n->class->desc_init )
n->class->desc_init(n->d);
if ( n->class->desc_setup(n->d, attr_mask, xfer_mode, pci_addr, vme_addr, n_bytes) ) {
BSP_VMEDmaListDescriptorDestroy(n);
return 0;
}
return n;
}
int
BSP_VMEDmaListDescriptorDestroy(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
return lfree(d);
}
int
BSP_VMEDmaListDestroy(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
VMEDmaListNode n;
while (d) {
n = d->n;
if ( BSP_VMEDmaListDescriptorEnq(0, d) ||
BSP_VMEDmaListDescriptorDestroy(d) )
return -1;
d = n;
}
return 0;
}
int
BSP_VMEDmaListDescriptorEnq(BSP_VMEDmaListDescriptor p, BSP_VMEDmaListDescriptor q)
{
VMEDmaListNode anchor = p;
VMEDmaListNode d = q;
DmaDescriptorSetNxt setnxt = d->class->desc_setnxt;
if ( !anchor ) {
/* dequeue can't fail - we can update dnlal first (need d->p) */
if ( d->p )
setnxt(d->p->d, d->n ? d->n->d : 0);
/* paranoia */
setnxt(d->d, 0);
} else {
if ( d->class != anchor->class )
return -1;
}
if ( lenq(anchor, d) )
return -1;
/* update descriptor pointers */
if ( anchor ) {
setnxt(d->d, d->n ? d->n->d : 0);
setnxt(anchor->d, d->d);
}
return 0;
}
BSP_VMEDmaListDescriptor
BSP_VMEDmaListDescriptorNext(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
return d->n;
}
BSP_VMEDmaListDescriptor
BSP_VMEDmaDescriptorPrev(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
return d->p;
}
void
BSP_VMEDmaListDescriptorSetUsr(BSP_VMEDmaListDescriptor p, void *usrData)
{
VMEDmaListNode d = p;
d->usrData = usrData;
}
void *
BSP_VMEDmaListDescriptorGetUsr(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
return d->usrData;
}
int
BSP_VMEDmaListRefresh(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode anchor = p;
DmaDescriptorRefr desc_refr;
VMEDmaListNode n;
if ( (desc_refr = anchor->class->desc_refr) ) {
for ( n = anchor; n; n = n->n ) {
desc_refr(n->d);
}
}
return 0;
}
#ifdef DEBUG
void
BSP_VMEDmaListDump(BSP_VMEDmaListDescriptor p)
{
VMEDmaListNode d = p;
while (d) {
printf("----------\n");
lprint(d);
if (d->class->desc_dump)
d->class->desc_dump(d->d);
d = d->n;
}
}
#endif
