/**
*
* Makes the connection between the Id of the interrupt source and the
* associated handler that is to run when the interrupt is recognized.
*
* @param InstancePtr is a pointer to the XIOModule instance.
* @param Id contains the ID of the interrupt source and should be in the
* range of 0 to XPAR_INTC_MAX_NUM_INTR_INPUTS - 1 with 0 being the
* highest priority interrupt.
* @param Handler to the handler for that interrupt.
*
* @return
* - XST_SUCCESS if the handler was connected correctly.
*
* @note Only used with fast interrupt mode.
*
* WARNING: The handler provided as an argument will overwrite any handler
* that was previously connected.
*
****************************************************************************/
int XIOModule_ConnectFastHandler(XIOModule *InstancePtr, u8 Id,
XFastInterruptHandler Handler)
{
u32 CurrentIER, NewIMR;
u32 Mask;
/*
* Assert the arguments
*/
XASSERT_NONVOID(InstancePtr != NULL);
XASSERT_NONVOID(Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE);
XASSERT_NONVOID(Handler != NULL);
XASSERT_NONVOID(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
XASSERT_NONVOID(InstancePtr->CfgPtr->FastIntr == TRUE);
/*
* The Id is used to create the appropriate mask for the
* desired bit position. Id currently limited to 0 - 31
*/
Mask = XIOModule_BitPosMask[Id];
/*
* Get the Enabled Interrupts and disable the Interrupt if it was
* enabled before calling this function
*/
CurrentIER = InstancePtr->CurrentIER;
if (CurrentIER & Mask) {
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
CurrentIER & ~Mask);
}
/*
* Assign the handler information and set the hardware vector
*/
InstancePtr->CfgPtr->HandlerTable[Id].Handler = NULL;
InstancePtr->CfgPtr->HandlerTable[Id].CallBackRef = InstancePtr;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IVAR_OFFSET + (Id * 4),
(u32) Handler);
/*
* Set the selected interrupt source to use fast interrupt
*/
NewIMR = InstancePtr->CurrentIMR | Mask;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IMR_OFFSET, NewIMR);
InstancePtr->CurrentIMR = NewIMR;
/*
* Enable Interrupt if it was enabled before calling this function
*/
if (CurrentIER & Mask) {
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
CurrentIER);
}
return XST_SUCCESS;
}
/**
*
* Sets the normal interrupt mode for the specified interrupt in the Interrupt
* Mode Register, by resetting the vector to 0x10 and selecting normal mode.
*
* @param InstancePtr is a pointer to the XIOModule instance.
* @param Id contains the ID of the interrupt source and should be in the
* range of 0 to XPAR_INTC_MAX_NUM_INTR_INPUTS - 1 with 0 being the
* highest priority interrupt.
*
* @return None.
*
* @note Only used with fast interrupt mode.
*
****************************************************************************/
void XIOModule_SetNormalIntrMode(XIOModule *InstancePtr, u8 Id)
{
u32 CurrentIER, NewIMR;
u32 Mask;
/*
* Assert the arguments
*/
XASSERT_VOID(InstancePtr != NULL);
XASSERT_VOID(Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE);
XASSERT_VOID(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
XASSERT_VOID(InstancePtr->CfgPtr->FastIntr == TRUE);
/*
* The Id is used to create the appropriate mask for the
* desired bit position. Id currently limited to 0 - 31
*/
Mask = XIOModule_BitPosMask[Id];
/*
* Get the Enabled Interrupts and disable the Interrupt if it was
* enabled before calling this function
*/
CurrentIER = InstancePtr->CurrentIER;
if (CurrentIER & Mask) {
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
CurrentIER & ~Mask);
}
/*
* Set the selected interrupt source to use normal interrupt
*/
NewIMR = InstancePtr->CurrentIMR & ~Mask;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IMR_OFFSET, NewIMR);
InstancePtr->CurrentIMR = NewIMR;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IVAR_OFFSET + (Id * 4),
0x10);
/*
* Disconnect the handler and connect a stub, the callback reference
* must be set to this instance to allow unhandled interrupts to be
* tracked
*/
InstancePtr->CfgPtr->HandlerTable[Id].Handler = StubHandler;
InstancePtr->CfgPtr->HandlerTable[Id].CallBackRef = InstancePtr;
/*
* Enable Interrupt if it was enabled before calling this function
*/
if (CurrentIER & Mask) {
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
CurrentIER);
}
}
/**
*
* Disables the interrupt source provided as the argument Id such that the
* interrupt controller will not cause interrupts for the specified Id. The
* interrupt controller will continue to hold an interrupt condition for the
* Id, but will not cause an interrupt.
*
* @param InstancePtr is a pointer to the XIOModule instance to be
* worked on.
* @param Id contains the ID of the interrupt source and should be in
* the range of 0 to XPAR_IOMODULE_INTC_MAX_INTR_SIZE - 1
* with 0 being the highest priority interrupt.
*
* @return None.
*
* @note None.
*
****************************************************************************/
void XIOModule_Disable(XIOModule * InstancePtr, u8 Id)
{
u32 NewIER;
u32 Mask;
/*
* Assert the arguments
*/
XASSERT_VOID(InstancePtr != NULL);
XASSERT_VOID(Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE);
XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
/*
* The Id is used to create the appropriate mask for the
* desired bit position. Id currently limited to 0 - 31
*/
Mask = XIOModule_BitPosMask[Id];
/*
* Disable the selected interrupt source by using the interrupt enable
* current value and then modifying only the specified interrupt id
*/
NewIER = InstancePtr->CurrentIER & ~Mask;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET, NewIER);
InstancePtr->CurrentIER = NewIER;
}
/**
*
* Run a self-test on the interrupt controller driver/device. This is a
* destructive test.
*
* This involves forcing interrupts into the controller (if possible, given
* the IO Module configuration) and verifying that they are recognized and can
* be acknowledged.
*
* @param InstancePtr is a pointer to the XIOModule instance to be
* worked on.
*
* @return
* - XST_SUCCESS if self-test is successful.
* - XST_INTC_FAIL_SELFTEST if the Interrupt controller
* fails the self-test. It will fail the self test if the
* device has previously been started in real mode.
*
* @note None.
*
******************************************************************************/
int XIOModule_Intc_SelfTest(XIOModule * InstancePtr)
{
u32 CurrentISR;
u32 Temp;
/*
* Assert the arguments
*/
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Acknowledge all pending interrupts by reading the interrupt status
* register and writing the value to the acknowledge register
*/
Temp = XIomodule_In32(InstancePtr->BaseAddress + XIN_ISR_OFFSET);
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IAR_OFFSET, Temp);
/*
* Verify that there are no interrupts by reading the interrupt status
*/
CurrentISR = XIomodule_In32(InstancePtr->BaseAddress + XIN_ISR_OFFSET);
/*
* ISR for internal interrupts should be zero after all interrupts
* are acknowledged. Skip checking external interrupts, since they may
* occur at any time.
*/
if ((CurrentISR & 0xffff) != 0) {
return XST_INTC_FAIL_SELFTEST;
}
return XST_SUCCESS;
}
/**
*
* Updates the interrupt table with the Null Handler and NULL arguments at the
* location pointed at by the Id. This effectively disconnects that interrupt
* source from any handler. The interrupt is disabled also.
*
* @param InstancePtr is a pointer to the XIOModule instance to be
* worked on.
* @param Id contains the ID of the interrupt source and should be in the
* range of 0 to XPAR_IOMODULE_INTC_MAX_INTR_SIZE - 1 with 0
* being the highest priority interrupt.
*
* @return None.
*
* @note None.
*
****************************************************************************/
void XIOModule_Disconnect(XIOModule * InstancePtr, u8 Id)
{
u32 NewIER;
u32 Mask;
/*
* Assert the arguments
*/
XASSERT_VOID(InstancePtr != NULL);
XASSERT_VOID(Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE);
XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
/*
* Disable the interrupt such that it won't occur while disconnecting
* the handler, only disable the specified interrupt id without
* modifying the other interrupt ids
*/
Mask = XIOModule_BitPosMask[Id]; /* convert integer id to bit mask */
NewIER = InstancePtr->CurrentIER & ~Mask;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET, NewIER);
InstancePtr->CurrentIER = NewIER;
/*
* Disconnect the handler and connect a stub, the callback reference
* must be set to this instance to allow unhandled interrupts to be
* tracked
*/
InstancePtr->CfgPtr->HandlerTable[Id].Handler = StubHandler;
InstancePtr->CfgPtr->HandlerTable[Id].CallBackRef = InstancePtr;
}
/**
*
* This functions sends the specified buffer of data using the UART in either
* polled or interrupt driven modes. This function is non-blocking such that it
* will return before the data has been sent by the UART. If the UART is busy
* sending data, it will return and indicate zero bytes were sent.
*
* In a polled mode, this function will only send as much data as the UART can
* buffer in the transmitter. The application may need to call it repeatedly to
* send a buffer.
*
* In interrupt mode, this function will start sending the specified buffer and
* then the interrupt handler of the driver will continue sending data until the
* buffer has been sent. A callback function, as specified by the application,
* will be called to indicate the completion of sending the buffer.
*
* @param InstancePtr is a pointer to the XIOModule instance.
* @param DataBufferPtr is pointer to a buffer of data to be sent.
* @param NumBytes contains the number of bytes to be sent. A value of
* zero will stop a previous send operation that is in progress
* in interrupt mode. Any data that was already put into the
* transmit FIFO will be sent.
*
* @return The number of bytes actually sent.
*
* @note The number of bytes is not asserted so that this function may
* be called with a value of zero to stop an operation that is
* already in progress.
*
******************************************************************************/
unsigned int XIOModule_Send(XIOModule *InstancePtr, u8 *DataBufferPtr,
unsigned int NumBytes)
{
unsigned int BytesSent;
u32 StatusRegister;
/*
* Assert validates the input arguments
*/
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(DataBufferPtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
Xil_AssertNonvoid(((signed)NumBytes) >= 0);
/*
* Enter a critical region by disabling the UART interrupts to allow
* this call to stop a previous operation that may be interrupt driven.
*/
StatusRegister = InstancePtr->CurrentIER;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
StatusRegister & 0xFFFFFFF8);
/*
* Setup the specified buffer to be sent by setting the instance
* variables so it can be sent with polled or interrupt mode
*/
InstancePtr->SendBuffer.RequestedBytes = NumBytes;
InstancePtr->SendBuffer.RemainingBytes = NumBytes;
InstancePtr->SendBuffer.NextBytePtr = DataBufferPtr;
/*
* Restore the interrupt enable register to it's previous value such
* that the critical region is exited.
* This is done here to minimize the amount of time the interrupt is
* disabled since there is only one interrupt and the receive could
* be filling up while interrupts are blocked.
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
(InstancePtr->CurrentIER & 0xFFFFFFF8) | (StatusRegister & 0x7));
/*
* Send the buffer using the UART and return the number of bytes sent
*/
BytesSent = XIOModule_SendBuffer(InstancePtr);
return BytesSent;
}
/**
* Write 32-bit word to the IO Bus memory mapped IO
*
* @param InstancePtr is a pointer to an XIOModule instance to be
* worked on.
* @param ByteOffset is a byte offset from the beginning of the
* IO Bus address area
* @param Data is the value to be written to the IO Bus - 32-bit
*
* @return None.
*
*****************************************************************************/
void XIOModule_IoWriteWord(XIOModule * InstancePtr,
u32 ByteOffset,
u32 Data)
{
XASSERT_VOID(InstancePtr != NULL);
XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
XIomodule_Out32((InstancePtr->IoBaseAddress + ByteOffset), Data);
}
/**
* Write 32-bit word to the IO Bus memory mapped IO
*
* @param InstancePtr is a pointer to an XIOModule instance to be
* worked on.
* @param ByteOffset is a byte offset from the beginning of the
* IO Bus address area
* @param Data is the value to be written to the IO Bus - 32-bit
*
* @return None.
*
*****************************************************************************/
void XIOModule_IoWriteWord(XIOModule * InstancePtr,
u32 ByteOffset,
u32 Data)
{
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
XIomodule_Out32((InstancePtr->IoBaseAddress + ByteOffset), Data);
}
/**
*
* This function enables the UART interrupts such that an interrupt will occur
* when data is received or data has been transmitted.
*
* @param InstancePtr is a pointer to the XIOModule instance.
*
* @return None.
*
* @note None.
*
*****************************************************************************/
void XIOModule_Uart_EnableInterrupt(XIOModule *InstancePtr)
{
u32 NewIER;
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Write to the interrupt enable register to enable the interrupts.
*/
NewIER = InstancePtr->CurrentIER | 0x7;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET, NewIER);
InstancePtr->CurrentIER = NewIER;
}
/**
*
* Acknowledges the interrupt source provided as the argument Id. When the
* interrupt is acknowledged, it causes the interrupt controller to clear its
* interrupt condition.
*
* @param InstancePtr is a pointer to the XIOModule instance to be
* worked on.
* @param Id contains the ID of the interrupt source and should be in
* the range of 0 to XPAR_IOMODULE_INTC_MAX_INTR_SIZE - 1
* with 0 being the highest priority interrupt.
*
* @return None.
*
* @note None.
*
****************************************************************************/
void XIOModule_Acknowledge(XIOModule * InstancePtr, u8 Id)
{
u32 Mask;
/*
* Assert the arguments
*/
XASSERT_VOID(InstancePtr != NULL);
XASSERT_VOID(Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE);
XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
/*
* The Id is used to create the appropriate mask for the
* desired bit position. Id currently limited to 0 - 31
*/
Mask = XIOModule_BitPosMask[Id];
/*
* Acknowledge the selected interrupt source, no read of the acknowledge
* register is necessary since only the bits set in the mask will be
* affected by the write
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IAR_OFFSET, Mask);
}
/**
*
* Initialize a specific interrupt controller instance/driver. The
* initialization entails:
*
* - Initialize fields of the XIOModule structure
* - Initial vector table with stub function calls
* - All interrupt sources are disabled
* - Interrupt output is disabled
* - All timers are initialized
*
* @param InstancePtr is a pointer to the XIOModule instance to be
* worked on.
* @param DeviceId is the unique id of the device controlled by this
* XIOModule instance. Passing in a device id associates the
* generic XIOModule instance to a specific device, as chosen
* by the caller or application developer.
*
* @return
* - XST_SUCCESS if initialization was successful
* - XST_DEVICE_IS_STARTED if the device has already been started
* - XST_DEVICE_NOT_FOUND if device configuration information was
* not found for a device with the supplied device ID.
*
* @note None.
*
******************************************************************************/
int XIOModule_Initialize(XIOModule * InstancePtr, u16 DeviceId)
{
u8 Id;
XIOModule_Config *CfgPtr;
u32 NextBitMask = 1;
int i;
XASSERT_NONVOID(InstancePtr != NULL);
/*
* If the device is started, disallow the initialize and return a status
* indicating it is started. This allows the user to stop the device
* and reinitialize, but prevents a user from inadvertently initializing
*/
if (InstancePtr->IsStarted == XCOMPONENT_IS_STARTED) {
return XST_DEVICE_IS_STARTED;
}
/*
* Lookup the device configuration in the CROM table. Use this
* configuration info down below when initializing this component.
*/
CfgPtr = XIOModule_LookupConfig(DeviceId);
if (CfgPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
/*
* Set some default values
*/
InstancePtr->IsReady = 0;
InstancePtr->IsStarted = 0; /* not started */
InstancePtr->CfgPtr = CfgPtr;
InstancePtr->CfgPtr->Options = XIN_SVC_SGL_ISR_OPTION;
/*
* Initialize GPO value from INIT parameter
*/
for (i = 0; i < XGPO_DEVICE_COUNT; i++)
InstancePtr->GpoValue[i] = CfgPtr->GpoInit[i];
/*
* Save the base address pointer such that the registers of the
* IO Module can be accessed
*/
InstancePtr->BaseAddress = CfgPtr->BaseAddress;
/*
* Initialize all the data needed to perform interrupt processing for
* each interrupt ID up to the maximum used
*/
for (Id = 0; Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE; Id++) {
/*
* Initalize the handler to point to a stub to handle an
* interrupt which has not been connected to a handler. Only
* initialize it if the handler is 0 or XNullHandler, which
* means it was not initialized statically by the tools/user.
* Set the callback reference to this instance so that
* unhandled interrupts can be tracked.
*/
if ((InstancePtr->CfgPtr->HandlerTable[Id].Handler == 0) ||
(InstancePtr->CfgPtr->HandlerTable[Id].Handler ==
XNullHandler)) {
InstancePtr->CfgPtr->HandlerTable[Id].Handler =
StubHandler;
}
InstancePtr->CfgPtr->HandlerTable[Id].CallBackRef = InstancePtr;
/*
* Initialize the bit position mask table such that bit
* positions are lookups only for each interrupt id, with 0
* being a special case
* (XIOModule_BitPosMask[] = { 1, 2, 4, 8, ... })
*/
XIOModule_BitPosMask[Id] = NextBitMask;
NextBitMask *= 2;
}
/*
* Disable all interrupt sources
* Acknowledge all sources
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET, 0);
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IMR_OFFSET, 0);
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IAR_OFFSET, 0xFFFFFFFF);
InstancePtr->CurrentIER = 0;
InstancePtr->CurrentIMR = 0;
/*
* If the fast Interrupt mode is enabled then set all the
* interrupts as normal mode and initialize the interrupt hardware
* vector table to default (0x10).
*/
if (InstancePtr->CfgPtr->FastIntr == TRUE) {
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IMR_OFFSET, 0);
for (Id = 0; Id < XPAR_IOMODULE_INTC_MAX_INTR_SIZE; Id++) {
XIomodule_Out32(InstancePtr->BaseAddress +
XIN_IVAR_OFFSET + Id * 4, 0x10);
}
}
/*
* Initialize all Programmable Interrupt Timers
*/
XIOModule_Timer_Initialize(InstancePtr, DeviceId);
/*
* Save the IO Bus base address pointer such that the memory mapped
* IO can be accessed
*/
InstancePtr->IoBaseAddress = CfgPtr->IoBaseAddress;
/*
* Indicate the instance is now ready to use, successfully initialized
*/
InstancePtr->IsReady = XCOMPONENT_IS_READY;
return XST_SUCCESS;
}
/**
*
* This function receives a buffer that has been previously specified by setting
* up the instance variables of the instance. This function is designed to be
* an internal function for the XIOModule component such that it may be called
* from a shell function that sets up the buffer or from an interrupt handler.
*
* This function will attempt to receive a specified number of bytes of data
* from the UART and store it into the specified buffer. This function is
* designed for either polled or interrupt driven modes. It is non-blocking
* such that it will return if there is no data has already received by the
* UART.
*
* In a polled mode, this function will only receive as much data as the UART
* can buffer, either in the receiver or in the FIFO if present and enabled.
* The application may need to call it repeatedly to receive a buffer. Polled
* mode is the default mode of operation for the driver.
*
* In interrupt mode, this function will start receiving and then the interrupt
* handler of the driver will continue until the buffer has been received. A
* callback function, as specified by the application, will be called to indicate
* the completion of receiving the buffer or when any receive errors or timeouts
* occur.
*
* @param InstancePtr is a pointer to the XIOModule instance.
*
* @return The number of bytes received.
*
* @note None.
*
*****************************************************************************/
unsigned int XIOModule_ReceiveBuffer(XIOModule *InstancePtr)
{
u8 StatusRegister;
unsigned int ReceivedCount = 0;
/*
* Loop until there is not more data buffered by the UART or the
* specified number of bytes is received
*/
while (ReceivedCount < InstancePtr->ReceiveBuffer.RemainingBytes) {
/*
* Read the Status Register to determine if there is any data in
* the receiver
*/
StatusRegister =
XIOModule_GetStatusReg(InstancePtr->BaseAddress);
/*
* If there is data ready to be removed, then put the next byte
* received into the specified buffer and update the stats to
* reflect any receive errors for the byte
*/
if (StatusRegister & XUL_SR_RX_FIFO_VALID_DATA) {
InstancePtr->ReceiveBuffer.NextBytePtr[ReceivedCount++]=
XIOModule_ReadReg(InstancePtr->BaseAddress,
XUL_RX_OFFSET);
XIOModule_UpdateStats(InstancePtr, StatusRegister);
}
/*
* There's no more data buffered, so exit such that this
* function does not block waiting for data
*/
else {
break;
}
}
/*
* Enter a critical region by disabling all the UART interrupts to allow
* this call to stop a previous operation that may be interrupt driven
*/
StatusRegister = InstancePtr->CurrentIER;
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
StatusRegister & 0xFFFFFFF8);
/*
* Update the receive buffer to reflect the number of bytes that was
* received
*/
InstancePtr->ReceiveBuffer.NextBytePtr += ReceivedCount;
InstancePtr->ReceiveBuffer.RemainingBytes -= ReceivedCount;
/*
* Increment associated counters in the statistics
*/
InstancePtr->Uart_Stats.CharactersReceived += ReceivedCount;
/*
* Restore the interrupt enable register to it's previous value such
* that the critical region is exited
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
(InstancePtr->CurrentIER & 0xFFFFFFF8) | (StatusRegister & 0x7));
return ReceivedCount;
}
/**
*
* This function sends a buffer that has been previously specified by setting
* up the instance variables of the instance. This function is designed to be
* an internal function for the XIOModule component such that it may be called
* from a shell function that sets up the buffer or from an interrupt handler.
*
* This function sends the specified buffer of data to the UART in either
* polled or interrupt driven modes. This function is non-blocking such that
* it will return before the data has been sent by the UART.
*
* In a polled mode, this function will only send as much data as the UART can
* buffer in the transmitter. The application may need to call it repeatedly to
* send a buffer.
*
* In interrupt mode, this function will start sending the specified buffer and
* then the interrupt handler of the driver will continue until the buffer
* has been sent. A callback function, as specified by the application, will
* be called to indicate the completion of sending the buffer.
*
* @param InstancePtr is a pointer to the XIOModule instance.
*
* @return NumBytes is the number of bytes actually sent (put into the
* UART transmitter and/or FIFO).
*
* @note None.
*
*****************************************************************************/
unsigned int XIOModule_SendBuffer(XIOModule *InstancePtr)
{
unsigned int SentCount = 0;
u8 StatusRegister;
u8 IntrEnableStatus;
/*
* Read the status register to determine if the transmitter is full
*/
StatusRegister = XIOModule_GetStatusReg(InstancePtr->BaseAddress);
/*
* Enter a critical region by disabling all the UART interrupts to allow
* this call to stop a previous operation that may be interrupt driven
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
StatusRegister & 0xFFFFFFF8);
/*
* Save the status register contents to restore the interrupt enable
* register to it's previous value when that the critical region is
* exited
*/
IntrEnableStatus = StatusRegister;
/*
* Fill the FIFO from the the buffer that was specified
*/
while (((StatusRegister & XUL_SR_TX_FIFO_FULL) == 0) &&
(SentCount < InstancePtr->SendBuffer.RemainingBytes)) {
XIOModule_WriteReg(InstancePtr->BaseAddress,
XUL_TX_OFFSET,
InstancePtr->SendBuffer.NextBytePtr[
SentCount]);
SentCount++;
StatusRegister =
XIOModule_GetStatusReg(InstancePtr->BaseAddress);
}
/*
* Update the buffer to reflect the bytes that were sent from it
*/
InstancePtr->SendBuffer.NextBytePtr += SentCount;
InstancePtr->SendBuffer.RemainingBytes -= SentCount;
/*
* Increment associated counters
*/
InstancePtr->Uart_Stats.CharactersTransmitted += SentCount;
/*
* Restore the interrupt enable register to it's previous value such
* that the critical region is exited
*/
XIomodule_Out32(InstancePtr->BaseAddress + XIN_IER_OFFSET,
(InstancePtr->CurrentIER & 0xFFFFFFF8) | (IntrEnableStatus & 0x7));
/*
* Return the number of bytes that were sent, althought they really were
* only put into the FIFO, not completely sent yet
*/
return SentCount;
}
