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_MAX32675_UART_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32675_UART_H_
 
/***** Definitions *****/
#include <stdbool.h>
#include "uart_regs.h"
#include "mxc_sys.h"
 
#define UART_EXTCLK_FREQ EXTCLK_FREQ
 
#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_0, 
    MXC_UART_PARITY_EVEN_1, 
    MXC_UART_PARITY_ODD_0, 
    MXC_UART_PARITY_ODD_1, 
} mxc_uart_parity_t;
 
typedef enum {
    MXC_UART_FLOW_DIS, 
    MXC_UART_FLOW_EN, 
} mxc_uart_flow_t;
 
typedef enum {
    MXC_UART_APB_CLK = 0,
    MXC_UART_EXT_CLK = 1,
    /*8M (IBRO) and 32M (EFRO) clocks can be used for UARTs 0 and 2*/
    MXC_UART_IBRO_CLK = 2,
    MXC_UART_ERFO_CLK = 3,
} mxc_uart_clock_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; 
    const 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, mxc_uart_clock_t clock);
 
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, mxc_uart_clock_t clock);
 
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, mxc_uart_clock_t clock);
 
/* ************************************************************************* */
/* Low-level functions                                                       */
/* ************************************************************************* */
 
int MXC_UART_GetActive(mxc_uart_regs_t *uart);
 
int MXC_UART_AbortTransmission(mxc_uart_regs_t *uart);
 
int MXC_UART_ReadCharacterRaw(mxc_uart_regs_t *uart);
 
int MXC_UART_WriteCharacterRaw(mxc_uart_regs_t *uart, uint8_t character);
 
int MXC_UART_ReadCharacter(mxc_uart_regs_t *uart);
 
int MXC_UART_WriteCharacter(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, const 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, const unsigned char *bytes,
                                  unsigned int len);
 
int MXC_UART_WriteTXFIFODMA(mxc_uart_regs_t *uart, const 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);
 
/* ************************************************************************* */
/* 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_AsyncStop(mxc_uart_regs_t *uart);
 
int MXC_UART_AbortAsync(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_MAX32675_UART_H_