/* Disconnect ISR from its PCI interrupt vector. */
static
int vxworksDevPCIDisconnectInterrupt(
const epicsPCIDevice *dev,
void (*pFunction)(void *),
void *parameter
)
{
int status;
struct osdPCIDevice *osd=pcidev2osd(dev);
/* Get the IRQ number from the PCI device structure
* and use it to get the interrupt number from the translation table
* (if there is one). If there is no translation table, or the table
* is too small, jut use the irq as the interrupt number.
*/
unsigned char irq = osd->dev.irq;
if (inumTableSize && (irq < inumTableSize))
irq = inumTable[(int)irq];
/* prefer the newer API when it is available */
if(CallPciIntDisconnect2) {
status=CallPciIntDisconnect2((void*)INUM_TO_IVEC(VXPCIINTOFFSET + irq),
pFunction, (int)parameter);
} else {
status=CallPciIntDisconnect((void*)INUM_TO_IVEC(VXPCIINTOFFSET + irq),
pFunction);
}
if(status)
return S_dev_intDisconnect;
return 0;
}
INLINE void vmeio_int_attach(const DWORD base_adr, DWORD base_vect, int intnum,
void (*isr) (void))
/**************************************************************\
Purpose: Book an ISR for a bitwise set of interrupt input (0xff).
The interrupt vector is then the VECTOR_BASE+intnum
Input:
DWORD * base_addr : base address of the VMEIO
DWORD base_vect : base vector of the module
DWORD intnum : interrupt number (0:7)
DWORD isr_routine : interrupt routine pointer
Output:
none
Function value:
none
\**************************************************************/
{
vmeio_int_clear(base_adr); /* clear any pending front panel interrupts */
vmeio_int_disable(base_adr, intnum); /* bitwise input */
#ifdef OS_VXWORKS
if (intnum < 8)
intConnect(INUM_TO_IVEC(base_vect + intnum), (VOIDFUNCPTR) isr, intnum);
#else
printf("vector : 0x%x\n", base_vect + intnum);
#endif
vmeio_int_enable(base_adr, intnum); /* bitwise input */
}
STATUS pcmciaInit (void)
{
PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
PCMCIA_CHIP *pChip = &pCtrl->chip;
PCMCIA_CARD *pCard;
PCMCIA_ADAPTER *pAdapter = NULL;
int sock;
int ix;
pcmciaMsgQId = msgQCreate (PCMCIA_MAX_MSGS, sizeof(PCMCIA_MSG), MSG_Q_FIFO);
if (pcmciaMsgQId == NULL)
return (ERROR);
pcmciadId = taskSpawn ("tPcmciad", pcmciadPriority,
pcmciadOptions, pcmciadStackSize,
(FUNCPTR) pcmciad, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
if (pcmciadId == ERROR)
return (ERROR);
for (ix = 0; ix < pcmciaAdapterNumEnt; ix++)
{
pAdapter = &pcmciaAdapter[ix];
if ((* pAdapter->initRtn) (pAdapter->ioBase,
pAdapter->intVec,
pAdapter->intLevel,
pAdapter->showRtn) == OK)
break;
}
if (ix >= pcmciaAdapterNumEnt)
return (ERROR);
semMInit (&cisMuteSem, SEM_Q_PRIORITY | SEM_DELETE_SAFE |
SEM_INVERSION_SAFE);
(void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC(pAdapter->intVec),
(VOIDFUNCPTR)pcmciaCscIntr, 0);
if (pCtrl->socks != 0) /* if explicitely defined, use it */
pChip->socks = pCtrl->socks;
for (sock = 0; sock < pChip->socks; sock++)
{
pCard = &pCtrl->card[sock];
if ((pCard->cardStatus = (* pChip->status) (sock)) & PC_IS_CARD)
(void) cisGet (sock);
(void) (* pChip->cscPoll) (sock);
(void) (* pChip->cscOn) (sock, pChip->intLevel);
}
sysIntEnablePIC (pAdapter->intLevel);
return (OK);
}
/*
* isrFetch()
*/
static myISR *isrFetch(unsigned vectorNumber)
{
myISR *psub;
myISR *pCISR;
void *pParam;
int s;
/*
* fetch the handler or C stub attached at this vector
*/
psub = (myISR *) intVecGet((FUNCPTR *)INUM_TO_IVEC(vectorNumber));
if ( psub ) {
/*
* from libvxWorks/veclist.c
*
* checks to see if it is a C ISR
* and if so finds the function pointer and
* the parameter passed
*/
s = cISRTest(psub, &pCISR, &pParam);
if(!s){
psub = pCISR;
}
}
return psub;
}
/*
*
* vxDevDisconnectInterruptVME()
*
* wrapper to minimize driver dependency on vxWorks
*
* The parameter pFunction should be set to the C function pointer that
* was connected. It is used as a key to prevent a driver from removing
* an interrupt handler that was installed by another driver
*
*/
static long vxDevDisconnectInterruptVME (
unsigned vectorNumber,
void (*pFunction)()
)
{
void (*psub)();
int status;
# if CPU_FAMILY == PPC
return S_dev_vecInstlFail;
# endif
/*
* If pFunction not connected to this vector
* then they are probably disconnecting from the wrong vector
*/
psub = isrFetch(vectorNumber);
if(psub != pFunction){
return S_dev_vectorNotInUse;
}
status = intConnect(
(void *)INUM_TO_IVEC(vectorNumber),
unsolicitedHandlerEPICS,
(int) vectorNumber);
if(status<0){
return S_dev_vecInstlFail;
}
return 0;
}
/* Connect ISR to its PCI interrupt vector. */
static
int vxworksDevPCIConnectInterrupt(
const epicsPCIDevice *dev,
void (*pFunction)(void *),
void *parameter,
unsigned int opt
)
{
struct osdPCIDevice *osd=pcidev2osd(dev);
int status;
/* Get the IRQ number from the PCI device structure
* and use it to get the interrupt number from the translation table
* (if there is one). If there is no translation table, or the table
* is too small, just use the irq as the interrupt number.
*/
unsigned char irq = osd->dev.irq;
if (inumTableSize && (irq < inumTableSize))
irq = inumTable[(int)irq];
/* Attempt to connect the interrupt vector. Abort on failure.
*/
status = CallPciIntConnect ((VOIDFUNCPTR *)INUM_TO_IVEC(VXPCIINTOFFSET+irq),
pFunction, (int)parameter);
if(status)
return S_dev_vecInstlFail;
return 0;
}
/************ INLINE function for General command ***********/
INLINE void sis3803_int_detach(const DWORD base_adr, DWORD base_vect, int level)
/**************************************************************\
Purpose: Unbook an ISR for a bitwise set of interrupt input (0xff).
The interrupt vector is then the VECTOR_BASE+intnum
Input:
DWORD * base_addr : base address of the sis3803
DWORD base_vect : base vector of the module
int level : IRQ level (1..7)
Output:
none
Function value:
none
\**************************************************************/
{
/* disable all IRQ sources */
/* Should be done but not in detach
sis3803_int_source(base_adr , DISABLE_IRQ_DI_BS0
| DISABLE_IRQ_DI_BS1
| DISABLE_IRQ_DI_BS2);
*/
#ifdef OS_VXWORKS
/* Suppose to save the default isr before attach but would
* required isr table in case of multiple IRQ
* for now restore with myStub()
*/
intConnect(INUM_TO_IVEC(base_vect), (VOIDFUNCPTR) myStub_sis3803, 0);
sysIntDisable(level); /* interrupt level */
#else
printf("vector : 0x%x\n", base_vect + intnum);
#endif
}
void sysSerialHwInit2 (void)
{
int i;
for (i = 0; i < AMBA_UART_CHANNELS_NUM; i++)
{
(void)intConnect (INUM_TO_IVEC(dev_paras[i].vector),
balongv7r2_uart_irq_handler, (int) &amba_chan[i] );
(void)intEnable ((int)dev_paras[i].int_level);
}
}
void main (void)
{
unsigned char tempOut;
/* Connect interrupt service routine to vector and all stuff */
intConnect (INUM_TO_IVEC(aioIntNum), my_ISR, aioIntNum);
sysIntEnablePIC (aioIRQNum);
/* Enable interrupts on the aio:
* All interrupts and interrupt from counter 1 too */
tempOut = 0x24;
sysOutByte (aioBase + intEnAddress, tempOut);
/* Start counter 1 as timer with 50 ms period
* It has a clock input of 1 MHz = 1 µs
* Therefore the load value is 0xC350 = 50000 */
tempOut = 0x74;
sysOutByte (aioBase + cntCntrlReg, tempOut);
tempOut = 0x50;
sysOutByte (aioBase + cnt1Address, tempOut);
tempOut = 0xC3;
sysOutByte (aioBase + cnt1Address, tempOut);
/* Add your code here: create tasks, semaphores, ... */
//printf("Hello World!");
/*The second task shall do the following:
* - It starts counter a as an auto-reload timer with a period of 50 ms.
* - The interrupt generated by this counter activates the task.
* This shall be done with a semaphore.
* - The task reads the analog inputs of both the potentiometer and the temperature.
* - If the values have changed compared to the previous ones, these shall be written into global
* variables (AIn).
* - A hysteresis of e.g. 10 – 20 bit is necessary due to the noise of the analog inputs.
*
* */
initHardware(0);
int readTask;
readTask = taskSpawn("tRead", 101, 0, 0x1000, (FUNCPTR) tRead,0,0,0,0,0,0,0,0,0,0);
timIntSem = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
/* The third task shall do the following:
* - It writes the values of the global variables (AIn) onto the display.
* - This shall happen approx. each 100 ms
*/
int writeTask;
writeTask = taskSpawn("tWrite",102,0,0x1000, (FUNCPTR) tWrite,0,0,0,0,0,0,0,0,0,0);
/* Suspend own task */
taskSuspend (0); //suspended sich selber
} /* main */
/******************************************************************************
** Function: CFE_PSP_Init1HzTone()
**
** Purpose:
** Initializes the 1Hz Tone interrupt
**
** Arguments:
**
** Return:
**
*/
void CFE_PSP_Init1HzTone()
{
uint32 val;
uint32 tone1HzPin = (1 << 7); /* GPIO0_7 */
val = am335xInLong (AM335X_GPIO0_BASE + AM335X_GPIO_IRQSTATUS_SET1);
am335xOutLong (AM335X_GPIO0_BASE + AM335X_GPIO_IRQSTATUS_SET1, val | tone1HzPin);
val = am335xInLong (AM335X_GPIO0_BASE + AM335X_GPIO_RISINGDETECT);
am335xOutLong (AM335X_GPIO0_BASE + AM335X_GPIO_RISINGDETECT, val | tone1HzPin);
intConnect((VOIDFUNCPTR *)INUM_TO_IVEC (AM335X_GPIOINT0B), CFE_PSP_ToneISR, 0);
intEnable(AM335X_GPIOINT0B);
}
STATUS sysScsiInit (VOID)
{
#ifdef INCLUDE_AIC_7880
AIC7880_INFO *aicResource;
aicResource = &aic7880InfoTable;
/* Create the SCSI controller */
if ((pSysScsiCtrl = (SCSI_CTRL *) aic7880CtrlCreate
(aicResource->pciBus, aicResource->pciDevice,
SCSI_DEF_CTRL_BUS_ID)) == NULL)
{
logMsg ("Could not create SCSI controller\n",
0, 0, 0, 0, 0, 0);
return (ERROR);
}
/* connect the SCSI controller's interrupt service routine */
if ((pciIntConnect (INUM_TO_IVEC (INT_NUM_GET (aicResource->irq)),
aic7880Intr, (int) pSysScsiCtrl)) == ERROR)
{
logMsg ("Failed to connect interrupt\n",
0, 0, 0, 0, 0, 0);
return (ERROR);
}
sysIntEnablePIC((int) aicResource->irq) ;
#endif /* INCLUDE_AIC_7880 */
#ifdef INCLUDE_TAPEFS
tapeFsInit (); /* initialize tape file system */
#endif /* INCLUDE_TAPEFS */
#ifdef INCLUDE_CDROMFS
cdromFsInit (); /* include CD-ROM file system */
#endif /* INCLUDE_CDROMFS */
return (OK);
}
/*
* devConnectInterruptVME
*
* wrapper to minimize driver dependency on vxWorks
*/
static long vxDevConnectInterruptVME (
unsigned vectorNumber,
void (*pFunction)(),
void *parameter)
{
int status;
if (vxDevInterruptInUseVME(vectorNumber)) {
return S_dev_vectorInUse;
}
status = intConnect(
(void *)INUM_TO_IVEC(vectorNumber),
pFunction,
(int) parameter);
if (status<0) {
return S_dev_vecInstlFail;
}
return 0;
}
PUBLIC IX_STATUS
ixOsalIrqUnbind (UINT32 irqLevel)
{
/*
* disable interrupts for this vector
*/
if (intDisable (IVEC_TO_INUM (irqLevel)) != OK)
{
return IX_FAIL;
}
/*
* register a dummy ISR
*/
if (intConnect (INUM_TO_IVEC(irqLevel),
(IxOsalVoidFnVoidPtr) ixOsalDummyIsr, 0) != OK)
{
return IX_FAIL;
}
return IX_SUCCESS;
}
void sysSerialHwInit2 (void)
{
int i;
AT91DBGUDevInit2( &at91DBGUChan );
for (i = 0; i < N_SIO_CHANNELS; i++)
{
/*
* Connect and enable the interrupt.
* We would like to check the return value from this and log a message
* if it failed. However, logLib has not been initialised yet, so we
* cannot log a message, so there's little point in checking it.
* URAT still in quiet state
*/
(void) intConnect ( INUM_TO_IVEC(devParas[i].vector),
AT91UartInt, (UINT32) &at91UartChan[i] );
intEnable (devParas[i].intLevel);
AT91UartDevInit2( &at91UartChan[i] );
}
}
int readInputs (void)
{
unsigned char tempOut;
/* Connect interrupt service routine to vector and all stuff */
intConnect (INUM_TO_IVEC(aioIntNum), my_ISR, aioIntNum);
sysIntEnablePIC (aioIRQNum);
/* Enable interrupts on the aio:
* All interrupts and interrupt from counter 1 too */
tempOut = 0x24;
sysOutByte (aioBase + intEnAddress, tempOut);
/* Start counter 1 as timer with 50 ms period
* It has a clock input of 1 MHz = 1 µs
* Therefore the load value is 0xC350 = 50000 */
tempOut = 0x74;
sysOutByte (aioBase + cntCntrlReg, tempOut);
tempOut = 0x50;
sysOutByte (aioBase + cnt1Address, tempOut);
tempOut = 0xC3;
sysOutByte (aioBase + cnt1Address, tempOut);
int poti;
int temp;
int hyst = 15;
while(1){
semTake (analogInputs, WAIT_FOREVER);
poti = readAnalog (2, 0);
temp = readAnalog (5, 2);
//printf ("Werte %d %d \n", poti, temp);
if ((poti > globalPoti+hyst) | (poti < globalPoti-hyst))
{
globalPoti = poti;
}
if ((temp > globalTemp+hyst) | (temp < globalTemp-hyst))
{
globalTemp = temp;
}
}
}
PUBLIC IX_STATUS
ixOsalIrqBind (UINT32 irqLevel, IxOsalVoidFnVoidPtr routine, void *parameter)
{
#if((CPU==SIMSPARCSOLARIS) || (CPU==SIMLINUX))
/*
* No Irq support in simulation env
*/
return IX_FAIL;
#else
if (intConnect
(INUM_TO_IVEC(irqLevel),
(IxOsalVoidFnVoidPtr) routine,
(int) parameter) != OK)
{
return IX_FAIL;
}
intEnable (irqLevel);
return IX_SUCCESS;
#endif
}
INLINE void vmeio_int_detach(const DWORD base_adr, DWORD base_vect, int intnum)
/**************************************************************\
Purpose: Unbook an ISR for a bitwise set of interrupt input (0xff).
The interrupt vector is then the VECTOR_BASE+intnum
Input:
DWORD * base_addr : base address of the VMEIO
DWORD base_vect : base vector of the module
DWORD intnum : interrupt number (0:7)
Output:
none
Function value:
none
\**************************************************************/
{
vmeio_int_clear(base_adr); /* clear any pending front panel interrupts */
vmeio_int_disable(base_adr, intnum); /* mask off external interrupt x */
#ifdef OS_VXWORKS
if (intnum < 8)
intConnect(INUM_TO_IVEC(base_vect + intnum), (VOIDFUNCPTR) myStub, intnum);
#else
printf("vector : 0x%x\n", base_vect + intnum);
#endif
}
/************ INLINE function for General command ***********/
INLINE void sis3803_int_attach(const DWORD base_adr, DWORD base_vect, int level,
void (*isr) (void))
/**************************************************************\
Purpose: Book an ISR for a bitwise set of interrupt input (0xff).
The interrupt vector is then the VECTOR_BASE+intnum
Input:
DWORD * base_addr : base address of the sis3803
DWORD base_vect : base vector of the module
int level : IRQ level (1..7)
DWORD isr_routine : interrupt routine pointer
Output:
none
Function value:
none
\**************************************************************/
{
volatile DWORD *spec_adr;
/* disable all IRQ sources */
/* Should be done but not in attach
sis3803_int_source(base_adr
, DISABLE_IRQ_DI_BS0
| DISABLE_IRQ_DI_BS1
| DISABLE_IRQ_DI_BS2);
*/
#ifdef OS_VXWORKS
if ((level < 8) && (level > 0) && (base_vect < 0x100)) {
spec_adr = (DWORD *) (A32D24 + base_adr + IRQ_REG);
*spec_adr = (level << 8) | VME_IRQ_ENABLE | base_vect;
sysIntEnable(level); /* interrupt level */
}
intConnect(INUM_TO_IVEC(base_vect), (VOIDFUNCPTR) isr, 0);
#else
printf("Not implemented for this OS\n");
#endif
}
void sysPciPirqShow (void)
{
# if defined (INCLUDE_ICH2) || defined (INCLUDE_ICH3)
{
INT32 ix;
/* show the PIRQ[A-H] - IRQ[0-15] routing table */
for (ix = 0; ix < N_IOAPIC_PIRQS; ix++)
{
printf ("PIRQ%c: offset=0x%04x, PIRQ=0x%02x, IRQ=0x%02x\n",
'A' + ix,
sysPciPirqTbl[ix].offset,
sysPciPirqTbl[ix].pirq,
sysPciPirqTbl[ix].irq);
}
}
# endif /* defined (INCLUDE_ICH2) || defined (INCLUDE_ICH3) */
# ifdef INCLUDE_UNKNOWN_MOTHER
{
INT32 ix;
/* show the network device table */
for (ix = 0; ix < sysPciNnets; ix++)
{
printf ("bus=0x%04x dev=0x%04x venId=0x%04x "
"devId=0x%04x intPin=0x%02x intLine=0x%02x\n",
sysPciNetTbl[ix].pciBus,
sysPciNetTbl[ix].pciDev,
sysPciNetTbl[ix].vendorId,
sysPciNetTbl[ix].deviceId,
sysPciNetTbl[ix].intPin,
sysPciNetTbl[ix].intLine);
}
}
# elif defined (INCLUDE_D815EEA) || defined (INCLUDE_D850GB)
{
INT32 pciBusSlot = MOTHER_PCI_BUSNO_SLOT;
INT32 pciFuncSlot = MOTHER_PCI_FUNCNO_SLOT;
FUNCPTR defIsr; /* ISR of the default IRQ */
FUNCPTR curIsr; /* ISR of the current IRQ */
INT32 idtType; /* IDT type */
INT32 selector; /* CS selector */
INT32 vendorId; /* PCI vendor Id */
UINT8 intPin; /* PCI INT[A-D] from PCI Int Pin Reg */
UINT8 defIrq; /* default IRQ */
UINT8 curIrq; /* current IRQ */
UINT8 pirq; /* PIRQ[n] */
INT32 ix;
for (ix = 0; ix < N_PCI_SLOTS; ix++)
{
/* skip if the slot is empty */
pciConfigInLong (pciBusSlot, sysPciSlotTbl[ix], pciFuncSlot,
PCI_CFG_VENDOR_ID, &vendorId);
if ((vendorId & 0x0000ffff) == 0x0000ffff)
{
printf ("slot %d: empty \n", ix);
continue;
}
/* get the PCI INT[A-D] and IRQ[0-15] of the device */
pciConfigInByte (pciBusSlot, sysPciSlotTbl[ix], pciFuncSlot,
PCI_CFG_DEV_INT_PIN, &intPin);
pciConfigInByte (pciBusSlot, sysPciSlotTbl[ix], pciFuncSlot,
PCI_CFG_DEV_INT_LINE, &curIrq);
/* get the PIRQ[A-H] of the device */
pirq = sysPciIntTbl[ix][intPin - 1];
/* if sysPciPirqTbl[] table is not initialized, use the curIrq */
defIrq = sysPciPirqTbl[pirq - IOAPIC_PIRQA_INT_LVL].irq;
/* get the default Isr and current Isr */
intVecGet2 ((FUNCPTR *)INUM_TO_IVEC (INT_NUM_GET (defIrq)),
&defIsr, &idtType, &selector);
intVecGet2 ((FUNCPTR *)INUM_TO_IVEC (INT_NUM_GET (curIrq)),
&curIsr, &idtType, &selector);
/* show the default IRQ and the current IRQ setting */
printf ("slot %d: def-IRQ(ISR) = 0x%04x(0x%08x) "
"cur-IRQ(ISR) = 0x%04x(0x%08x)\n",
ix, defIrq, (int)defIsr, curIrq, (int)curIsr);
}
}
# endif /* INCLUDE_UNKNOWN_MOTHER */
}
/* This is needed by the GNAT run time to handle Vxworks interrupts. */
void *
__gnat_inum_to_ivec (int num)
{
return INUM_TO_IVEC (num);
}
int probe1()
{
unsigned int pciBusNo, pciDevNo, pciFuncNo;
unsigned char byte;
/* int i,j;*/
UINT32 s_pBA0, s_pBA1;
/* To ensure that taskDelay(1) is 1ms delay */
sysClkRateSet(1000);
if (pciConfigLibInit (PCI_MECHANISM_1, 0xCF8, 0xCFC, 0) != OK) {
printf("PCI lib config error\n");
return 1;
}
/****************************
* Find SoundCard
* Set BaseAddr0, BaseAddr1
****************************/
if(!(pciFindDevice(PCI_VENDOR_ID_CIRRUS,PCI_DEVICE_ID_CRYSTAL_CS4281,
0, &pciBusNo, &pciDevNo, &pciFuncNo)==OK)) {
printf("\n CS4281 sound card NOT FOUND!!! \n");
return 1;
}
printf("\n FOUND CS4281 sound card, configuring BA0,BA1... \n");
pciConfigOutLong( pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_BASE_ADDRESS_0, CS4281_pBA0);
/*
pciConfigOutLong( pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_BASE_ADDRESS_1, CS4281_pBA1);
*/
pciConfigInLong( pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_BASE_ADDRESS_0, &s_pBA0);
pciConfigInLong( pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_BASE_ADDRESS_1, &s_pBA1 );
printf ("\npBusNo pDeviceNo pFuncNo pBA0 pBA1\n\n");
printf ("%.8x %.8x %.8x %.8x %.8x \n",
pciBusNo, pciDevNo, pciFuncNo, s_pBA0,s_pBA1);
/********************************
* Config PCI Device Capability
* DMA Master
* MEM mapped
********************************/
/* Set the INTA vector */
pciConfigInByte(pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_DEV_INT_LINE, &cs4281_irq);
printf("\nFound CS4281 configured for IRQ %d\n", cs4281_irq);
pciConfigInByte(pciBusNo, pciDevNo, pciFuncNo,
PCI_CFG_DEV_INT_PIN, &byte);
printf("\tINT_PIN=%.8x\n", byte);
/* Enable the device's capabilities as specified
* Bus Master Enable/ Mem Space Enable */
pciConfigOutWord(pciBusNo, pciDevNo, pciFuncNo, PCI_CFG_COMMAND,
(unsigned short)0x0006);
/***************************
* BringUp Hardware
***************************/
/*Include Init Function Here*/
cs4281_hw_init();
/****************************
* Allocate ADC_BUFFER
* Allocate DAC_BUFFER
*
* Hook cs4281_interrupt
*
* Program CoDec
****************************/
if((DAC_BUFFER=valloc(DAC_BUFFER_SIZE))==NULL) {
printf("\n DAC_BUFFER valloc failed!\n");
return 1;
}
memset( DAC_BUFFER, 0, DAC_BUFFER_SIZE );
printf("\ndac=%x",DAC_BUFFER);
/*for( i=0 ; i < DAC_BUFFER_SIZE ; i++ )
((char *)DAC_BUFFER)[i]=0x7f;*/
writel((UINT32)DAC_BUFFER+8,CS4281_pBA0 + BA0_DBA0);
writel(DAC_BUFFER_SIZE-16, CS4281_pBA0 + BA0_DBC0);
printf("\nbao=%x",readl(CS4281_pBA0 + BA0_DBA0));
printf("\nbco=%x",readl(CS4281_pBA0 + BA0_DBC0));
printf("\ncco=%x",readl(CS4281_pBA0 + BA0_DCC0));
if((ADC_BUFFER=valloc(ADC_BUFFER_SIZE))==NULL) {
printf("\n ADC_BUFFER valloc failed!\n");
return 1;
}
printf("\nadc=%x",ADC_BUFFER);
/*for( i=0 ; i < ADC_BUFFER_SIZE ; i++ )
((char *)ADC_BUFFER)[i]=0x7f;*/
writel((UINT32)ADC_BUFFER+8,CS4281_pBA0 + BA0_DBA1);
writel(ADC_BUFFER_SIZE-16, CS4281_pBA0 + BA0_DBC1);
/* connect interrupt */
printf("\n Hook cs4281_interrupt to vector %d\n",
(INUM_TO_IVEC (cs4281_irq+INT_NUM_IRQ0)));
pciIntConnect((INUM_TO_IVEC (cs4281_irq+INT_NUM_IRQ0)),
(VOIDFUNCPTR)cs4281_interrupt, 0);
sysIntEnablePIC(cs4281_irq);
SEM_DMA_Playback = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
SEM_MY_Playback = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
SEM_DMA_Record = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
SEM_Sample = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
CNT_DMA_Playback = CNT_DMA_Record = 0;
/* program coDec */
printf("\n Program CoDec (sample rate, DMA...)\n");
prog_codec();
/*********************************************
* start dac/adc, interrupt is comming...
*********************************************/
start_dac();
return 0;
}
int rapiInit(pwr_tUInt8* pRapiDPMBase, int irq)
{
#if 0
RAPI_HEADER* pRapiHeader;
RAPI_DEV* pRapiDevtab;
RAPI_IMREG* pRapiImReg;
#endif
if(cRapi >= NUM_RAPI - 1) /* No free rapi module block's */
{
#ifdef DEBUG
printf("rapiInit: no free rapi module block\n");
#endif
return(RAPI_ERR);
}
pRapiHeader = (RAPI_HEADER *) pRapiDPMBase; /* Setup RAPI header pointer */
#ifdef DEBUG
printf("rapiInit: pRapiDPMBase = 0x%x\n", (unsigned int) pRapiDPMBase);
printf("Id 0 : %d\n", pRapiHeader->rapiId[0]); /* Printout of RAPI ID */
printf("Id 0 : %d\n", pRapiHeader->rapiId[1]);
printf("Id 0 : %d\n", pRapiHeader->rapiId[2]);
printf("Id 0 : %d\n", pRapiHeader->rapiId[3]);
#endif
if((pRapiHeader->rapiId[0] != 'R') || /* Test for valid RAPI ID structure */
(pRapiHeader->rapiId[1] != 'A') ||
(pRapiHeader->rapiId[2] != 'P') ||
(pRapiHeader->rapiId[3] != 'I') )
{
#ifdef DEBUG
printf("rapiInit: ""RAPI"" string missing in header\n");
#endif
return(RAPI_ERR);
}
if(pRapiHeader->crc != rapiCrcCalc(pRapiDPMBase)) /* Check CRC */
{
#ifdef DEBUG
printf("rapiInit: crc error\n");
#endif
return(RAPI_ERR);
}
#ifdef DEBUG
printf("RAPI rev %d\n", pRapiHeader->rapiRev);
printf("Module ID %d, Nr %d, Rev %d\n", pRapiHeader->modId,
pRapiHeader->modNr, pRapiHeader->modRev);
#endif
pRapiDevtab = (RAPI_DEV *)&pRapiDPMBase[wordSwapChk(pRapiHeader->devtab)]; /* Get pointer to device table */
pRapiImReg = (RAPI_IMREG *)&pRapiDPMBase[wordSwapChk(pRapiHeader->vectab)]; /* Get pointer to interrupt vector table */
#ifdef DEBUG
printf("rapiInit: pRapiDevtab = 0x%x\n", (unsigned int) pRapiDevtab);
printf("rapiInit: pRapiImReg = 0x%x\n", (unsigned int) pRapiImReg);
#endif
rapiModule[cRapi].pRapiDPM = pRapiDPMBase; /* Store pointer to Dual Ported Memory */
rapiModule[cRapi].pRapiHeader = pRapiHeader; /* Store pointer to RAPI_HEADER */
rapiModule[cRapi].pRapiDevtab = pRapiDevtab; /* Store pointer to RAPI_DEV */
rapiModule[cRapi].pRapiImReg = pRapiImReg; /* Store pointer to RAPI_IMREG */
#if 0 /* Obsolete in Lynx/SSPA case !?!? */
pRapiImReg->irqVec1 = irq;
pRapiImReg->irqVec2 = irq;
intConnect(INUM_TO_IVEC(irq), rapiInt, (unsigned int) cRapi);
#endif /* Obsolete in Lynx/SSPA case !?!? */
rapiModeSet(cRapi, RAPI_RESET); /* Initialize to RESET mode */
cRapi++; /* Increment initialized module count */
return(cRapi - 1); /* Return index for the module we just initialized */
}
int pci_int_connect(int intLine,
pci_isr_t isr,
void *isr_data)
{
#if !defined(NEGEV)
extern int sysVectorIRQ0;
#endif
#if defined(NSX) || defined(GTO) || defined(METROCORE)
int i;
#endif
debugk(DK_PCI,
"pci_int_connect: intLine=%d, isr=%p, isr_data=%p\n",
intLine, (void *)isr, (void *)isr_data);
#if defined(NSX) || defined(METROCORE)
/* all int lines */
for (i = 0; i < 4; i++) {
/* printk("pciIntConnect int line = %d\n", intLine + i); */
if (pciIntConnect ((VOIDFUNCPTR *)
INUM_TO_IVEC(sysVectorIRQ0 + intLine + i),
(VOIDFUNCPTR) isr,
PTR_TO_INT(isr_data)) != OK) {
return -1;
}
}
return 0;
#endif
#if defined(GTO)
for (i = 0; i < 4; i++) {
/* PCI interrupts are connected at external interrupt
* 0, 1, 2, and 3.
*/
if (pciIntConnect ((VOIDFUNCPTR *)
INUM_TO_IVEC(sysVectorIRQ0 + i),
(VOIDFUNCPTR) isr,
PTR_TO_INT(isr_data)) != OK) {
return -1;
}
if (intEnable(sysVectorIRQ0 + i) == ERROR) {
return -1;
}
}
return 0;
#endif
#if !defined (NEGEV)
if (pciIntConnect ((VOIDFUNCPTR *)
INUM_TO_IVEC(sysVectorIRQ0 + intLine),
(VOIDFUNCPTR) isr,
PTR_TO_INT(isr_data)) != OK) {
return -1;
}
#endif
#if (CPU_FAMILY != PPC) && !defined(IDTRP334) && \
!defined(MBZ) && !defined(IDT438) && !defined(NSX) && !defined(ROBO_4704) \
&& !defined(ROBO_4702) && !defined(RAPTOR) && !defined(METROCORE) \
&& !defined(KEYSTONE)
if (sysIntEnablePIC(intLine) == ERROR) {
return -1;
}
#endif
#if (CPU_FAMILY == PPC)
if (intEnable(intLine) != OK) {
return -1;
}
#endif /* (CPU_FAMILY == PPC) */
return 0;
}
//STATUS dac3550DevCreate (char *devName, int port, int irq)
DEV_HDR* dac3550DevCreate (char *devName, int port, int irq)
{
SND_DEV *pDev;
if (DrvNum < 1)
{
errno = S_ioLib_NO_DRIVER;
return ERROR;
}
if(dac3550Dev)
return &(dac3550Dev->devHdr);
pDev = (SND_DEV *)malloc (sizeof(SND_DEV));
if (!pDev) return 0;
bzero ((char *)pDev, sizeof(SND_DEV));
if(port==0) port = (int)AT91C_BASE_SSC1;
if(irq==0) irq = AT91C_ID_SSC1;
pDev->port = port;
pDev->irq = irq;
/* pDev->dma8 = dma8;
pDev->dma16 = dma16;
*/
pDev->devSem = semBCreate (SEM_Q_FIFO, SEM_FULL);
pDev->intSem = semCCreate (SEM_Q_FIFO, 0);
pDev->bufSem = semCCreate (SEM_Q_FIFO, MAX_DMA_MSGS);
pDev->dmaQ = msgQCreate (MAX_DMA_MSGS, sizeof (DMA_MSG), MSG_Q_FIFO);
pDev->dmaIndex = 0;
if (createDmaBuffer () < 0)
{
free (pDev);
return 0;
}
if (dsp_init (pDev) < 0)
{
free (pDev);
return 0;
}
if (iosDevAdd (&pDev->devHdr, devName, DrvNum) == ERROR)
{
free ((char *)pDev);
return 0;
}
/*
pDev->tid = taskSpawn ("tSndTask", TASK_PRIORITY, TASK_OPTIONS,
TASK_STACK_SIZE, dspHelperTask, (int)pDev,
0, 0, 0, 0, 0, 0, 0, 0, 0);
if (pDev->tid == ERROR)
{
free (pDev);
return ERROR;
}
*/
intConnect (INUM_TO_IVEC ( (irq)), dspInterrupt, (int)pDev);
dac3550Dev = pDev;
return &(pDev->devHdr);
}
/*
*
* veclist()
*
*/
int veclist(int all)
{
int vec;
int value;
SYM_TYPE type;
char name[MAX_SYS_SYM_LEN];
char function_type[10];
FUNCPTR proutine;
FUNCPTR pCISR;
int cRoutine;
void *pparam;
int status;
unsigned i;
for(vec=0; vec<NVEC; vec++){
proutine = intVecGet((FUNCPTR *)INUM_TO_IVEC(vec));
status = cISRTest(proutine, &pCISR, &pparam);
if(status == OK){
cRoutine = TRUE;
proutine = pCISR;
strcpy(function_type, "C");
}
else{
cRoutine = FALSE;
strcpy(function_type, "MACRO");
pCISR = NULL;
}
status = symFindByValue(
sysSymTbl,
(int)proutine,
name,
&value,
&type);
if(status<0 || value != (int)proutine){
sprintf(name, "0x%X", (unsigned int) proutine);
}
else if(!all){
int match = FALSE;
for(i=0; i<NELEMENTS(ignore_list); i++){
if(!strcmp(ignore_list[i],name)){
match = TRUE;
break;
}
}
if(match){
continue;
}
}
printf( "vec 0x%02X %5s ISR %s",
vec,
function_type,
name);
if(cRoutine){
printf("(0x%X)", (unsigned int) pparam);
}
printf("\n");
}
return OK;
}
