uart.h

 
/******************************************************************************
 *
 * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by 
 * Analog Devices, Inc.),
 * Copyright (C) 2023-2024 Analog Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/
 
/* Define to prevent redundant inclusion */
#ifndef LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32660_UART_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32660_UART_H_
 
/***** Definitions *****/
#include <stdbool.h>
#include "uart_regs.h"
#include "mxc_sys.h"
#include "mxc_pins.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct _mxc_uart_req_t mxc_uart_req_t;
typedef enum {
    MXC_UART_STOP_1, 
    MXC_UART_STOP_2, 
} mxc_uart_stop_t;
 
typedef enum {
    MXC_UART_PARITY_DISABLE, 
    MXC_UART_PARITY_EVEN, 
    MXC_UART_PARITY_ODD, 
    MXC_UART_PARITY_MARK, 
    MXC_UART_PARITY_SPACE, 
    MXC_UART_PARITY_EVEN_0, 
    MXC_UART_PARITY_EVEN_1, 
    MXC_UART_PARITY_ODD_0, 
    MXC_UART_PARITY_ODD_1, 
    MXC_UART_PARITY_MARK_0, 
    MXC_UART_PARITY_MARK_1, 
    MXC_UART_PARITY_SPACE_0, 
    MXC_UART_PARITY_SPACE_1, 
} mxc_uart_parity_t;
 
typedef enum {
    MXC_UART_FLOW_DIS, 
    MXC_UART_FLOW_EN_LOW, 
    MXC_UART_FLOW_EN_HIGH, 
} mxc_uart_flow_t;
 
typedef void (*mxc_uart_complete_cb_t)(mxc_uart_req_t *req, int result);
 
typedef void (*mxc_uart_dma_complete_cb_t)(mxc_uart_req_t *req, int num, int result);
 
struct _mxc_uart_req_t {
    mxc_uart_regs_t *uart; 
    uint8_t *txData; 
    uint8_t *rxData; 
    uint32_t txLen; 
    uint32_t rxLen; 
    volatile uint32_t txCnt; 
    volatile uint32_t rxCnt; 
 
    mxc_uart_complete_cb_t callback; 
};
 
/***** Function Prototypes *****/
 
/* ************************************************************************* */
/* Control/Configuration functions                                           */
/* ************************************************************************* */
 
int MXC_UART_Init(mxc_uart_regs_t *uart, unsigned int baud, sys_map_t map);
 
int MXC_UART_Shutdown(mxc_uart_regs_t *uart);
 
int MXC_UART_ReadyForSleep(mxc_uart_regs_t *uart);
 
int MXC_UART_SetFrequency(mxc_uart_regs_t *uart, unsigned int baud);
 
int MXC_UART_GetFrequency(mxc_uart_regs_t *uart);
 
int MXC_UART_SetDataSize(mxc_uart_regs_t *uart, int dataSize);
 
int MXC_UART_SetStopBits(mxc_uart_regs_t *uart, mxc_uart_stop_t stopBits);
 
int MXC_UART_SetParity(mxc_uart_regs_t *uart, mxc_uart_parity_t parity);
 
int MXC_UART_SetFlowCtrl(mxc_uart_regs_t *uart, mxc_uart_flow_t flowCtrl, int rtsThreshold);
 
int MXC_UART_SetClockSource(mxc_uart_regs_t *uart, int usePCLK);
 
int MXC_UART_SetNullModem(mxc_uart_regs_t *uart, int nullModem);
 
/* ************************************************************************* */
/* Low-level functions                                                       */
/* ************************************************************************* */
 
int MXC_UART_SendBreak(mxc_uart_regs_t *uart);
 
int MXC_UART_GetActive(mxc_uart_regs_t *uart);
 
int MXC_UART_AbortTransmission(mxc_uart_regs_t *uart);
 
int MXC_UART_ReadCharacter(mxc_uart_regs_t *uart);
 
int MXC_UART_WriteCharacter(mxc_uart_regs_t *uart, uint8_t character);
 
int MXC_UART_ReadCharacterRaw(mxc_uart_regs_t *uart);
 
int MXC_UART_WriteCharacterRaw(mxc_uart_regs_t *uart, uint8_t character);
 
