epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity
Files
4cb7ccbbb8d1b3fb4730bdd754eba9117ffbdafb
pcas/src/drv/drvBitBus.c

1231 lines
37 KiB
C
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#define DO_RESET_AND_OFFLINE
/* share/src/drv $Id$ */
/*
* Original Author: Ned Arnold
* Author: John Winans
* Date: 09-10-91
* XVME-402 BitBus driver
*
* Experimental Physics and Industrial Control System (EPICS)
*
* Copyright 1991, the Regents of the University of California,
* and the University of Chicago Board of Governors.
*
* This software was produced under U.S. Government contracts:
* (W-7405-ENG-36) at the Los Alamos National Laboratory,
* and (W-31-109-ENG-38) at Argonne National Laboratory.
*
* Initial development by:
* The Controls and Automation Group (AT-8)
* Ground Test Accelerator
* Accelerator Technology Division
* Los Alamos National Laboratory
*
* Co-developed with
* The Controls and Computing Group
* Accelerator Systems Division
* Advanced Photon Source
* Argonne National Laboratory
*
* Modification Log:
* -----------------
* .01 09-30-91 jrw Completely redesigned and rewritten
* .02 12-02-91 jrw Changed priority info to arrays
* .03 12-16-91 jrw Made the data portion of the message a pointer
* .04 01-21-91 jrw moved the task parameters into task_params.h
* .05 02-12-92 jrw removed IRQ based transmission.
* .06 04-08-92 jrw moved the device configs into module_types.h
* .07 09-28-92 jrw upped the reset delay time to 1/2 second
* .08 08-02-93 mrk Added call to taskwdInsert
*
* NOTES:
* This driver currently needs work on error message generation.
*/
#include <vxWorks.h>
#include <types.h>
#include <iosLib.h>
#include <taskLib.h>
#include <memLib.h>
#include <semLib.h>
#include <rngLib.h>
#include <wdLib.h>
#include <wdLib.h>
#include <tickLib.h>
#include <vme.h>
#include <task_params.h>
#include <module_types.h>
#include <drvSup.h>
#include <dbDefs.h>
#include <link.h>
#include <callback.h>
#include <taskwd.h>
#include <drvBitBusInterface.h>
#include "drvBitBus.h"
static long reportBB(), initBB(), qBBReq();
static int xvmeTmoHandler(), xvmeRxTask(), xvmeTxTask(), xvmeWdTask();
static int xvmeIrqRdav(), xvmeIrqRcmd();
int BB_MAX_OUTSTANDING_MSGS = 4;
int bbDebug = 0; /* set to 1 from the shell to print debugging info */
/******************************************************************************
*
* This structure contains a list of the outside-callable functions.
*
******************************************************************************/
struct drvBitBusEt drvBitBus = {
3,
reportBB,
initBB,
qBBReq
};
static char init_called = 0; /* to insure that init is done first */
static void *short_base; /* base of short address space */
static struct xvmeLink *pXvmeLink[BB_NUM_LINKS];/* NULL if link not present */
/******************************************************************************
*
* This function prints a message indicating the presence of each BB
* card found in the system.
*
******************************************************************************/
static long
reportBB()
{
int i;
printf("Debugging flag is set to %d\n", bbDebug);
if (init_called)
{
for (i=0; i< BB_NUM_LINKS; i++)
{
if (pXvmeLink[i] != NULL)
{
printf("Link %d (address 0x%08.8X) present and initialized.\n", i, pXvmeLink[i]->bbRegs);
printf(" %d mesages on busy list\n", pXvmeLink[i]->pbbLink->busyList.elements);
}
else
{
printf("Link %d not installed.\n", i);
}
}
}
else
{
printf("BB driver has not yet been initialized.\n");
}
return(OK);
}
/******************************************************************************
*
* Called by the iocInit processing.
* initBB, probes the bb card addresses and if one is present, it
* is initialized for use.
*
******************************************************************************/
static long
initBB()
{
int i;
int j;
int probeValue;
struct xvmeRegs *pXvmeRegs;
char *nameTemp[50];
int taskId;
if (init_called)
{
printf("initBB(): BB devices already initialized!\n");
return(ERROR);
}
/* figure out where the short address space is */
sysBusToLocalAdrs(VME_AM_SUP_SHORT_IO , 0, &short_base);
if (bbDebug)
{
printf("BB driver package initializing\n");
printf("short_base 0x%08.8X\n", short_base);
printf("BB_SHORT_OFF 0x%08.8X\n", BB_SHORT_OFF);
printf("BB_NUM_LINKS 0x%08.8X\n", BB_NUM_LINKS);
}
probeValue = XVME_RESET;
pXvmeRegs = (struct xvmeRegs *)((unsigned int)short_base + BB_SHORT_OFF);
for (i=0; i<BB_NUM_LINKS; i++)
{
if (vxMemProbe(&(pXvmeRegs->fifo_stat), WRITE, 1, &probeValue) < OK)
{ /* no BB board present here */
pXvmeLink[i] = (struct xvmeLink *) NULL;
if (bbDebug)
printf("Probing of address 0x%08.8X failed\n", pXvmeRegs);
}
else
{ /* BB board found... reserve space for structures */
#if FALSE
xvmeReset(pXvmeRegs, i); /* finish resetting the xvme module */
#endif
if (bbDebug)
printf("BB card found at address 0x%08.8X\n", pXvmeRegs);
if ((pXvmeLink[i] = (struct xvmeLink *) malloc(sizeof(struct xvmeLink))) == NULL)
{
printf("Can't malloc memory for link data structures!\n");
return(ERROR);
}
if ((pXvmeLink[i]->pbbLink = (struct bbLink *) malloc(sizeof(struct bbLink))) == NULL)
{
printf("Can't malloc memory for link data structures!\n");
return(ERROR);
}
pXvmeLink[i]->pbbLink->linkType = BITBUS_IO; /* spec'd in link.h */
pXvmeLink[i]->pbbLink->linkId = i; /* link number */
pXvmeLink[i]->pbbLink->linkEventSem = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
pXvmeLink[i]->rxInt = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
/* init all the prioritized queue lists */
for (j=0; j<BB_NUM_PRIO; j++)
{
pXvmeLink[i]->pbbLink->queue[j].head = NULL;
pXvmeLink[i]->pbbLink->queue[j].tail = NULL;
pXvmeLink[i]->pbbLink->queue[j].sem = semBCreate(SEM_Q_PRIORITY, SEM_FULL);
pXvmeLink[i]->pbbLink->queue[j].elements = 0;
}
/* init the busy message list */
pXvmeLink[i]->pbbLink->busyList.sem = semBCreate(SEM_Q_PRIORITY, SEM_FULL);
pXvmeLink[i]->pbbLink->busyList.head = NULL;
pXvmeLink[i]->pbbLink->busyList.tail = NULL;
pXvmeLink[i]->pbbLink->busyList.elements = 0;
for (j=0; j<BB_APERLINK; j++)
{
/* Assume all nodes are IDLE */
pXvmeLink[i]->pbbLink->deviceStatus[j] = BB_IDLE;
}
pXvmeLink[i]->bbRegs = pXvmeRegs;
pXvmeLink[i]->watchDogId = wdCreate();
pXvmeLink[i]->watchDogSem = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
/* clear the link abort status */
pXvmeLink[i]->abortFlag = 0;
pXvmeLink[i]->txAbortAck = 0;
pXvmeLink[i]->rxAbortAck = 0;
xvmeReset(pXvmeRegs, i); /* finish resetting the xvme module */
/* attach the interrupt handler routines */
intConnect((BB_IVEC_BASE + 1 + (i*4)) * 4, xvmeIrqRcmd, i);
intConnect((BB_IVEC_BASE + 3 + (i*4)) * 4, xvmeIrqRdav, i);
/* start a task to manage the TX link */
sprintf(nameTemp, "%s%d", BBTXLINK_NAME, i);
if ((taskId=taskSpawn(nameTemp, BBTXLINK_PRI, BBTXLINK_OPT, BBTXLINK_STACK, xvmeTxTask, i)) == ERROR)
{
printf("initBB: failed to start TX link task for link %d\n", i);
}
taskwdInsert(taskId,NULL,NULL);
/* start a task to manage the RX link */
sprintf(nameTemp, "%s%d", BBRXLINK_NAME, i);
if ((taskId=taskSpawn(nameTemp, BBRXLINK_PRI, BBRXLINK_OPT, BBRXLINK_STACK, xvmeRxTask, i)) == ERROR)
{
printf("initBB: failed to start RX link task for link %d\n", i);
}
taskwdInsert(taskId,NULL,NULL);
/* start a task to keep an eye on the busy list */
sprintf(nameTemp, "%s%d", BBWDTASK_NAME, i);
if ((taskId=taskSpawn(nameTemp, BBWDTASK_PRI, BBWDTASK_OPT, BBWDTASK_STACK, xvmeWdTask, i)) == ERROR)
{
printf("initBB: failed to start watchdog task for link %d\n", i);
}
taskwdInsert(taskId,NULL,NULL);
}
pXvmeRegs++; /* ready for next board window */
}
sysIntEnable(BB_IRQ_LEVEL);
init_called = 1; /* let reportBB() know init occured */
return(OK);
}
/******************************************************************************
*
* Reset an xvme-402 BitBus card by cycling the reset bit in the fifo
* status register.
*
******************************************************************************/
static int
xvmeReset(xvmeRegs, link)
struct xvmeRegs *xvmeRegs;
int link;
{
char trash;
int j;
int lockKey;
if (bbDebug)
printf("xvmeReset(%08.8X, %d): Resetting xvme module\n", xvmeRegs, link);
xvmeRegs->fifo_stat = XVME_RESET; /* assert the reset pulse */
taskDelay(2);
xvmeRegs->fifo_stat = 0; /* clear the reset pulse */
taskDelay(30); /* give the 8044 time to self check */
j = 100; /* give up after this */
while ((xvmeRegs->fifo_stat & XVME_RCMD) && --j)
trash = xvmeRegs->cmnd; /* flush command buffer if junk in it */
if (!j)
{
printf("xvmeReset(%d): Command buffer will not clear after reset!\n", link);
return(ERROR);
}
j = 100;
while ((xvmeRegs->fifo_stat & XVME_RFNE) && --j)
trash = xvmeRegs->data; /* flush data buffer if junk in it */
if (!j)
{
printf("xvmeReset(%d): Data buffer will not clear after reset!\n", link);
return(ERROR);
}
if ((xvmeRegs->fifo_stat & XVME_FSVALID) != XVME_FSIDLE)
{
printf("xvmeReset(%d): XVME board not returning to idle status after reset!\n", link);
return(ERROR);
}
/* set the interrupt vector */
lockKey = intLock();
xvmeRegs->stat_ctl = 0; /* disable all interupts */
xvmeRegs->int_vec = BB_IVEC_BASE + (link*4);/* set the int vector */
intUnlock(lockKey);
semGive(pXvmeLink[link]->rxInt); /* Tell xvmeRxTask to Re-enable interrupts */
return(OK);
}
/******************************************************************************
*
* This function is used to add a node to the HEAD of a list.
*
******************************************************************************/
static int
listAddHead(plist, pnode)
struct bbList *plist;
struct dpvtBitBusHead *pnode;
{
pnode->prev = NULL;
pnode->next = plist->head;
if (plist->head != NULL)
plist->head->prev = pnode;
if (plist->tail == NULL)
plist->tail = pnode;
plist->head = pnode;
plist->elements++;
return(0);
}
/******************************************************************************
*
* This function is used to add a node to the TAIL of a list.
*
******************************************************************************/
static int
listAddTail(plist, pnode)
struct bbList *plist;
struct dpvtBitBusHead *pnode;
{
pnode->next = NULL; /* No next node if this is the TAIL */
pnode->prev = plist->tail; /* previous node is the 'old' TAIL node */
if (plist->tail != NULL)
plist->tail->next = pnode; /* link the 'old' tail to the 'new' tail node */
if (plist->head == NULL)
plist->head = pnode;
plist->tail = pnode; /* this is the 'new' tail node */
plist->elements++;
return(0);
}
/******************************************************************************
*
* This function is used to delete a node from a list.
*
******************************************************************************/
static int
listDel(plist, pnode)
struct bbList *plist;
struct dpvtBitBusHead *pnode;
{
if (pnode->next != NULL)
pnode->next->prev = pnode->prev;
if (pnode->prev != NULL)
pnode->prev->next = pnode->next;
if (plist->head == pnode)
plist->head = pnode->next;
if (plist->tail == pnode)
plist->tail = pnode->prev;
plist->elements--;
return(0);
}
/******************************************************************************
*
* Interrupt handler that is called when the receiver has a byte that should be
* read.
*
******************************************************************************/
static int
xvmeIrqRdav(link)
int link;
{
if (bbDebug > 30)
logMsg("bitbus rx IRQ on link %d\n", link);
semGive(pXvmeLink[link]->rxInt); /* deliver the groceries */
return(0);
}
/******************************************************************************
*
* This interrupt handler is invoked when the BitBus controller has completed
* the transfer of a RECEIVED message.
*
******************************************************************************/
static int
xvmeIrqRcmd(link)
int link;
{
if (bbDebug > 30)
logMsg("bitbus rcmd IRQ on link %d\n", link);
semGive(pXvmeLink[link]->rxInt); /* deliver the groceries */
return(0);
}
/******************************************************************************
*
* Given a link number, make sure it is valid.
*
******************************************************************************/
static int
checkLink(link)
int link;
{
if ((link<0) || (link>BB_NUM_LINKS))
return(ERROR); /* link number out of range */
if (pXvmeLink[link] == NULL)
return(ERROR); /* link number has no card installed */
return(OK);
}
/******************************************************************************
*
* Watchdogs are running when ever the busy list has any elements in it.
* The idea here is that the watchdog handler scans thru the busy list,
* looking for old requests that have not been replied to in too long
* a time. If there are any old ones around, they are removed from the
* list and marked as un-replied to.
*
******************************************************************************/
static int
xvmeTmoHandler(link)
int link;
{
if (bbDebug > 25)
logMsg("xvmeTmoHandler(%d): Watch dog interrupt\n", link);
semGive(pXvmeLink[link]->watchDogSem);
return(0);
}
/******************************************************************************
*
* This function is started as a task during driver init time. It's purpose
* is to read messages that are received from the bitbus link. After a message
* is received, the soliciting message's completion routines are started by
* the use of semaphores and/or a callbackRequest().
*
******************************************************************************/
static int
xvmeRxTask(link)
int link;
{
int rxState; /* current state of the receiver */
#define BBRX_HEAD 1
#define BBRX_DATA 2
#define BBRX_RCMD 3
#define BBRX_IGN 4
unsigned char rxHead[5]; /* room for header of current rx msg */
unsigned char *rxMsg; /* where to place next byte (after header) */
int rxTCount; /* byte counter for data in rxHead */
unsigned char ch;
struct dpvtBitBusHead *rxDpvtHead; /* for message currently receiving */
int lockKey; /* used for intLock calls */
rxMsg = (unsigned char *) NULL;
rxState = BBRX_HEAD;
rxTCount = 0;
rxDpvtHead = (struct dpvtBitBusHead *) NULL;
while (1)
{
/* Wait for RX interrupts, but only if no chars are ready */
if ((pXvmeLink[link]->bbRegs->fifo_stat & XVME_RFNE) == 0)
{
/* Enable interrupts and check again because xycom blew it */
lockKey = intLock();
pXvmeLink[link]->bbRegs->stat_ctl = XVME_ENABLE_INT | XVME_RX_INT;
intUnlock(lockKey);
while (((pXvmeLink[link]->bbRegs->fifo_stat & XVME_RFNE) == 0) && (pXvmeLink[link]->abortFlag == 0))
{
/* Re-enable ints here each time in case board got reset */
lockKey = intLock();
pXvmeLink[link]->bbRegs->stat_ctl = XVME_ENABLE_INT | XVME_RX_INT;
intUnlock(lockKey);
semTake(pXvmeLink[link]->rxInt, WAIT_FOREVER); /* wait for groceries */
}
/* Disable RX Interrupts (prevents unnecessary context switching) */
lockKey = intLock();
pXvmeLink[link]->bbRegs->stat_ctl = 0;
intUnlock(lockKey);
}
if (pXvmeLink[link]->abortFlag == 0)
{
/* check to see if we got a data byte or a command byte */
if ((pXvmeLink[link]->bbRegs->fifo_stat & XVME_RCMD) == XVME_RCMD)
rxState = BBRX_RCMD;
switch (rxState) {
case BBRX_HEAD: /* getting the head of a new message */
rxHead[rxTCount] = pXvmeLink[link]->bbRegs->data;
if (bbDebug>21)
printf("xvmeRxTask(%d): >%02.2X< (Header)\n", link, rxHead[rxTCount]);
if (++rxTCount == 5)
{ /* find the message this is a reply to */
rxTCount += 2; /* adjust for the link field space */
/* Lock the busy list */
semTake(pXvmeLink[link]->pbbLink->busyList.sem, WAIT_FOREVER);
rxDpvtHead = pXvmeLink[link]->pbbLink->busyList.head;
while (rxDpvtHead != NULL)
{
if (bbDebug>19)
printf("xvmeRxTask(%d): checking reply against 0x%08.8X\n", link, rxDpvtHead);
/* see if node's match */
if (rxDpvtHead->txMsg.node == rxHead[2])
{ /* see if the tasks match */
if (rxDpvtHead->txMsg.tasks == rxHead[3])
{ /* They match, finish putting response into the rxMsg buffer */
if (bbDebug>4)
printf("xvmeRxTask(%d): reply to 0x%08.8X\n", link, rxDpvtHead);
/* Delete the node from the list */
listDel(&(pXvmeLink[link]->pbbLink->busyList), rxDpvtHead);
/* If busy list is empty, stop the dog */
if (pXvmeLink[link]->pbbLink->busyList.head == NULL)
wdCancel(pXvmeLink[link]->watchDogId);
/* decrement the number of outstanding messages to the node */
(pXvmeLink[link]->pbbLink->deviceStatus[rxDpvtHead->txMsg.node])--;
/* Wake up Link Task in case was waiting on "this" node */
/* BUG -- this may require moving into the BB_RCMD state */
semGive(pXvmeLink[link]->pbbLink->linkEventSem);
semGive(pXvmeLink[link]->pbbLink->busyList.sem);
rxDpvtHead->rxMsg.length = rxHead[0];
rxDpvtHead->rxMsg.route = rxHead[1];
rxDpvtHead->rxMsg.node = rxHead[2];
rxDpvtHead->rxMsg.tasks = rxHead[3];
rxDpvtHead->rxMsg.cmd = rxHead[4];
rxMsg = rxDpvtHead->rxMsg.data;
rxDpvtHead->status = BB_OK; /* OK, unless BB_LENGTH */
rxState = BBRX_DATA; /* finish reading till RCMD */
break; /* get out of the while() */
}
}
rxDpvtHead = rxDpvtHead->next; /* Keep looking */
}
if (rxDpvtHead == NULL)
{
if (bbDebug)
{
printf("xvmeRxTask(%d): msg from node %d unsolicited!\nHeader:", link, rxHead[2]);
rxDpvtHead->rxMsg.length = 7; /* we just have the header now */
drvBitBusDumpMsg(&(rxDpvtHead->rxMsg));
}
semGive(pXvmeLink[link]->pbbLink->busyList.sem);
rxState = BBRX_IGN; /* nothing waiting... toss it */
}
}
break;
case BBRX_DATA: /* finish reading data portion of message */
ch = pXvmeLink[link]->bbRegs->data;
if (rxTCount >= rxDpvtHead->rxMaxLen)
{
rxState = BBRX_IGN; /* toss the rest of the data */
rxDpvtHead->status = BB_LENGTH; /* set driver status */
if (bbDebug>22)
printf("xvmeRxTask(%d): %02.2X (Ignored)\n", link, ch);
}
else
{
*rxMsg = ch;
if (bbDebug>22)
printf("xvmeRxTask(%d): %02.2X (Data)\n", link, ch);
rxMsg++;
rxTCount++;
}
break;
case BBRX_IGN:
ch = pXvmeLink[link]->bbRegs->data;
if (bbDebug>22)
printf("xvmeRxTask(%d): %02.2X (Ignored)\n", link, ch);
break;
case BBRX_RCMD:
if (rxDpvtHead == NULL)
{
ch = pXvmeLink[link]->bbRegs->cmnd;
printf("xvmeRxTask(%d): got unexpected XVME_RCMD\n", link);
}
else
{
rxDpvtHead->status = BB_OK;
rxDpvtHead->rxCmd = pXvmeLink[link]->bbRegs->cmnd;
if (bbDebug>24)
printf("xvmeRxTask(%d):RX command byte = %02.2X\n", link, rxDpvtHead->rxCmd);
if (rxDpvtHead->finishProc != NULL)
{
if (bbDebug>8)
printf("xvmeRxTask(%d): invoking the callbackRequest\n", link);
callbackRequest(rxDpvtHead); /* schedule completion processing */
}
else
{
/* If there is a semaphore for synchronous I/O, unlock it */
if (rxDpvtHead->psyncSem != NULL)
semGive(*(rxDpvtHead->psyncSem));
}
}
/* Reset the state of the RxTask to expect a new message */
rxMsg = (unsigned char *) NULL;
rxState = BBRX_HEAD;
rxTCount = 0;
rxDpvtHead = (struct dpvtBitBusHead *) NULL;
break;
}
}
else
{ /* Link abort state is active reset receiver link status now */
if (rxDpvtHead != NULL)
{ /* This xact is not on the busy list, put it back on */
semTake(pXvmeLink[link]->pbbLink->busyList.sem, WAIT_FOREVER);
(pXvmeLink[link]->pbbLink->deviceStatus[rxDpvtHead->txMsg.node])++;
listAddTail(&(pXvmeLink[link]->pbbLink->busyList), rxDpvtHead);
semGive(pXvmeLink[link]->pbbLink->busyList.sem);
}
rxMsg = (unsigned char *) NULL;
rxState = BBRX_HEAD;
rxTCount = 0;
rxDpvtHead = (struct dpvtBitBusHead *) NULL;
/* Tell the watch dog I am ready for the reset (reset in the dog task) */
pXvmeLink[link]->rxAbortAck = 1;
/* if (bbDebug) */
printf("xvmeRxTask(%d): resetting due to abort status\n", link);
/* wait for link state to become active again */
while (pXvmeLink[link]->abortFlag != 0)
taskDelay(RESET_POLL_TIME);
/* if bbDebug) */
printf("xvmeRxTask(%d): restarting after abort\n", link);
}
}
}
/******************************************************************************
*
* A user callable link resetter. This sets a flag and releases the dog
* task to reset the link.
*
******************************************************************************/
int
bbReset(link)
int link;
{
if (checkLink(link) != ERROR)
{
pXvmeLink[link]->pbbLink->nukeEm = 1;
semGive(pXvmeLink[link]->watchDogSem);
}
else
printf("Link %d not installed.\n", link);
return(0);
}
/******************************************************************************
*
******************************************************************************/
static int
xvmeWdTask(link)
int link;
{
struct bbLink *plink; /* a reference to the link structures covered */
struct dpvtBitBusHead *pnode;
struct dpvtBitBusHead *npnode;
unsigned long now;
SEM_ID syncSem;
#ifdef DO_RESET_AND_OFFLINE
struct dpvtBitBusHead resetNode;
unsigned char resetNodeData; /* 1-byte data field for RAC_OFFLINE */
#endif
/* init the SEM used when sending the reset message */
syncSem = semBCreate(SEM_EMPTY, SEM_Q_PRIORITY);
#ifdef DO_RESET_AND_OFFLINE
/*
* Hand-craft a RAC_OFFLINE message to use when a message times out.
* NOTE that having only one copy is OK provided that the dog waits for
* a response before sending it again!
*/
resetNode.finishProc = NULL; /* no callback routine used */
resetNode.psyncSem = &syncSem;/* do a semGive on this SEM when done sending */
resetNode.link = link; /* which bitbus link to send message out on */
resetNode.rxMaxLen = 7; /* Chop off the response... we don't care */
resetNode.ageLimit = sysClkRateGet()*100; /* make sure this never times out */
resetNode.txMsg.length = 8;
resetNode.txMsg.route = BB_STANDARD_TX_ROUTE;
resetNode.txMsg.node = 0xff;
resetNode.txMsg.tasks = 0x0;
resetNode.txMsg.cmd = RAC_OFFLINE;
resetNode.txMsg.data = &resetNodeData;
#endif
plink = pXvmeLink[link]->pbbLink;
plink->nukeEm = 0; /* Make sure the nuke status is clear */
while(1)
{
semTake(pXvmeLink[link]->watchDogSem, WAIT_FOREVER);
now = tickGet(); /* what time is it? */
if (plink->nukeEm != 0)
printf("Bitbus manual reset being issued on link %d\n", link);
if (bbDebug>4)
printf("xvmeWdTask(%d): (Watchdog) checking busy list\n", link);
pXvmeLink[link]->rxAbortAck = 0; /* In case we need to use them */
pXvmeLink[link]->txAbortAck = 0;
if (plink->nukeEm != 0)
{ /* set abort status and wait for the abort acks */
pXvmeLink[link]->abortFlag = 1;
/* wake up the Tx task so it can observe the abort status */
semGive(plink->linkEventSem);
/* wake up the Rx task so it can observe the abort ststus */
semGive(pXvmeLink[link]->rxInt);
/* sleep until abort ack from Tx & Rx tasks */
while ((pXvmeLink[link]->rxAbortAck == 0) && (pXvmeLink[link]->txAbortAck == 0))
taskDelay(RESET_POLL_TIME);
}
/*
* Run thru entire busy list to see if there are any transactions
* that have been waiting on a response for too long a period.
*/
semTake(plink->busyList.sem, WAIT_FOREVER);
pnode = plink->busyList.head;
while (pnode != NULL)
{
npnode = pnode->next; /* remember where we were in the list */
if ((plink->nukeEm != 0) || (pnode->retire <= now))
{
/* Get rid of the request and set error status etc... */
listDel(&(plink->busyList), pnode);
/*if (bbDebug)*/
{
printf("xvmeWdTask(%d): TIMEOUT on xact 0x%08.8X\n", link, pnode);
drvBitBusDumpMsg(&pnode->txMsg);
}
(plink->deviceStatus[pnode->txMsg.node])--; /* fix device status */
pnode->status = BB_TIMEOUT;
#ifdef DO_RESET_AND_OFFLINE
/* Do now in case we need it later */
resetNodeData = pnode->txMsg.node; /* mark the node number */
#endif
/* Make the callbackRequest if one was spec'd */
if(pnode->finishProc != NULL)
{
callbackRequest(pnode); /* schedule completion processing */
}
else
{
/* Release a completion lock if one was spec'd */
if (pnode->psyncSem != NULL)
semGive(*(pnode->psyncSem));
}
#ifdef DO_RESET_AND_OFFLINE
/* If we are not going to reboot the link... */
if (plink->nukeEm == 0)
{ /* Send out a RAC_NODE_OFFLINE to the controller */
semGive(plink->busyList.sem);
printf("issuing a node offline for link %d node %d\n", link, resetNodeData);
semTake(plink->queue[BB_Q_HIGH].sem, WAIT_FOREVER);
listAddHead(&(plink->queue[BB_Q_HIGH]), &resetNode);
semGive(plink->queue[BB_Q_HIGH].sem);
semGive(plink->linkEventSem); /* Tell TxTask to send the message */
if (semTake(syncSem, sysClkRateGet()/4) == ERROR)
{
printf("xvmeWdTask(%d): link dead, trying manual reboot\n", link);
plink->nukeEm = 1;
pXvmeLink[link]->abortFlag = 1; /* Start the abort sequence */
semGive(plink->linkEventSem); /* Let Tx task observe abort status */
semGive(pXvmeLink[link]->rxInt); /* Let Rx task observe abort ststus */
/* sleep until abort ack from Tx & Rx tasks */
while ((pXvmeLink[link]->rxAbortAck == 0) && (pXvmeLink[link]->txAbortAck == 0))
taskDelay(RESET_POLL_TIME);
}
/* Start over since released the busy list */
semTake(plink->busyList.sem, WAIT_FOREVER);
npnode = plink->busyList.head;
}
#else
semGive(plink->linkEventSem);
#endif
}
pnode = npnode;
}
if (plink->busyList.head != NULL)
{ /* Restart the dog timer */
if (bbDebug>5)
printf("xvmeWdTask(%d): restarting watch dog timer\n", link);
wdStart(pXvmeLink[link]->watchDogId, plink->busyList.head->retire - now, xvmeTmoHandler, link);
}
semGive(plink->busyList.sem);
/* Finish the link reboot if necessary */
if (plink->nukeEm != 0)
{
xvmeReset(pXvmeLink[link]->bbRegs, link);
/* clear the abort_flag */
pXvmeLink[link]->abortFlag = 0;
plink->nukeEm = 0;
}
}
}
/******************************************************************************
*
* This function is started as a task during driver init time. It's purpose
* is to keep the link busy. It awaits user-calls to qBbReq() with new work
* as well as wake-up calls from the watchdog timer.
*
* At the time this function is started as its own task, the linked list
* structures will have been created and initialized.
*
******************************************************************************/
static int
xvmeTxTask(link)
int link;
{
struct bbLink *plink; /* a reference to the link structures covered */
struct dpvtBitBusHead *pnode;
struct dpvtBitBusHead *npnode;
int prio;
int working;
int dogStart;
int stuck;
int txTCount;
int txCCount;
unsigned char *txMsg;
register int x;
unsigned long now;
SEM_ID resetNodeSem;
struct dpvtBitBusHead resetNode;
unsigned char resetNodeData; /* 1-byte data field for RAC_OFFLINE */
if (bbDebug)
printf("xvmeTxTask started for link %d\n", link);
/* hand-craft a RAC_OFFLINE message for use with RAC_RESET_SLAVE commands */
/* NOTE that having only one copy is OK provided that this message is */
/* sent immediately following the RAC_RESET_SLAVE message. */
resetNodeSem = semBCreate(SEM_Q_PRIORITY, SEM_FULL);
resetNode.finishProc = NULL;
resetNode.psyncSem = &resetNodeSem;
resetNode.link = link;
resetNode.rxMaxLen = 7; /* Chop it off, we don't care */
resetNode.ageLimit = 10;
resetNode.txMsg.length = 8;
resetNode.txMsg.route = BB_STANDARD_TX_ROUTE;
resetNode.txMsg.node = 0xff;
resetNode.txMsg.tasks = 0x0;
resetNode.txMsg.cmd = RAC_OFFLINE;
resetNode.txMsg.data = &resetNodeData;
plink = pXvmeLink[link]->pbbLink;
while(1)
{
if (pXvmeLink[link]->abortFlag != 0)
{
pXvmeLink[link]->txAbortAck = 1; /* let the dog know we are ready */
/* if (bbDebug) */
printf("xvmeTxTask(%d): resetting due to abort status\n", link);
while (pXvmeLink[link]->abortFlag != 0)
taskDelay(RESET_POLL_TIME); /* wait for link to reset */
/* if (bbDebug) */
printf("xvmeTxTask(%d): restarting after abort\n", link);
}
else
semTake(plink->linkEventSem, WAIT_FOREVER);
if (bbDebug>5)
printf("xvmeTxTask(%d): got an event\n", link);
working = 1;
while ((working != 0) && (pXvmeLink[link]->abortFlag == 0) && (plink->busyList.elements < BB_MAX_OUTSTANDING_MSGS))
{
working = 0;
prio = BB_NUM_PRIO-1;
while ((prio >= 0) && (pXvmeLink[link]->abortFlag == 0))
{
/* see if the queue has anything in it */
semTake(plink->queue[prio].sem, WAIT_FOREVER);
if ((pnode = plink->queue[prio].head) != NULL)
{
while (plink->deviceStatus[pnode->txMsg.node] == BB_BUSY)
{
if ((pnode = pnode->next) == NULL)
break;
}
}
if (pnode != NULL)
{ /* have an xact to start processing */
working = 1; /* indicate work being done */
/* delete the node from the inbound fifo queue */
listDel(&(plink->queue[prio]), pnode);
semGive(plink->queue[prio].sem);
if (bbDebug>3)
printf("xvmeTxTask(%d): got xact, pnode=0x%08.8X\n", link, pnode);
/* Send the message in polled mode */
txTCount = pnode->txMsg.length - 2;
txCCount = 0;
txMsg = &(pnode->txMsg.length);
while ((txCCount <= txTCount) && (pXvmeLink[link]->abortFlag == 0))
{
stuck = 1000;
while (((pXvmeLink[link]->bbRegs->fifo_stat & XVME_TFNF) != XVME_TFNF) && (pXvmeLink[link]->abortFlag == 0) && --stuck)
for(x=0;x<100;x++); /* wait for TX ready */
if (!stuck)
txStuck(link); /* will end up setting abortFlag */
else if (txCCount < txTCount) /* on last time, just wait, no data */
{
pXvmeLink[link]->bbRegs->data = *txMsg; /* send next byte */
if (bbDebug>30)
printf("xvmeTxTask(%d): outputting %02.2X\n", link, *txMsg);
/* On 5th byte, we are dun w/header, set start w/data buffer */
if (txCCount != 4)
txMsg++;
else
txMsg = pnode->txMsg.data;
}
txCCount++;
}
if (pXvmeLink[link]->abortFlag == 0)
{
/* All data bytes have been sent, put on busy list and release */
/* Don't add to busy list if was a RAC_RESET_SLAVE */
if (pnode->txMsg.cmd != RAC_RESET_SLAVE)
{
/* Lock the busy list */
semTake(plink->busyList.sem, WAIT_FOREVER);
/* set the retire time */
pnode->retire = tickGet();
if (pnode->ageLimit)
pnode->retire += pnode->ageLimit;
else
pnode->retire += 5 * sysClkRateGet();
if (plink->busyList.head == NULL)
dogStart = 1;
else
dogStart = 0;
/* Add pnode to the busy list */
listAddTail(&(plink->busyList), pnode);
/* Count the outstanding messages */
(plink->deviceStatus[pnode->txMsg.node])++;
semGive(plink->busyList.sem);
/* If just added something to an empty busy list, start the dog */
if (dogStart)
{
now = tickGet();
wdStart(pXvmeLink[link]->watchDogId, plink->busyList.head->retire - now, xvmeTmoHandler, link);
}
}
else
{ /* Finish the transaction here if was a RAC_RESET_SLAVE */
/* if (bbDebug) */
printf("xvmeTxTask(%d): RAC_RESET_SLAVE sent, resetting node %d\n", link, pnode->txMsg.node);
pnode->status = BB_OK;
if (pnode->finishProc != NULL)
{
if (bbDebug>4)
printf("xvmeTxTask(%d): invoking callbackRequest\n", link);
callbackRequest(pnode); /* schedule completion processing */
}
else
{
/* If there is a semaphore for synchronous I/O, unlock it */
if (pnode->psyncSem != NULL)
semGive(*(pnode->psyncSem));
}
/* Wait for last NODE_OFFLINE to finish (if still pending) */
semTake(resetNodeSem, WAIT_FOREVER);
/* have to reset the master so it won't wait on a response */
resetNodeData = pnode->txMsg.node; /* mark the node number */
semTake(plink->queue[BB_Q_HIGH].sem, WAIT_FOREVER);
listAddHead(&(plink->queue[BB_Q_HIGH]), &resetNode);
semGive(plink->queue[BB_Q_HIGH].sem);
/* -- BUG -- I don't really need this */
/* taskDelay(15); */ /* wait while bug is resetting */
}
/* Tell the 8044 to fire out the message now */
pXvmeLink[link]->bbRegs->cmnd = BB_SEND_CMD; /* forward it now */
}
else
{ /* Aborted transmission operation, re-queue the message */
semTake(plink->queue[BB_Q_HIGH].sem, WAIT_FOREVER);
listAddHead(&(plink->queue[BB_Q_HIGH]), pnode);
semGive(plink->queue[BB_Q_HIGH].sem);
printf("Message in progress when abort issued:\n");
drvBitBusDumpMsg(&pnode->txMsg);
}
/* BUG -- I don't really need this */
/* break;*/ /* stop checking the fifo queues */
}
else
{ /* we have no xacts that can be processed at this time */
semGive(plink->queue[prio].sem);
}
prio--; /* look at the next prio queue */
}
}
}
}
/******************************************************************************
*
* This gets called by the transmit task if it gets stuck waiting to send a
* byte to the transmit fifo.
*
******************************************************************************/
static int
txStuck(link)
int link;
{
/* if (bbDebug) */
printf("xvmeTxTask(%d): transmitter stuck, resetting link\n", link);
bbReset(link);
while (pXvmeLink[link]->abortFlag == 0)
taskDelay(1);
return(OK);
}
/******************************************************************************
*
* This function is called by user programs to queue an I/O transaction request
* for the BB driver. It is the only user-callable function provided in this
* driver.
*
******************************************************************************/
static long
qBBReq(pdpvt, prio)
struct dpvtBitBusHead *pdpvt;
int prio;
{
char message[100];
if ((prio < 0) || (prio >= BB_NUM_PRIO))
{
sprintf(message, "invalid priority requested in call to qbbreq(%08.8X, %d)\n", pdpvt, prio);
errMessage(S_BB_badPrio, message);
return(ERROR);
}
if (checkLink(pdpvt->link) == ERROR)
{
sprintf(message, "invalid link requested in call to qbbreq(%08.8X, %d)\n", pdpvt, prio);
errMessage(S_BB_rfu1, message);
return(ERROR);
}
if (bbDebug>5)
printf("qbbreq(0x%08.8X, %d): transaction queued\n", pdpvt, prio);
if (bbDebug>6)
drvBitBusDumpMsg(&(pdpvt->txMsg));
semTake(pXvmeLink[pdpvt->link]->pbbLink->queue[prio].sem, WAIT_FOREVER);
/* Add to the end of the queue of waiting transactions */
listAddTail(&(pXvmeLink[pdpvt->link]->pbbLink->queue[prio]), pdpvt);
semGive(pXvmeLink[pdpvt->link]->pbbLink->queue[prio].sem);
semGive(pXvmeLink[pdpvt->link]->pbbLink->linkEventSem);
return(OK);
}
/******************************************************************************
*
* This is used for debugging purposes.
*
******************************************************************************/
int
drvBitBusDumpMsg(pbbMsg)
struct bitBusMsg *pbbMsg;
{
char ascBuf[15]; /* for ascii xlation part of the dump */
int x;
int y;
int z;
printf("Link 0x%04.4X, length 0x%02.2X, route 0x%02.2X, node 0x%02.2X, tasks 0x%02.2X, cmd %02.2X\n", pbbMsg->link, pbbMsg->length, pbbMsg->route, pbbMsg->node, pbbMsg->tasks, pbbMsg->cmd);
x = BB_MSG_HEADER_SIZE;
y = pbbMsg->length;
z = 0;
while (x < y)
{
printf("%02.2X ", pbbMsg->data[z]);
ascBuf[z] = pbbMsg->data[z];
if (!((ascBuf[z] >= 0x20) && (ascBuf[z] <= 0x7e)))
ascBuf[z] = '.';
x++;
z++;
}
while (x < BB_MAX_MSG_LENGTH)
{
printf(" ");
x++;
}
ascBuf[z] = '\0';
printf(" *%s*\n", ascBuf);
return(OK);
}
Reference in New Issue View Git Blame Copy Permalink