fsl_flexio_mculcd.h

/*
 * Copyright (c) 2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2021, 2022 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_FLEXIO_MCULCD_H_
#define _FSL_FLEXIO_MCULCD_H_
 
#include "fsl_common.h"
#include "fsl_flexio.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_FLEXIO_MCULCD_DRIVER_VERSION (MAKE_VERSION(2, 0, 7))
#ifndef FLEXIO_MCULCD_WAIT_COMPLETE_TIME
#define FLEXIO_MCULCD_WAIT_COMPLETE_TIME 512
#endif
 
#ifndef FLEXIO_MCULCD_DATA_BUS_WIDTH
#define FLEXIO_MCULCD_DATA_BUS_WIDTH 16UL
#endif
 
#if (16UL != FLEXIO_MCULCD_DATA_BUS_WIDTH) && (8UL != FLEXIO_MCULCD_DATA_BUS_WIDTH)
#error Only support data bus 8-bit or 16-bit
#endif
 
enum
{
    kStatus_FLEXIO_MCULCD_Idle  = MAKE_STATUS(kStatusGroup_FLEXIO_MCULCD, 0), 
    kStatus_FLEXIO_MCULCD_Busy  = MAKE_STATUS(kStatusGroup_FLEXIO_MCULCD, 1), 
    kStatus_FLEXIO_MCULCD_Error = MAKE_STATUS(kStatusGroup_FLEXIO_MCULCD, 2), 
};
 
typedef enum _flexio_mculcd_pixel_format
{
    kFLEXIO_MCULCD_RGB565 = 0, 
    kFLEXIO_MCULCD_BGR565,     
    kFLEXIO_MCULCD_RGB888,     
    kFLEXIO_MCULCD_BGR888,     
} flexio_mculcd_pixel_format_t;
 
typedef enum _flexio_mculcd_bus
{
    kFLEXIO_MCULCD_8080, 
    kFLEXIO_MCULCD_6800, 
} flexio_mculcd_bus_t;
 
enum _flexio_mculcd_interrupt_enable
{
    kFLEXIO_MCULCD_TxEmptyInterruptEnable = (1U << 0U), 
    kFLEXIO_MCULCD_RxFullInterruptEnable  = (1U << 1U), 
};
 
enum _flexio_mculcd_status_flags
{
    kFLEXIO_MCULCD_TxEmptyFlag = (1U << 0U), 
    kFLEXIO_MCULCD_RxFullFlag  = (1U << 1U), 
};
 
enum _flexio_mculcd_dma_enable
{
    kFLEXIO_MCULCD_TxDmaEnable = 0x1U, 
    kFLEXIO_MCULCD_RxDmaEnable = 0x2U, 
};
 
typedef void (*flexio_mculcd_pin_func_t)(bool set);
 
typedef struct _flexio_mculcd_type
{
    FLEXIO_Type *flexioBase;             
    flexio_mculcd_bus_t busType;         
    uint8_t dataPinStartIndex;           
    uint8_t ENWRPinIndex;                
    uint8_t RDPinIndex;                  
    uint8_t txShifterStartIndex;         
    uint8_t txShifterEndIndex;           
    uint8_t rxShifterStartIndex;         
    uint8_t rxShifterEndIndex;           
    uint8_t timerIndex;                  
    flexio_mculcd_pin_func_t setCSPin;   
    flexio_mculcd_pin_func_t setRSPin;   
    flexio_mculcd_pin_func_t setRDWRPin; 
} FLEXIO_MCULCD_Type;
 
typedef struct _flexio_mculcd_config
{
    bool enable;           
    bool enableInDoze;     
    bool enableInDebug;    
    bool enableFastAccess; 
    uint32_t baudRate_Bps; 
} flexio_mculcd_config_t;
 
typedef enum _flexio_mculcd_transfer_mode
{
    kFLEXIO_MCULCD_ReadArray,      
    kFLEXIO_MCULCD_WriteArray,     
    kFLEXIO_MCULCD_WriteSameValue, 
} flexio_mculcd_transfer_mode_t;
 
typedef struct _flexio_mculcd_transfer
{
    uint32_t command;                   
    flexio_mculcd_transfer_mode_t mode; 
    uint32_t dataAddrOrSameValue;       
    size_t dataSize;                    
} flexio_mculcd_transfer_t;
 
typedef struct _flexio_mculcd_handle flexio_mculcd_handle_t;
 
typedef void (*flexio_mculcd_transfer_callback_t)(FLEXIO_MCULCD_Type *base,
                                                  flexio_mculcd_handle_t *handle,
                                                  status_t status,
                                                  void *userData);
 
struct _flexio_mculcd_handle
{
    uint32_t dataAddrOrSameValue;                         
    size_t dataCount;                                     
    volatile size_t remainingCount;                       
    volatile uint32_t state;                              
    flexio_mculcd_transfer_callback_t completionCallback; 
    void *userData;                                       
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
status_t FLEXIO_MCULCD_Init(FLEXIO_MCULCD_Type *base, flexio_mculcd_config_t *config, uint32_t srcClock_Hz);
 
void FLEXIO_MCULCD_Deinit(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_GetDefaultConfig(flexio_mculcd_config_t *config);
 
uint32_t FLEXIO_MCULCD_GetStatusFlags(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_ClearStatusFlags(FLEXIO_MCULCD_Type *base, uint32_t mask);
 
void FLEXIO_MCULCD_EnableInterrupts(FLEXIO_MCULCD_Type *base, uint32_t mask);
 
void FLEXIO_MCULCD_DisableInterrupts(FLEXIO_MCULCD_Type *base, uint32_t mask);
 
static inline void FLEXIO_MCULCD_EnableTxDMA(FLEXIO_MCULCD_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, (1UL << base->txShifterStartIndex), enable);
}
 
static inline void FLEXIO_MCULCD_EnableRxDMA(FLEXIO_MCULCD_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, (1UL << base->rxShifterEndIndex), enable);
}
 
static inline uint32_t FLEXIO_MCULCD_GetTxDataRegisterAddress(FLEXIO_MCULCD_Type *base)
{
    return (uint32_t) & (base->flexioBase->SHIFTBUF[base->txShifterStartIndex]);
}
 
static inline uint32_t FLEXIO_MCULCD_GetRxDataRegisterAddress(FLEXIO_MCULCD_Type *base)
{
    return (uint32_t) & (base->flexioBase->SHIFTBUF[base->rxShifterStartIndex]);
}
 
status_t FLEXIO_MCULCD_SetBaudRate(FLEXIO_MCULCD_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz);
 
void FLEXIO_MCULCD_SetSingleBeatWriteConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_ClearSingleBeatWriteConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_SetSingleBeatReadConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_ClearSingleBeatReadConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_SetMultiBeatsWriteConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_ClearMultiBeatsWriteConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_SetMultiBeatsReadConfig(FLEXIO_MCULCD_Type *base);
 
void FLEXIO_MCULCD_ClearMultiBeatsReadConfig(FLEXIO_MCULCD_Type *base);
 
static inline void FLEXIO_MCULCD_Enable(FLEXIO_MCULCD_Type *base, bool enable)
{
    if (enable)
    {
        FLEXIO_Enable(base->flexioBase, enable);
    }
}
 
uint32_t FLEXIO_MCULCD_ReadData(FLEXIO_MCULCD_Type *base);
 
static inline void FLEXIO_MCULCD_WriteData(FLEXIO_MCULCD_Type *base, uint32_t data)
{
    base->flexioBase->SHIFTBUF[base->txShifterStartIndex] = data;
}
 
static inline void FLEXIO_MCULCD_StartTransfer(FLEXIO_MCULCD_Type *base)
{
    base->setCSPin(false);
}
 
static inline void FLEXIO_MCULCD_StopTransfer(FLEXIO_MCULCD_Type *base)
{
    base->setCSPin(true);
}
 
void FLEXIO_MCULCD_WaitTransmitComplete(void);
 
void FLEXIO_MCULCD_WriteCommandBlocking(FLEXIO_MCULCD_Type *base, uint32_t command);
 
void FLEXIO_MCULCD_WriteDataArrayBlocking(FLEXIO_MCULCD_Type *base, const void *data, size_t size);
 
void FLEXIO_MCULCD_ReadDataArrayBlocking(FLEXIO_MCULCD_Type *base, void *data, size_t size);
 
void FLEXIO_MCULCD_WriteSameValueBlocking(FLEXIO_MCULCD_Type *base, uint32_t sameValue, size_t size);
 
void FLEXIO_MCULCD_TransferBlocking(FLEXIO_MCULCD_Type *base, flexio_mculcd_transfer_t *xfer);
status_t FLEXIO_MCULCD_TransferCreateHandle(FLEXIO_MCULCD_Type *base,
                                            flexio_mculcd_handle_t *handle,
                                            flexio_mculcd_transfer_callback_t callback,
                                            void *userData);
 
status_t FLEXIO_MCULCD_TransferNonBlocking(FLEXIO_MCULCD_Type *base,
                                           flexio_mculcd_handle_t *handle,
                                           flexio_mculcd_transfer_t *xfer);
 
void FLEXIO_MCULCD_TransferAbort(FLEXIO_MCULCD_Type *base, flexio_mculcd_handle_t *handle);
 
status_t FLEXIO_MCULCD_TransferGetCount(FLEXIO_MCULCD_Type *base, flexio_mculcd_handle_t *handle, size_t *count);
 
void FLEXIO_MCULCD_TransferHandleIRQ(void *base, void *handle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
#endif /*_FSL_FLEXIO_MCULCD_H_*/