/**
* All modules MUST provide a FULL cleanup function. This must cleanup all allocations etc
* e.g. we will have to populate this when we add circular buffers!
*
**/
static BT_ERROR canCleanup(BT_HANDLE hCan) {
canDisable(hCan);
// Disable peripheral clock.
disableCanPeripheralClock(hCan);
// Free any buffers if used.
if(hCan->eMode != BT_CAN_MODE_BUFFERED) {
BT_CloseHandle(hCan->hRxFifo);
BT_CloseHandle(hCan->hTxFifo);
}
BT_u32 i;
BT_BOOL bClose = BT_TRUE;
for (i = 0; i < 2; i++) {
const BT_RESOURCE *pResource = BT_GetIntegratedResource(hCan->pDevice, BT_RESOURCE_ENUM, 0);
if ((pResource->ulStart != i) && (g_CAN_HANDLES[i] != NULL)) {
bClose = BT_FALSE;
}
}
const BT_RESOURCE *pResource = BT_GetIntegratedResource(hCan->pDevice, BT_RESOURCE_IRQ, 0);
if (bClose) BT_DisableInterrupt(pResource->ulStart);
pResource = BT_GetIntegratedResource(hCan->pDevice, BT_RESOURCE_ENUM, 0);
g_CAN_HANDLES[pResource->ulStart] = NULL; // Finally mark the hardware as not used.
return BT_ERR_NONE;
}
/**
* Complete a full configuration of the UART.
**/
static BT_ERROR canSetConfig(BT_HANDLE hCan, BT_CAN_CONFIG *pConfig) {
volatile LPC17xx_CAN_REGS *pRegs = hCan->pRegs;
BT_ERROR Error = BT_ERR_NONE;
canSetBaudrate(hCan, pConfig->ulBaudrate);
switch(pConfig->eMode) {
case BT_UART_MODE_POLLED: {
if(hCan->eMode != BT_CAN_MODE_POLLED) {
if(hCan->hTxFifo) {
BT_CloseHandle(hCan->hTxFifo);
hCan->hTxFifo = NULL;
}
if(hCan->hRxFifo) {
BT_CloseHandle(hCan->hRxFifo);
hCan->hRxFifo = NULL;
}
// Disable TX and RX interrupts
pRegs->CANIER &= ~LPC17xx_CAN_IER_RIE; // Disable the interrupt
hCan->eMode = BT_CAN_MODE_POLLED;
}
break;
}
case BT_UART_MODE_BUFFERED:
{
if(hCan->eMode != BT_CAN_MODE_BUFFERED) {
if(!hCan->hRxFifo && !hCan->hTxFifo) {
hCan->hRxFifo = BT_FifoCreate(pConfig->usRxBufferSize, sizeof(BT_CAN_MESSAGE), 0, &Error);
hCan->hTxFifo = BT_FifoCreate(pConfig->usTxBufferSize, sizeof(BT_CAN_MESSAGE), 0, &Error);
pRegs->CANIER |= LPC17xx_CAN_IER_RIE; // Enable the interrupt
hCan->eMode = BT_CAN_MODE_BUFFERED;
}
}
break;
}
}
LPC17xx_CAN_COMMON_REGS *pCMN = CAN_COMMON;
pCMN->LPC17xx_CAN_AFMR |= LPC17xx_CAN_AFMR_ACCBP;
return Error;
}
static int bt_cat(BT_HANDLE hShell, int argc, char **argv) {
BT_HANDLE hStdout = BT_ShellGetStdout(hShell);
BT_ERROR Error;
char *szpPath = 0;
if(argc == 1) {
szpPath = "/";
} else if(argc == 2) {
szpPath = argv[1];
} else {
bt_fprintf(hStdout, "Usage: %s [path]\n", argv[0]);
return -1;
}
BT_HANDLE hFile = BT_Open(szpPath, BT_GetModeFlags("rb"), &Error);
if(!hFile) {
bt_fprintf(hStdout, "cat: cannot access %s: No such file or not a file\n", szpPath);
return 0;
}
BT_s32 c;
while((c = BT_GetC(hFile, 0)) >= 0) {
bt_fprintf(hStdout, "%c", c);
}
bt_fprintf(hStdout, "\n");
BT_CloseHandle(hFile);
return 0;
}
long bt_sys_close(int fd) {
BT_ERROR Error = BT_ERR_NONE;
BT_HANDLE hFile = BT_GetFileDescriptor(fd, &Error);
BT_SetFileDescriptor(fd, NULL);
BT_CloseHandle(hFile);
BT_FreeFileDescriptor(fd);
return 0;
}
static BT_ERROR timer_callback_cleanup(BT_HANDLE hCallback) {
struct _TIMER_CALLBACK_HANDLE *hCleanup = (struct _TIMER_CALLBACK_HANDLE*)hCallback;
hCleanup->pfnCallback = NULL;
hCleanup->pParam = NULL;
BT_CloseHandle((BT_HANDLE)hCleanup);
return BT_ERR_NONE;
}
BT_ERROR BT_ShellScript(const BT_i8 *path) {
BT_ERROR Error;
BT_HANDLE hFile = BT_Open(path, "rb", &Error);
if(!hFile) {
BT_kPrint("Could not open shell script %s\n", path);
return BT_ERR_GENERIC;
}
BT_i8 *line = BT_kMalloc(256);
if(!line) {
BT_CloseHandle(hFile);
return BT_ERR_NO_MEMORY;
}
BT_u32 linelen;
while((linelen = BT_GetS(hFile, 256, line)) > 0) {
BT_i8 *p = line;
while(isspace((int) *p)) {
p++;
}
if(*p == '#') {
continue; // commented line!
}
if(p == (line + linelen)) {
continue;
}
Error = BT_ShellCommand(p);
}
BT_kFree(line);
BT_CloseHandle(hFile);
return BT_ERR_NONE;
}
/**
* All modules MUST provide a FULL cleanup function. This must cleanup all allocations etc
* e.g. we will have to populate this when we add circular buffers!
*
**/
static BT_ERROR uartCleanup(BT_HANDLE hUart) {
ResetUart(hUart);
// Disable peripheral clock.
disableUartPeripheralClock(hUart);
// Free any buffers if used.
if(hUart->eMode == BT_UART_MODE_BUFFERED) {
BT_CloseHandle(hUart->hTxFifo);
BT_CloseHandle(hUart->hRxFifo);
}
const BT_RESOURCE *pResource = BT_GetIntegratedResource(hUart->pDevice, BT_RESOURCE_IRQ, 0);
BT_DisableInterrupt(pResource->ulStart);
pResource = BT_GetIntegratedResource(hUart->pDevice, BT_RESOURCE_ENUM, 0);
g_USART_HANDLES[pResource->ulStart] = NULL; // Finally mark the hardware as not used.
return BT_ERR_NONE;
}
BT_ERROR BT_CleanupInterruptControllers() {
BT_u32 i;
BT_ERROR Error;
for(i=0; i < g_ulRegistered; i++) {
BT_CloseHandle(g_oControllers[i].hIRQ);
if(Error) {
//BT_kPrintf("Error cleaning %s", );
}
}
return BT_ERR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: sys_mbox_free
*---------------------------------------------------------------------------*
* Description:
* Deallocates a mailbox. If there are messages still present in the
* mailbox when the mailbox is deallocated, it is an indication of a
* programming error in lwIP and the developer should be notified.
* Inputs:
* sys_mbox_t mbox -- Handle of mailbox
* Outputs:
* sys_mbox_t -- Handle to new mailbox
*---------------------------------------------------------------------------*/
void sys_mbox_free( sys_mbox_t *pxMailBox ) {
BT_u32 ulMessagesWaiting;
ulMessagesWaiting = BT_QueueMessagesWaiting( *pxMailBox );
#if SYS_STATS
{
if( ulMessagesWaiting != 0UL ) {
SYS_STATS_INC( mbox.err );
}
SYS_STATS_DEC( mbox.used );
}
#endif /* SYS_STATS */
BT_CloseHandle( *pxMailBox );
}
static int bt_partition_disk(BT_HANDLE hShell, int argc, char **argv) {
if(argc > 2) {
usage_disk(hShell);
return -1;
}
if(argc == 1) {
BT_PRSHELL("Current disk: %s\n", device_path ? device_path : "none-selected");
return 0;
}
if(!device_path) {
int retval = 0;
BT_ERROR Error;
BT_HANDLE hBlock = BT_Open(argv[1], 0, &Error);
if(!hBlock) {
BT_PRSHELL("Error: Could not open %s\n", argv[1]);
return -1;
}
/**
* Ensure we have a valid block device handle.
* This API will return BT_ERR_INVALID_HANDLE, or BT_ERR_NONE.
*
* Maybe we should actually add a simple API for that!
**/
if(BT_GetBlockGeometry(hBlock, NULL) != BT_ERR_NONE) {
BT_PRSHELL("Error: %s is not a RAW block device\n", argv[1]);
retval = -1;
goto close_out;
}
device_path = BT_kMalloc(strlen(argv[1]));
strcpy(device_path, argv[1]);
close_out:
BT_CloseHandle(hBlock);
return retval;
} else {
BT_PRSHELL("Already working with: %s\n", device_path);
}
return 0;
}
static int bt_partition_list(BT_HANDLE hShell, int argc, char **argv) {
if(argc != 1) {
usage_list(hShell);
return -1;
}
if(!device_path) {
return no_disk(hShell);
}
BT_BLOCK_GEOMETRY oGeom;
BT_u32 i;
if(!p_partition_info) {
BT_ERROR Error;
BT_HANDLE hBlock = BT_Open(device_path, 0, &Error);
if(!hBlock) {
BT_PRSHELL("Error: Could not open %s\n", argv[1]);
return -1;
}
BT_GetBlockGeometry(hBlock, &oGeom);
g_partitions = BT_PartitionCount(hBlock);
for(i = 0; i < g_partitions; i++) {
BT_PartitionInfo(hBlock, i, &g_partition_info[i]);
}
p_partition_info = g_partition_info;
BT_CloseHandle(hBlock);
}
BT_PRSHELL("Device %s contains %d partitions\n", device_path, g_partitions);
BT_PRSHELL("BlockSize : %lu\n", oGeom.ulBlockSize);
BT_PRSHELL("Total Blocks : %lu\n", oGeom.ulTotalBlocks);
for(i = 0; i < g_partitions; i++) {
BT_PRSHELL(" %d : %lu : %lu\n", i, g_partition_info[i].ulStartLBA, g_partition_info[i].ulSectorCount);
}
return 0;
}
/** Delete a semaphore
* @param mutex the mutex to delete */
void sys_mutex_free( sys_mutex_t *Mutex ) {
SYS_STATS_DEC( mutex.used );
BT_CloseHandle( *Mutex );
}
static BT_ERROR fifo_cleanup(BT_HANDLE hFifo) {
BT_CloseHandle(hFifo->hQueue);
return BT_ERR_NONE;
}
static int bt_load_fpga(BT_HANDLE hShell, int argc, char **argv) {
BT_HANDLE hStdout = BT_ShellGetStdout(hShell);
BT_ERROR Error;
if(argc != 4 && argc != 5) {
bt_fprintf(hStdout, "Usage: %s [buffer_address] [fpga_device] [bitstream] [length]\n", argv[0]);
return -1;
}
BT_u32 length = 0;
BT_u32 addr = strtoul(argv[1], NULL, 16);
void *p = (void *) addr;
if(argv[3][0] == '-' && argc == 5) {
// Image loaded and length provided.
length = strtoul(argv[4], NULL, 10);
goto flush;
}
BT_HANDLE hFile = BT_Open(argv[3], BT_GetModeFlags("rb"), &Error);
if(!hFile) {
bt_fprintf(hStdout, "Could not open bitstream at %s\n", argv[3]);
return -1;
}
BT_HANDLE hInode = BT_GetInode(argv[3], &Error);
if(!hInode) {
bt_fprintf(hStdout, "Could not stat bitstream at %s\n", argv[3]);
BT_CloseHandle(hFile);
return -1;
}
BT_INODE oInode;
BT_ReadInode(hInode, &oInode);
BT_kPrint("Loading %s at %08X (%llu bytes)", argv[3], addr, oInode.ullFileSize);
BT_Read(hFile, 0, oInode.ullFileSize, p, &Error);
BT_kPrint("Load successful");
if(hFile) {
BT_CloseHandle(hFile);
}
if(hInode) {
BT_CloseHandle(hInode);
}
length = oInode.ullFileSize;
flush:
BT_DCacheFlush();
BT_HANDLE hFPGA = BT_DeviceOpen(argv[2], &Error);
if(!hFPGA) {
bt_printf("Failed to open fpga device %s\n", argv[2]);
return -1;
}
BT_Write(hFPGA, 0, length, p, &Error);
BT_CloseHandle(hFPGA);
return 0;
}
/**
* Complete a full configuration of the UART.
**/
static BT_ERROR uartSetConfig(BT_HANDLE hUart, BT_UART_CONFIG *pConfig) {
volatile LM3Sxx_UART_REGS *pRegs = hUart->pRegs;
BT_ERROR Error = BT_ERR_NONE;
uartSetBaudrate(hUart, pConfig->ulBaudrate);
uartDisable(hUart);
// Set parity, data length, and number of stop bits.
pRegs->LCRH = (pConfig->ucDataBits - 5) << 5;
pRegs->LCRH |= (pConfig->ucStopBits) << 3;
if (pConfig->ucParity == BT_UART_PARITY_ODD) pRegs->LCRH |= LM3Sxx_UART_LCRH_ODD;
if (pConfig->ucParity == BT_UART_PARITY_EVEN) pRegs->LCRH |= LM3Sxx_UART_LCRH_EVEN;
if (pConfig->ucParity == BT_UART_PARITY_MARK) pRegs->LCRH |= LM3Sxx_UART_LCRH_MARK;
if (pConfig->ucParity == BT_UART_PARITY_SPACE) pRegs->LCRH |= LM3Sxx_UART_LCRH_SPACE;
// Clear the flags register.
pRegs->FR = 0;
uartEnable(hUart);
switch(pConfig->eMode) {
case BT_UART_MODE_POLLED: {
if(hUart->eMode != BT_UART_MODE_POLLED) {
if(hUart->hTxFifo) {
BT_CloseHandle(hUart->hTxFifo);
hUart->hTxFifo = NULL;
}
if(hUart->hRxFifo) {
BT_CloseHandle(hUart->hRxFifo);
hUart->hRxFifo = NULL;
}
// Disable TX and RX interrupts
pRegs->IM &= ~(LM3Sxx_UART_INT_RX | LM3Sxx_UART_INT_RT); // Disable the interrupt
hUart->eMode = BT_UART_MODE_POLLED;
}
break;
}
case BT_UART_MODE_BUFFERED:
{
if(hUart->eMode != BT_UART_MODE_BUFFERED) {
if(!hUart->hRxFifo && !hUart->hTxFifo) {
hUart->hRxFifo = BT_FifoCreate(pConfig->ulRxBufferSize, 1, 0, &Error);
hUart->hTxFifo = BT_FifoCreate(pConfig->ulTxBufferSize, 1, 0, &Error);
pRegs->IM |= LM3Sxx_UART_INT_RX | LM3Sxx_UART_INT_RT; // Enable the interrupt
hUart->eMode = BT_UART_MODE_BUFFERED;
}
}
break;
}
default:
// Unsupported operating mode!
break;
}
return BT_ERR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: sys_sem_free
*---------------------------------------------------------------------------*
* Description:
* Deallocates a semaphore
* Inputs:
* sys_sem_t sem -- Semaphore to free
*---------------------------------------------------------------------------*/
void sys_sem_free( sys_sem_t *pxSemaphore ) {
SYS_STATS_DEC(sem.used);
BT_CloseHandle( *pxSemaphore );
}
/**
* Complete a full configuration of the SPI.
**/
static BT_ERROR spiSetConfig(BT_HANDLE hSpi, BT_SPI_CONFIG *pConfig) {
volatile LPC17xx_SPI_REGS *pRegs = hSpi->pRegs;
BT_ERROR Error = BT_ERR_NONE;
const BT_RESOURCE *pResource = BT_GetIntegratedResource(hSpi->pDevice, BT_RESOURCE_ENUM, 0);
if (pResource->ulStart == 0) {
pRegs->CR &= ~(LPC17xx_SPI_CR_DSS_MASK << 8);
pRegs->CR |= (pConfig->ucDataBits & LPC17xx_SPI_CR_DSS_MASK) << 8;
pRegs->CR &= ~(LPC17xx_SPI_CR_CPOL | LPC17xx_SPI_CR_CPHA);
if (pConfig->eCPOL)
pRegs->CR |= LPC17xx_SPI_CR_CPOL;
if (pConfig->eCPHA)
pRegs->CR |= LPC17xx_SPI_CR_CPHA;
}
else {
pRegs->CR0 = (pConfig->ucDataBits - 1) & LPC17xx_SPI_CR0_DSS_MASK;
pRegs->CR0 |= pConfig->eCPOL << 6;
pRegs->CR0 |= pConfig->eCPHA << 7;
}
spiSetBaudrate(hSpi, pConfig->ulBaudrate);
switch(pConfig->eMode) {
case BT_SPI_MODE_POLLED: {
if(hSpi->eMode != BT_SPI_MODE_POLLED) {
if(hSpi->hTxFifo) {
BT_CloseHandle(hSpi->hTxFifo);
hSpi->hTxFifo = NULL;
}
if(hSpi->hRxFifo) {
BT_CloseHandle(hSpi->hRxFifo);
hSpi->hRxFifo = NULL;
}
// Disable TX and RX interrupts
//@@pRegs->IER &= ~LPC17xx_SPI_IER_RBRIE; // Disable the interrupt
hSpi->eMode = BT_SPI_MODE_POLLED;
}
break;
}
case BT_SPI_MODE_BUFFERED:
{
if(hSpi->eMode != BT_SPI_MODE_BUFFERED) {
if(!hSpi->hRxFifo && !hSpi->hTxFifo) {
hSpi->hRxFifo = BT_FifoCreate(pConfig->ulRxBufferSize, 1, 0, &Error);
hSpi->hTxFifo = BT_FifoCreate(pConfig->ulTxBufferSize, 1, 0, &Error);
//@@pRegs->IER |= LPC17xx_SPI_IER_RBRIE; // Enable the interrupt
hSpi->eMode = BT_SPI_MODE_BUFFERED;
}
}
break;
}
default:
// Unsupported operating mode!
break;
}
return BT_ERR_NONE;
}
int closesocket(int s) {
BT_CloseHandle((BT_HANDLE)s);
return 0;
}
