/** * * 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; }