/****************************************************************************
*
* NAME: bAppQApiInit
*
* DESCRIPTION:
* Initialised the Application Queue API, Application API and stack. Creates
* the queues used for passing information up to the application and fills
* the 'spare buffers' queues with the spare buffer entries. Also registers
* the callback handlers with the Application API layer so all upward
* information comes through this module.
*
* PARAMETERS: Name RW Usage
* prMlmeCallback R Optional callback when MLME received
* prMcpsCallback R Optional callback when MCPS received
* prHwCallback R Optional callback when HW int received
*
* RETURNS:
* TRUE if initialisation was successful
*
****************************************************************************/
PUBLIC uint32 u32AppQApiInit(PR_QIND_CALLBACK prMlmeCallback,
PR_QMCPS_CALLBACK prMcpsCallback,
PR_HWQINT_CALLBACK prHwCallback)
{
int i;
/* Initialise 'spare buffers' queues and fill with spare buffers */
vFifoInit(&sMlmeIndBufferQueue, apvMlmeIndBufferData, APP_MAX_MLME_IND);
for (i = 0; i < APP_MAX_MLME_IND; i++)
{
bFifoPush(&sMlmeIndBufferQueue, (void *)&asMlmeIndBuffer[i]);
}
vFifoInit(&sMcpsIndBufferQueue, apvMcpsIndBufferData, APP_MAX_MCPS_IND);
for (i = 0; i < APP_MAX_MCPS_IND; i++)
{
bFifoPush(&sMcpsIndBufferQueue, (void *)&asMcpsIndBuffer[i]);
}
vFifoInit(&sHwIndBufferQueue, apvHwIndBufferData, APP_MAX_HW_IND);
for (i = 0; i < APP_MAX_HW_IND; i++)
{
bFifoPush(&sHwIndBufferQueue, (void *)&asHwIndBuffer[i]);
}
/* Initialise 'used buffers' queues */
vFifoInit(&sMlmeIndQueue, apvMlmeIndData, APP_MAX_MLME_IND);
vFifoInit(&sMcpsIndQueue, apvMcpsIndData, APP_MAX_MCPS_IND);
vFifoInit(&sHwIndQueue, apvHwIndData, APP_MAX_HW_IND);
/* Store callbacks */
prAppMlmeCallback = prMlmeCallback;
prAppMcpsCallback = prMcpsCallback;
prAppHwCallback = prHwCallback;
/* Register peripheral callbacks */
vAHI_SysCtrlRegisterCallback(vAppQApiPostHwInt);
vAHI_APRegisterCallback(vAppQApiPostHwInt);
#ifndef GDB
vAHI_Uart0RegisterCallback(vAppQApiPostHwInt);
#endif
vAHI_Uart1RegisterCallback(vAppQApiPostHwInt);
vAHI_TickTimerInit(vAppQApiPostHwInt);
vAHI_SpiRegisterCallback(vAppQApiPostHwInt);
vAHI_SiRegisterCallback(vAppQApiPostHwInt);
vAHI_Timer0RegisterCallback(vAppQApiPostHwInt);
vAHI_Timer1RegisterCallback(vAppQApiPostHwInt);
/* Register this layer with AppApi layer */
return u32AppApiInit(psAppQApiGetMlmeBuffer, vAppQApiPostMlme, NULL,
psAppQApiGetMcpsBuffer, vAppQApiPostMcps, NULL);
}
PROCESS_THREAD(i2c_process, ev, data)
{
static size_t i;
#if (DEBUG==1)
static u32_t i2c_ticks;
#endif
PROCESS_BEGIN();
vAHI_SiRegisterCallback(i2c_irq);
vAHI_SiConfigure(true,true,I2C_400KHZ_FAST_MODE);
while ((transaction=list_pop(transactions)))
{
#if (DEBUG==1)
printf("i2c: to 0x%x start, %d written, %d read\n",
transaction->addr, transaction->wrlen, transaction->rdlen);
i2c_ticks = u32AHI_TickTimerRead();
#endif
if (transaction->wrlen) {
/* send slave address, start condition */
vAHI_SiWriteData8(transaction->addr);
vAHI_SiSetCmdReg(E_AHI_SI_START_BIT, E_AHI_SI_NO_STOP_BIT,
E_AHI_SI_NO_SLAVE_READ, E_AHI_SI_SLAVE_WRITE,
E_AHI_SI_SEND_ACK, E_AHI_SI_NO_IRQ_ACK);
PROCESS_YIELD_UNTIL(ev==PROCESS_EVENT_POLL);
if (i2c_status==FAIL) { /* we only test for ACK on the first byte! */
if (transaction->cb) transaction->cb(false);
#if (DEBUG==1)
printf("i2c: to 0x%x failed, %d written, %d read in %d ticks\n",
transaction->addr, transaction->wrlen, transaction->rdlen,
u32AHI_TickTimerRead() - i2c_ticks);
#endif
continue;
}
}
/* send wr data. If repeated_start and there is something to read, send no
* stop condition, else send a stop condition on the last byte. */
for (i=0; i<transaction->wrlen; i++) {
vAHI_SiWriteData8(transaction->buf[i]);
vAHI_SiSetCmdReg(E_AHI_SI_NO_START_BIT,
(transaction->wrlen!=0) ? E_AHI_SI_NO_STOP_BIT : transaction->rdlen,
E_AHI_SI_NO_SLAVE_READ, E_AHI_SI_SLAVE_WRITE,
E_AHI_SI_SEND_ACK, E_AHI_SI_NO_IRQ_ACK);
PROCESS_YIELD_UNTIL(ev==PROCESS_EVENT_POLL);
if (i2c_status==FAIL) { /* we only test for ACK on the first byte! */
if (transaction->cb) transaction->cb(false);
#if (DEBUG==1)
printf("i2c: to 0x%x failed, %d written, %d read in %d ticks\n",
transaction->addr, transaction->wrlen, transaction->rdlen,
(uint32_t) u32AHI_TickTimerRead() - i2c_ticks);
#endif
continue;
}
}
if (transaction->rdlen) {
/* send slave addr, start condition */
vAHI_SiWriteData8(transaction->addr|1);
vAHI_SiSetCmdReg(E_AHI_SI_START_BIT, E_AHI_SI_NO_STOP_BIT,
E_AHI_SI_NO_SLAVE_READ, E_AHI_SI_SLAVE_WRITE,
E_AHI_SI_SEND_ACK, E_AHI_SI_NO_IRQ_ACK);
PROCESS_YIELD_UNTIL(ev==PROCESS_EVENT_POLL);
}
/* read data, send stop condition on last byte, send nak on last byte when
* end_of_transmission is set.*/
for (i=0; i<transaction->rdlen; i++) {
vAHI_SiSetCmdReg(E_AHI_SI_NO_START_BIT, i==transaction->rdlen-1,
E_AHI_SI_SLAVE_READ, E_AHI_SI_NO_SLAVE_WRITE,
(i==transaction->rdlen-1) ? E_AHI_SI_SEND_NACK : E_AHI_SI_SEND_ACK,
E_AHI_SI_NO_IRQ_ACK);
PROCESS_YIELD_UNTIL(ev==PROCESS_EVENT_POLL);
transaction->buf[transaction->wrlen+i] = u8AHI_SiReadData8();
}
#if (DEBUG==1)
printf("i2c: to 0x%x completed, %d written, %d read in %d ticks (rd:",
transaction->addr, transaction->wrlen, transaction->rdlen,
(u32_t) u32AHI_TickTimerRead() - i2c_ticks);
for (i=0; i<transaction->rdlen+transaction->wrlen; i++)
printf("0x%x,", transaction->buf[i]);
printf(")\n");
#endif
if (transaction->cb) transaction->cb(i2c_status==SUCCESS);
}
vAHI_SiConfigure(false,false,0);
PROCESS_END();
}
static void Wire_Init(void) {
vAHI_SiRegisterCallback(SiInterruptHandler);
}
