/** * * 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 XUartLite 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, either in the transmitter or in the FIFO if present and enabled. * 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 XUartLite instance to be worked on. * * @return * * NumBytes is the number of bytes actually sent (put into the UART transmitter * and/or FIFO). * * @note * * None. * *****************************************************************************/ unsigned int XUartLite_SendBuffer(XUartLite *InstancePtr) { unsigned int SentCount = 0; Xuint8 StatusRegister; /* Read the line status register to determine if the transmitter is * full */ StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); /* * Fill the FIFO from the the buffer that was specified */ while (((StatusRegister & XUL_SR_TX_FIFO_FULL) == 0) && (SentCount < InstancePtr->SendBuffer.RemainingBytes)) { XIo_Out32(InstancePtr->RegBaseAddress + XUL_TX_FIFO_OFFSET, InstancePtr->SendBuffer.NextBytePtr[SentCount]); SentCount++; StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); } /* 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 = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, 0); /* * Update the buffer to reflect the bytes that were sent from it */ InstancePtr->SendBuffer.NextBytePtr += SentCount; InstancePtr->SendBuffer.RemainingBytes -= SentCount; /* * Increment associated counters */ InstancePtr->Stats.CharactersTransmitted += SentCount; /* Restore the interrupt enable register to it's previous value such * that the critical region is exited */ StatusRegister &= XUL_CR_ENABLE_INTR; XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, StatusRegister); /* * Return the number of bytes that were sent, althought they really were * only put into the FIFO, not completely sent yet */ return SentCount; }
/** * * 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 XUartLite 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, either in the transmitter or in the FIFO if present and enabled. * 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 XUartLite instance to be worked on. * * @return * * NumBytes is the number of bytes actually sent (put into the UART transmitter * and/or FIFO). * * @note * * None. * *****************************************************************************/ unsigned int XUartLite_SendBuffer(XUartLite * InstancePtr) { unsigned int SentCount = 0; u32 StatusRegister; /* Read the line status register to determine if the transmitter is * full */ StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); /* * Fill the FIFO from the the buffer that was specified */ SentCount = 0; while (((StatusRegister & XUL_SR_TX_FIFO_FULL) == 0) && (SentCount < InstancePtr->SendBuffer.RemainingBytes)) { XIo_Out32(InstancePtr->RegBaseAddress + XUL_TX_FIFO_OFFSET, InstancePtr->SendBuffer.NextBytePtr[SentCount]); SentCount++; StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); } /* * Update the buffer to reflect the bytes that were sent from it */ InstancePtr->SendBuffer.NextBytePtr += SentCount; InstancePtr->SendBuffer.RemainingBytes -= SentCount; /* * Increment associated counters */ InstancePtr->Stats.CharactersTransmitted += SentCount; /* * Return the number of bytes that were sent, althought they really were * only put into the FIFO, not completely sent yet */ return SentCount; }
/** * * 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 XUartLite 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. Interrupt mode must be enabled using the SetOptions function. * * @param InstancePtr is a pointer to the XUartLite instance to be worked on. * * @return * * The number of bytes received. * * @note * * None. * *****************************************************************************/ unsigned int XUartLite_ReceiveBuffer(XUartLite * 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/FIFO */ StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); /* 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++] = XIo_In32(InstancePtr->RegBaseAddress + XUL_RX_FIFO_OFFSET); XUartLite_mUpdateStats(InstancePtr, StatusRegister); } /* There's no more data buffered, so exit such that this function does * not block waiting for data */ else { break; } } /* 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->Stats.CharactersReceived += ReceivedCount; return ReceivedCount; }
/** * * 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 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 in the FIFO. 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 receiving data 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. Interrupt mode must be enabled using the SetOptions function. * * @param InstancePtr is a pointer to the XUartLite instance to be worked on. * @param BufferPtr is pointer to buffer for data to be received into * @param NumBytes is the number of bytes to be received. A value of zero will * stop a previous receive operation that is in progress in interrupt mode. * * @return * * The number of bytes received. * * @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 XUartLite_Recv(XUartLite * InstancePtr, u8 * DataBufferPtr, unsigned int NumBytes) { unsigned int ReceivedCount; u32 StatusRegister; /* * Assert validates the input arguments */ XASSERT_NONVOID(InstancePtr != NULL); XASSERT_NONVOID(DataBufferPtr != NULL); XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* 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 = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, 0); /* Setup the specified buffer to be received by setting the instance * variables so it can be received with polled or interrupt mode */ InstancePtr->ReceiveBuffer.RequestedBytes = NumBytes; InstancePtr->ReceiveBuffer.RemainingBytes = NumBytes; InstancePtr->ReceiveBuffer.NextBytePtr = DataBufferPtr; /* Restore the interrupt enable register to it's previous value such * that the critical region is exited */ StatusRegister &= XUL_CR_ENABLE_INTR; XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, StatusRegister); /* Receive the data from the UART and return the number of bytes * received * This is done here to minimize the amount of time the interrupt is * disabled since there is only one interrupt and the transmit could * be emptying out while interrupts are blocked. */ ReceivedCount = XUartLite_ReceiveBuffer(InstancePtr); return ReceivedCount; }
/** * * 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 XUartLite 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. Interrupt mode must be enabled using the SetOptions function. * * @param InstancePtr is a pointer to the XUartLite instance to be worked on. * * @return * * The number of bytes received. * * @note * * None. * *****************************************************************************/ unsigned int XUartLite_ReceiveBuffer(XUartLite *InstancePtr) { Xuint8 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/FIFO */ StatusRegister = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); /* 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++] = XIo_In32(InstancePtr->RegBaseAddress + XUL_RX_FIFO_OFFSET); XUartLite_mUpdateStats(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 = XUartLite_mGetStatusReg(InstancePtr->RegBaseAddress); XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, 0); /* 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->Stats.CharactersReceived += ReceivedCount; /* Restore the interrupt enable register to it's previous value such * that the critical region is exited */ StatusRegister &= XUL_CR_ENABLE_INTR; XIo_Out32(InstancePtr->RegBaseAddress + XUL_CONTROL_REG_OFFSET, StatusRegister); return ReceivedCount; }