/**
* @brief Ajouter un périphérique.
* @param i
* @return OK en cas de succès, ERROR sinon.
*/
int pe_deviceAdd(int i)
{
// Buffer pour le nom de périphérique.
char dev_name[NAME_SIZE];
if(driver_id == -1)
{
errnoSet(S_ioLib_NO_DRIVER);
return ERROR;
}
sprintf(dev_name, DEVICE_BASENAME, i);
if(iosDevAdd((DEV_HDR*)&(table_capt[i]),dev_name,driver_id) == ERROR)
{
errnoSet(ECANNOTADD);
return ERROR;
}
semTake(mut_table_capt, WAIT_FOREVER);
// Le capteur est fermé
table_capt[i].specific.state = closed;
// Il n'a pas encore de capteur associé, au niveau CAN.
// utiliser ioctl pour lui en founir une.
table_capt[i].specific.address = -1;
semGive(mut_table_capt);
return OK;
}
DSL_DRV_STATIC int DSL_DRV_DevNodeInit(DSL_DRV_DevHeader_t *pDrvHdr, char *name, DSL_uint32_t drvNum)
{
/* Add device to the device list */
if (iosDevAdd(&pDrvHdr->DevHdr, name, drvNum) == ERROR)
{
DSL_DEBUG(DSL_DBG_ERR,
(DSL_NULL, SYS_DBG_ERR""DSL_DRV_CRLF DSL_DRV_CRLF"unable to register "
"major for %s!!!", DRV_DSL_CPE_API_DEV_NAME));
return -1;
}
return 0;
}
STATUS ttyDevCreate
(
char * name, /* name to use for this device */
SIO_CHAN * pSioChan, /* pointer to core driver structure */
int rdBufSize, /* read buffer size, in bytes */
int wrtBufSize /* write buffer size, in bytes */
)
{
TYCO_DEV *pTyCoDev;
if (ttyDrvNum <= 0)
{
errnoSet (S_ioLib_NO_DRIVER);
return (ERROR);
}
if (pSioChan == (SIO_CHAN *) ERROR)
{
return (ERROR);
}
/* allocate memory for the device */
if ((pTyCoDev = (TYCO_DEV *) malloc (sizeof (TYCO_DEV))) == NULL)
return (ERROR);
/* initialize the ty descriptor */
if (tyDevInit (&pTyCoDev->tyDev, rdBufSize, wrtBufSize,
(FUNCPTR) ttyStartup) != OK)
{
free (pTyCoDev);
return (ERROR);
}
/* initialize the SIO_CHAN structure */
pTyCoDev->pSioChan = pSioChan;
sioCallbackInstall (pSioChan, SIO_CALLBACK_GET_TX_CHAR,
tyITx, (void *)pTyCoDev);
sioCallbackInstall (pSioChan, SIO_CALLBACK_PUT_RCV_CHAR,
tyIRd, (void *)pTyCoDev);
/* start the device cranking */
sioIoctl (pSioChan, SIO_MODE_SET, (void *)SIO_MODE_INT);
/* add the device to the I/O system */
return (iosDevAdd (&pTyCoDev->tyDev.devHdr, name, ttyDrvNum));
}
//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);
}
int i8042MseDevCreate(
char *name
)
{
int result;
int drvNum;
I8042_MSE_DEVICE *pDev;
drvNum = iosDrvInstall(
(FUNCPTR) i8042MseOpen,
(FUNCPTR) i8042MseDelete,
(FUNCPTR) i8042MseOpen,
(FUNCPTR) i8042MseClose,
(FUNCPTR) i8042MseRead,
(FUNCPTR) i8042MseWrite,
(FUNCPTR) i8042MseIoctl
);
if (drvNum == ERROR)
{
result = ERROR;
}
else
{
pDev = (I8042_MSE_DEVICE *) malloc(sizeof(I8042_MSE_DEVICE));
if (pDev == NULL)
{
result = ERROR;
}
else
{
if (tyDevInit(
&pDev->tyDev,
512,
512,
(FUNCPTR) i8042MseTxStart) != OK)
{
free(pDev);
result = ERROR;
}
else
{
/* Initialize device registers */
pDev->dataReg = I8042_KBD_DATA_REG;
pDev->statReg = I8042_KBD_STAT_REG;
pDev->cmdReg = I8042_KBD_CMD_REG;
/* Connect interrupt handler */
intConnectDefault(I8042_MSE_INT, (VOIDFUNCPTR) i8042Intr, pDev);
i8042MseHwInit(pDev);
/* Enable interrupt level */
sysIntEnablePIC(I8042_MSE_INT_LVL);
if (iosDevAdd(&pDev->tyDev.devHeader, name, drvNum) != OK)
{
free(pDev);
result = ERROR;
}
else
{
result = drvNum;
}
}
}
}
return result;
}
int devAdd(char * devName,int devNb)
{
myDev * dev;
myDev * i;
int ret = 0;
if (devNb == 0)
{//No sensor have this number, do not add device.
//This test is not very useful, since we can't initiate the device,
//we can't make sure a corresponding physical device exist anyway.
errnoSet(INVALID_ARG);
return -1;
}
dev = malloc(sizeof(myDev));
//myDev has to be dynamically allocated since it will be needed 'till devDelete
//where it'll then be deallocated.
if (dev==NULL)
{//we can't allocate memory for drv struct => we can't add driver
errnoSet(MEM_OVERFLOW);
return -1;
}
dev->next = NULL; //it's the last one in linked list
dev->devNumber = devNb;
dev->firstFifo = NULL; //no one has openned this device just yet
dev->openned = 0;
dev->semMData = semMCreate(SEM_Q_FIFO);
//semMDATA will prevent multiple acces to device members used by apps during
//open, read and close
if(dev->semMData==0)
{
free(dev);
errnoSet(SEM_ERR);
return -1;
}
if(semTake(semMAdmin,WAIT_FOREVER)==-1)
{
semDelete(dev->semMData);//semaphore
free(dev);
errnoSet(SEM_ERR);
return -1;
}
if (numPilote == -1)
{
semDelete(dev->semMData);//semaphore
free(dev);
errnoSet(NOT_INSTALLED);
return -1;
}
//Let's queue this device to the driver device-linked-list.
if (first==NULL)
{//This is very first device added to this driver
first = dev;
}else{
//Let's look for the end of linked list and make sure there is no other
//device with the same number already installed
for (i=first;i->next!=NULL;i=i->next)
{
if (i->devNumber == devNb)
{//There is already a device with this number, cancel this one's installation
semGive(semMAdmin);
semDelete(dev->semMData);//semaphore
free(dev);
errnoSet(DEV_ALREADY_CREATED);
return -1;
}
}
if (i->devNumber == devNb)
{//The last device already has this number, same thing than above
semGive(semMAdmin);
semDelete(dev->semMData);//semaphore
free(dev);
errnoSet(DEV_ALREADY_CREATED);
return -1;
}
i->next = dev; //queue this device to linked list
//We might simplify this one by using a while, or a flag to indicate last element.
}
ret = iosDevAdd((DEV_HDR*)dev,devName,numPilote);
if (ret == -1)
{
//We couldn't register device, let's free allocated ressources:
if (first == dev) //linked list
{
first=NULL;
}else{
i->next=NULL;
}
semGive(semMAdmin);
semDelete(dev->semMData);//semaphore
free(dev); //memory
errnoSet(DEV_ADD_ERR);
return -1;
}
semGive(semMAdmin);
return 0;
}