int MXC_UART_Read(mxc_uart_regs_t *uart, uint8_t *buffer, int *len);
 
int MXC_UART_Write(mxc_uart_regs_t *uart, uint8_t *byte, int *len);
 
unsigned int MXC_UART_ReadRXFIFO(mxc_uart_regs_t *uart, unsigned char *bytes, unsigned int len);
 
int MXC_UART_ReadRXFIFODMA(mxc_uart_regs_t *uart, unsigned char *bytes, unsigned int len,
                           mxc_uart_dma_complete_cb_t callback);
 
unsigned int MXC_UART_GetRXFIFOAvailable(mxc_uart_regs_t *uart);
 
unsigned int MXC_UART_WriteTXFIFO(mxc_uart_regs_t *uart, unsigned char *bytes, unsigned int len);
 
int MXC_UART_WriteTXFIFODMA(mxc_uart_regs_t *uart, unsigned char *bytes, unsigned int len,
                            mxc_uart_dma_complete_cb_t callback);
 
unsigned int MXC_UART_GetTXFIFOAvailable(mxc_uart_regs_t *uart);
 
int MXC_UART_ClearRXFIFO(mxc_uart_regs_t *uart);
 
int MXC_UART_ClearTXFIFO(mxc_uart_regs_t *uart);
 
int MXC_UART_SetRXThreshold(mxc_uart_regs_t *uart, unsigned int numBytes);
 
unsigned int MXC_UART_GetRXThreshold(mxc_uart_regs_t *uart);
 
int MXC_UART_SetTXThreshold(mxc_uart_regs_t *uart, unsigned int numBytes);
 
unsigned int MXC_UART_GetTXThreshold(mxc_uart_regs_t *uart);
 
unsigned int MXC_UART_GetFlags(mxc_uart_regs_t *uart);
 
int MXC_UART_ClearFlags(mxc_uart_regs_t *uart, unsigned int flags);
 
int MXC_UART_EnableInt(mxc_uart_regs_t *uart, unsigned int mask);
 
int MXC_UART_DisableInt(mxc_uart_regs_t *uart, unsigned int mask);
 
unsigned int MXC_UART_GetStatus(mxc_uart_regs_t *uart);
 
int MXC_UART_Busy(mxc_uart_regs_t *uart);
 
/* ************************************************************************* */
/* Transaction level functions                                               */
/* ************************************************************************* */
 
int MXC_UART_Transaction(mxc_uart_req_t *req);
 
int MXC_UART_TransactionAsync(mxc_uart_req_t *req);
 
int MXC_UART_TransactionDMA(mxc_uart_req_t *req);
 
void MXC_UART_DMACallback(int ch, int error);
 
int MXC_UART_AsyncCallback(mxc_uart_regs_t *uart, int retVal);
int MXC_UART_TxAsyncCallback(mxc_uart_regs_t *uart, int retVal);
int MXC_UART_RxAsyncCallback(mxc_uart_regs_t *uart, int retVal);
 
int MXC_UART_AsyncStop(mxc_uart_regs_t *uart);
int MXC_UART_TxAsyncStop(mxc_uart_regs_t *uart);
int MXC_UART_RxAsyncStop(mxc_uart_regs_t *uart);
 
int MXC_UART_AbortAsync(mxc_uart_regs_t *uart);
int MXC_UART_TxAbortAsync(mxc_uart_regs_t *uart);
int MXC_UART_RxAbortAsync(mxc_uart_regs_t *uart);
 
int MXC_UART_AsyncHandler(mxc_uart_regs_t *uart);
 
uint32_t MXC_UART_GetAsyncTXCount(mxc_uart_req_t *req);
 
uint32_t MXC_UART_GetAsyncRXCount(mxc_uart_req_t *req);
 
int MXC_UART_SetAutoDMAHandlers(mxc_uart_regs_t *uart, bool enable);
 
int MXC_UART_SetTXDMAChannel(mxc_uart_regs_t *uart, unsigned int channel);
 
int MXC_UART_GetTXDMAChannel(mxc_uart_regs_t *uart);
 
int MXC_UART_SetRXDMAChannel(mxc_uart_regs_t *uart, unsigned int channel);
 
int MXC_UART_GetRXDMAChannel(mxc_uart_regs_t *uart);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32660_UART_H_