uart_socket_t* uart_open(uart_set_str *puartpara)
{
PinName uart_tx = PA_7;//PA_4; //PA_7
PinName uart_rx = PA_6;//PA_0; //PA_6
uart_socket_t *u;
u = (uart_socket_t *)RtlZmalloc(sizeof(uart_socket_t));
if(!u){
uart_printf("%s(): Alloc memory for uart_socket failed!\n", __func__);
return NULL;
}
/*initial uart */
serial_init(&u->sobj, uart_tx,uart_rx);
serial_baud(&u->sobj,puartpara->BaudRate);
serial_format(&u->sobj, puartpara->number, (SerialParity)puartpara->parity, puartpara->StopBits);
/*uart irq handle*/
serial_irq_handler(&u->sobj, uart_irq, (int)u);
serial_irq_set(&u->sobj, RxIrq, 1);
serial_irq_set(&u->sobj, TxIrq, 1);
#if UART_SOCKET_USE_DMA_TX
serial_send_comp_handler(&u->sobj, (void*)uart_send_stream_done, (uint32_t)u);
#endif
/*alloc a socket*/
u->fd = lwip_allocsocketsd();
if(u->fd == -1){
uart_printf("Failed to alloc uart socket!\n");
goto Exit2;
}
/*init uart related semaphore*/
RtlInitSema(&u->action_sema, 0);
RtlInitSema(&u->tx_sema, 1);
RtlInitSema(&u->dma_tx_sema, 1);
/*create uart_thread to handle send&recv data*/
{
#define UART_ACTION_STACKSIZE 512
#define UART_ACTION_PRIORITY 1
if(xTaskCreate(uart_action_handler, ((const char*)"uart_action"), UART_ACTION_STACKSIZE, u, UART_ACTION_PRIORITY, NULL) != pdPASS){
uart_printf("%s xTaskCreate(uart_action) failed", __FUNCTION__);
goto Exit1;
}
}
return u;
Exit1:
/* Free uart related semaphore */
RtlFreeSema(&u->action_sema);
RtlFreeSema(&u->tx_sema);
RtlFreeSema(&u->dma_tx_sema);
Exit2:
RtlMfree((u8*)u, sizeof(uart_socket_t));
return NULL;
}
/******************************************************************************
* Function: RtlMailboxCreate
* Desc: To create a mailbox with a given mailbox ID and size
* Para:
* MboxID: A number to identify this created mailbox. A message block can
* be send to a mailbox by a given MboxID. The MboxID must be unique
* in the whole system. If this MboxID is conflict with a created
* mailbox, the mailbox creation will fail and return NULL.
* MboxSize: The size of this mailbox to be created. It means maximum number
* of message blocks can be stored in this mailbox.
* pWakeSema: The semaphore to wake up the receiving task to receive the new
* message. If the receiving task doesn't need a semaphore to wakeup
* it, then just let this pointer is NULL.
* Return: The created mailbox pointer. If it failed, return NULL.
******************************************************************************/
PRTL_MAILBOX RtlMailboxCreate(
IN u8 MboxID,
IN u32 MboxSize,
IN _Sema *pWakeSema
)
{
PRTL_MAILBOX pMBox=NULL;
// if the Mailbox root entry initialed ? if not, initial it
if (!MBox_Entry.isInitialed) {
RtlMutexInit(&MBox_Entry.Mutex); // Init the Mutex for the mailbox add/delete procedure protection
RtlInitListhead(&MBox_Entry.mbox_list); // Init the link list head to chain all created mailbox
MBox_Entry.isInitialed = 1;
MSG_MBOX_INFO("MBox Entry Initial...\n");
}
// check if this mailbox ID is ocupied ?
pMBox = RtlMBoxIdToHdl(MboxID);
if (NULL != pMBox) {
MSG_MBOX_ERR("RtlMailboxCreate: The Mailbox ID %d is used by someone!!\n", MboxID);
return NULL;
}
pMBox = (RTL_MAILBOX *)RtlZmalloc(sizeof(RTL_MAILBOX));
if (NULL==pMBox) {
MSG_MBOX_ERR("RtlMailboxCreate: MAlloc Failed\n");
return NULL;
}
RtlInitListhead(&pMBox->mbox_list); // Init the link list to be chained into the created mailbox list
pMBox->mbox_id = MboxID;
pMBox->pWakeSema = pWakeSema;
#ifdef PLATFORM_FREERTOS
pMBox->mbox_hdl = xQueueCreate(MboxSize, sizeof(MSG_BLK));
if (NULL == pMBox->mbox_hdl) {
MSG_MBOX_ERR("RtlMailboxCreate: xQueueCreate Failed\n");
RtlMfree((void *)pMBox, sizeof(RTL_MAILBOX));
return NULL;
}
#endif
#ifdef PLATFORM_ECOS
// TODO: Create mailbox
#endif
// Add this mailbox to the link list of created mailbox
RtlDownMutex(&MBox_Entry.Mutex);
RtlListInsertTail(&pMBox->mbox_list, &MBox_Entry.mbox_list);
RtlUpMutex(&MBox_Entry.Mutex);
MSG_MBOX_INFO("A Mailbox Created: Size=%d\n", MboxSize);
return pMBox;
}
//---------------------------------------------------------------------------------------------------
//Function Name:
// RtkI2CGetMngtAdpt
//
// Description:
// According to the input index, all the memory space are allocated and all the
// related pointers are assigned. The management adapter pointer will be
// returned.
//
// Arguments:
// [in] u8 I2CIdx -
// I2C module index
//
// Return:
// PSAL_I2C_MNGT_ADPT
//
// Note:
// NA
//
// See Also:
// NA
//
// Author:
// By Jason Deng, 2014-04-02.
//
//---------------------------------------------------------------------------------------------------
PSAL_DAC_MNGT_ADPT
RtkDACGetMngtAdpt(
IN u8 DACIdx
){
PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL;
PSAL_DAC_USERCB_ADPT pSalDACUserCBAdpt = NULL;
/* If the kernel is available, Memory-allocation is used. */
#ifdef CONFIG_KERNEL
pSalDACMngtAdpt = (PSAL_DAC_MNGT_ADPT)RtlZmalloc(sizeof(SAL_DAC_MNGT_ADPT));
pSalDACMngtAdpt->pSalHndPriv = (PSAL_DAC_HND_PRIV)RtlZmalloc(sizeof(SAL_DAC_HND_PRIV));
pSalDACMngtAdpt->pHalInitDat = (PHAL_DAC_INIT_DAT)RtlZmalloc(sizeof(HAL_DAC_INIT_DAT));
pSalDACMngtAdpt->pHalOp = (PHAL_DAC_OP)RtlZmalloc(sizeof(HAL_DAC_OP));
pSalDACMngtAdpt->pIrqHnd = (PIRQ_HANDLE)RtlZmalloc(sizeof(IRQ_HANDLE));
pSalDACMngtAdpt->pUserCB = (PSAL_DAC_USER_CB)RtlZmalloc(sizeof(SAL_DAC_USER_CB));
pSalDACMngtAdpt->pHalGdmaAdp = (PHAL_GDMA_ADAPTER)RtlZmalloc(sizeof(HAL_GDMA_ADAPTER));
pSalDACMngtAdpt->pHalGdmaOp = (PHAL_GDMA_OP)RtlZmalloc(sizeof(HAL_GDMA_OP));
pSalDACMngtAdpt->pIrqGdmaHnd = (PIRQ_HANDLE)RtlZmalloc(sizeof(IRQ_HANDLE));
pSalDACUserCBAdpt = (PSAL_DAC_USERCB_ADPT)RtlZmalloc((sizeof(SAL_DAC_USERCB_ADPT)*SAL_DAC_USER_CB_NUM));
#else
switch (DACIdx){
case DAC0_SEL:
{
pSalDACMngtAdpt = &SalDAC0MngtAdpt;
pSalDACMngtAdpt->pSalHndPriv = &SalDAC0HndPriv;
pSalDACMngtAdpt->pHalInitDat = &HalDAC0InitData;
pSalDACMngtAdpt->pHalOp = &HalDACOpSAL;
pSalDACMngtAdpt->pIrqHnd = &DAC0IrqHandleDat;
pSalDACMngtAdpt->pHalGdmaAdp = &HalDAC0GdmaAdpt;
pSalDACMngtAdpt->pHalGdmaOp = &HalDAC0GdmaOp;
pSalDACMngtAdpt->pIrqGdmaHnd = &DAC0IrqHandleDat;
pSalDACMngtAdpt->pUserCB = &SalDAC0UserCB;
pSalDACUserCBAdpt = &SalDAC0UserCBAdpt;
break;
}
case DAC1_SEL:
{
pSalDACMngtAdpt = &SalDAC1MngtAdpt;
pSalDACMngtAdpt->pSalHndPriv = &SalDAC1HndPriv;
pSalDACMngtAdpt->pHalInitDat = &HalDAC1InitData;
pSalDACMngtAdpt->pHalOp = &HalDACOpSAL;
pSalDACMngtAdpt->pIrqHnd = &DAC1IrqHandleDat;
pSalDACMngtAdpt->pHalGdmaAdp = &HalDAC1GdmaAdpt;
pSalDACMngtAdpt->pHalGdmaOp = &HalDAC1GdmaOp;
pSalDACMngtAdpt->pIrqGdmaHnd = &DAC1IrqHandleDat;
pSalDACMngtAdpt->pUserCB = &SalDAC1UserCB;
pSalDACUserCBAdpt = &SalDAC1UserCBAdpt;
break;
}
default:
break;
}
#endif
/*To assign user callback pointers*/
pSalDACMngtAdpt->pUserCB->pTXCB = pSalDACUserCBAdpt;
pSalDACMngtAdpt->pUserCB->pTXCCB = (pSalDACUserCBAdpt+1);
pSalDACMngtAdpt->pUserCB->pRXCB = (pSalDACUserCBAdpt+2);
pSalDACMngtAdpt->pUserCB->pRXCCB = (pSalDACUserCBAdpt+3);
pSalDACMngtAdpt->pUserCB->pRDREQCB = (pSalDACUserCBAdpt+4);
pSalDACMngtAdpt->pUserCB->pERRCB = (pSalDACUserCBAdpt+5);
pSalDACMngtAdpt->pUserCB->pDMATXCB = (pSalDACUserCBAdpt+6);
pSalDACMngtAdpt->pUserCB->pDMATXCCB = (pSalDACUserCBAdpt+7);
pSalDACMngtAdpt->pUserCB->pDMARXCB = (pSalDACUserCBAdpt+8);
pSalDACMngtAdpt->pUserCB->pDMARXCCB = (pSalDACUserCBAdpt+9);
/*To assign the rest pointers*/
pSalDACMngtAdpt->pSalHndPriv->ppSalDACHnd = (void**)&(pSalDACMngtAdpt->pSalHndPriv);
return pSalDACMngtAdpt;
}
