static bool ConfigureDac(DAC_DRIVER_INFO * drv_info)
{
bool res = true;
// Enable AND Reset the DAC peripheral
RCCPeripheralEnable(drv_info->info.peripheral_indx);
RCCPeripheralReset(drv_info->info.peripheral_indx);
PIO_Cfg_List(drv_info->dac_pins);
drv_enable_isr(&drv_info->info);
#if USE_DAC_DMA_DRIVER
if(!ConfigureDacDma(&drv_info->drv_data->dac_dma_hnd[0], &drv_info->dac_dma_mode[0]))
res = false;
if(!ConfigureDacDma(&drv_info->drv_data->dac_dma_hnd[1], &drv_info->dac_dma_mode[1]))
res = false;
#endif
return res;
}
void EXTI_DCR(EXTI_DRIVER_INFO* drv_info, unsigned int reason, HANDLE hnd)
{
EXTI_DRIVER_DATA * drv_data = drv_info->drv_data ;
const PIN_DESC* pin;
unsigned int lines;
switch( reason )
{
case DCR_ISR:
{
lines = (unsigned int)hnd; //lines with edge
// loop waiting handles
for(hnd = drv_data->waiting; hnd; hnd = hnd->next)
{
// loop pin description list in the handle
for(pin = (PIN_DESC*)hnd->mode.as_voidptr; *pin; pin++)
{
if(lines & *pin)
{
if(hnd->mode0 == PIOHND_WAITING)
{
hnd->mode0 = PIOHND_IDLE;
read_handle(hnd);
svc_HND_SET_STATUS(hnd, RES_SIG_OK);
}
else
hnd->mode0 = PIOHND_INTPENDING;
break; //done with this handle
}
}
}
}
break;
case DCR_OPEN:
{
//Enable AFIO/SYSCFG...
RCCPeripheralEnable(drv_info->info.peripheral_indx);
pin = (PIN_DESC *)hnd->mode.as_voidptr;
hnd->list_add(drv_data->waiting);
hnd->mode0 = PIOHND_IDLE;
while(*pin)
{
unsigned int pin_pattern, pos;
PIO_Cfg(*pin);
if(PD_MODE_Get(*pin) == PD_MODE_INPUT)
{
if(PD_INT_Get(*pin))
{
pin_pattern = PD_PINS_Get(*pin);
while(pin_pattern)
{
pos = 31 - __CLZ(pin_pattern);
lines = 1 << pos;
pin_pattern ^= lines;
pos = stm_get_drv_indx(pos);
// Handles can be open with any EXTI driver, so check
// here if the actual driver is installed
int adr = (int)DRV_TABLE[pos];
adr &= ~3;
const EXTI_DRIVER_INFO* info;
info = (const EXTI_DRIVER_INFO*)adr;
if(info->info.isr == (DRV_ISR)EXTI_ISR)
{
drv_enable_isr(&info->info);
/* Clear Rising Falling edge configuration */
info->hw_base->EXTI_RTSR &= ~lines;
info->hw_base->EXTI_FTSR &= ~lines;
exti_set_line_source(31 - __CLZ(lines), PD_PORT_Get(*pin));
/* Select the trigger for the selected external interrupts */
if(*pin & PD_INT_FE) // falling edge
info->hw_base->EXTI_FTSR |= lines;
if(*pin & PD_INT_RE) // rising edge
info->hw_base->EXTI_RTSR |= lines;
/* Enable line interrupt */
info->hw_base->EXTI_IMR |= lines;
}
}
}
}
pin++;
}
hnd->res = RES_OK;
}
break;
case DCR_CLOSE:
{
PIO_Cfg_List((PIN_DESC*)hnd->mode.as_voidptr);
hnd->list_remove(drv_data->waiting);
}
break;
case DCR_CANCEL:
if (hnd->res & FLG_BUSY)
{
read_handle(hnd);
svc_HND_SET_STATUS(hnd, RES_SIG_CANCEL);
}
break;
case DCR_RESET:
NVIC_DisableIRQ(drv_info->info.drv_index);
RCCPeripheralReset(drv_info->info.peripheral_indx);
RCCPeripheralDisable(drv_info->info.peripheral_indx); // turn off
break;
default:
break;
}
}
void dcr_SerialDriver(UART_DRIVER_INFO* drv_info, unsigned int reason, HANDLE hnd)
{
UART_Type * Uart = drv_info->hw_base;
UART_DRIVER_DATA *drv_data = drv_info->drv_data;
switch(reason)
{
case DCR_ISR:
TX_CTS(drv_data, Uart, (unsigned int)hnd);
return;
case DCR_RESET:
SysCtlPeripheralReset(drv_info->info.peripheral_indx);
SysCtlPeripheralDisable(drv_info->info.peripheral_indx); // ??? turn off
return;
case DCR_OPEN:
{
UART_DRIVER_MODE *uart_mode = (UART_DRIVER_MODE *)(hnd->mode.as_voidptr);
if(uart_mode)
{
//unsigned long mode, baudrate;
if(drv_data->cnt)
{
if( uart_mode->mode != drv_data->mode.mode ||
uart_mode->baudrate != drv_data->mode.baudrate ||
uart_mode->hw_flow != drv_data->mode.hw_flow )
{
return;
}
}
else
{
// Enable AND Reset the UART peripheral
SysCtlPeripheralReset(drv_info->info.peripheral_indx);
if(drv_data->mode.hw_flow)
{
PIO_Cfg_List((PIN_DESC *)&drv_info->uart_pins[UART_LIST_ALL_PINS]);
ConfigureUart(drv_info, drv_data, uart_mode);
#ifdef HW_VER_10
if(drv_info->info.drv_index != UART1_IRQn)
TX_CTS(drv_data, Uart, PIO_Read(drv_info->uart_pins[CTS_PIN]));
#endif
}
else
{
PIO_Cfg_List((PIN_DESC *)&drv_info->uart_pins[UART_LIST_RX_TX_PINS]);
ConfigureUart(drv_info, drv_data, uart_mode);
}
START_RX_BUF(Uart, drv_info, drv_data);
}
drv_data->cnt++;
hnd->res = RES_OK;
}
return;
}
case DCR_CLOSE:
if(drv_data->cnt)
drv_data->cnt--;
case DCR_CANCEL:
{
if( !(hnd->res & FLG_BUSY))
return;
if (hnd->cmd & FLAG_READ)
{
if(hnd == drv_data->hnd_rcv)
{
STOP_RX(Uart);
if(hnd->len > drv_data->rx_remaining || hnd->mode0 )
{
hnd->len = drv_data->rx_remaining;
hnd->res = RES_SIG_OK;
}
else
hnd->res = RES_SIG_IDLE;
drv_data->hnd_rcv = hnd->next;
svc_HND_SET_STATUS(hnd, hnd->res);
if( (hnd=drv_data->hnd_rcv) )
START_RX_HND(Uart, drv_info, hnd);
else
START_RX_BUF(Uart, drv_info, drv_data);
}
else
{
// try cnacel
hnd->svc_list_cancel(drv_data->hnd_rcv);
}
}
else
{
if(hnd == drv_data->hnd_snd)
{
STOP_TX(Uart);
drv_data->hnd_snd = hnd->next;
svc_HND_SET_STATUS(hnd, RES_SIG_IDLE);
if( (hnd=drv_data->hnd_snd) )
START_TX_HND(Uart, hnd);
}
else
{
hnd->svc_list_cancel(drv_data->hnd_snd);
}
}
if(!drv_data->cnt)
{
NVIC->NVIC_DisableIRQ(drv_info->info.drv_index);
Uart->UARTDisable();
STOP_RX(Uart);
STOP_TX(Uart);
SysCtlPeripheralDisable(drv_info->info.peripheral_indx);
SYSCTL->SysCtlPeripheralDeepSleepDisable(drv_info->info.peripheral_indx);
SYSCTL->SysCtlPeripheralSleepDisable(drv_info->info.peripheral_indx);
if(drv_data->mode.hw_flow)
PIO_Free_List((PIN_DESC *)&drv_info->uart_pins[UART_LIST_ALL_PINS]);
else
PIO_Free_List((PIN_DESC *)&drv_info->uart_pins[UART_LIST_RX_TX_PINS]);
}
return;
}
case DCR_CLOCK:
return;
}
}
