Exemplo n.º 1
0
static void uart_irq_handler_cons(__unused enum irq_nr irqnr)
{
	const uint8_t uart = cons_get_uart();
	uint8_t iir;

	//uart_putchar_nb(uart, 'U');

	iir = uart_reg_read(uart, IIR);
	if (iir & IIR_INT_PENDING)
		return;

	switch (iir & IIR_INT_TYPE) {
	case IIR_INT_TYPE_RHR:
		break;
	case IIR_INT_TYPE_THR:
		if (cons_rb_flush() == 1) {
			/* everything was flushed, disable THR IRQ */
			uint8_t ier = uart_reg_read(uart, IER);
			ier &= ~(1 << 1);
			uart_reg_write(uart, IER, ier);
		}
		break;
	case IIR_INT_TYPE_MSR:
		break;
	case IIR_INT_TYPE_RX_STATUS_ERROR:
		break;
	case IIR_INT_TYPE_RX_TIMEOUT:
		break;
	case IIR_INT_TYPE_XOFF:
		break;
	}
}
Exemplo n.º 2
0
void uart_irq_enable(uint8_t uart, enum uart_irq irq, int on)
{
  uint8_t ier = uart_reg_read(uart, IER);
  uint8_t mask = 0;

  switch (irq)
    {
    case UART_IRQ_TX_EMPTY:
      mask = (1 << 1);
      break;

    case UART_IRQ_RX_CHAR:
      mask = (1 << 0);
      break;
    }

  if (on)
    {
      ier |= mask;
    }
  else
    {
      ier &= ~mask;
    }

  uart_reg_write(uart, IER, ier);
}
static void AthrUartPut(char __ch_data) {
	u32 rdata;

	do {
		rdata = uart_reg_read(UARTDATA_ADDRESS);
	} while (UARTDATA_UARTTXCSR_GET(rdata) == 0);

	rdata = UARTDATA_UARTTXRXDATA_SET((u32)__ch_data);
	rdata |= UARTDATA_UARTTXCSR_SET(1);

	uart_reg_write(UARTDATA_ADDRESS, rdata);
}
static int AthrUartGet(char *__ch_data) {
	u32 rdata;

	rdata = uart_reg_read(UARTDATA_ADDRESS);

	if (UARTDATA_UARTRXCSR_GET(rdata)) {
		*__ch_data = (char) UARTDATA_UARTTXRXDATA_GET(rdata);
		rdata = UARTDATA_UARTRXCSR_SET(1);
		uart_reg_write(UARTDATA_ADDRESS, rdata);
		return 1;
	} else {
		return 0;
	}
}
Exemplo n.º 5
0
u8 UartGetPoll(void)
{
	u8 ret_val;
	unsigned int rdata;

	do {
		rdata = uart_reg_read(UARTDATA_ADDRESS);
	} while (!UARTDATA_UARTRXCSR_GET(rdata));

	ret_val = (u8) UARTDATA_UARTTXRXDATA_GET(rdata);
	rdata = UARTDATA_UARTRXCSR_SET(1);
	uart_reg_write(UARTDATA_ADDRESS, rdata);

	return ret_val;
}
Exemplo n.º 6
0
static void uart_irq_handler_sercomm(__unused enum irq_nr irqnr)
{
	const uint8_t uart = sercomm_get_uart();
	uint8_t iir, ch;

	//uart_putchar_nb(uart, 'U');

	iir = uart_reg_read(uart, IIR);
	if (iir & IIR_INT_PENDING)
		return;

	switch (iir & IIR_INT_TYPE) {
	case IIR_INT_TYPE_RX_TIMEOUT:
	case IIR_INT_TYPE_RHR:
		/* as long as we have rx data available */
		while (uart_getchar_nb(uart, &ch)) {
			if (sercomm_drv_rx_char(ch) < 0) {
				/* sercomm cannot receive more data right now */
				uart_irq_enable(uart, UART_IRQ_RX_CHAR, 0);
			}
		}
		break;
	case IIR_INT_TYPE_THR:
		/* as long as we have space in the FIFO */
		while (!uart_tx_busy(uart)) {
			/* get a byte from sercomm */
			if (!sercomm_drv_pull(&ch)) {
				/* no more bytes in sercomm, stop TX interrupts */
				uart_irq_enable(uart, UART_IRQ_TX_EMPTY, 0);
				break;
			}
			/* write the byte into the TX FIFO */
			uart_putchar_nb(uart, ch);
		}
		break;
	case IIR_INT_TYPE_MSR:
		printf("UART IRQ MSR\n");
		break;
	case IIR_INT_TYPE_RX_STATUS_ERROR:
		printf("UART IRQ RX_SE\n");
		break;
	case IIR_INT_TYPE_XOFF:
		printf("UART IRQXOFF\n");
		break;
	}
}
Exemplo n.º 7
0
void UartPut(u8 byte)
{
	unsigned int rdata;

	if (!serial_inited) {
		serial_inited = 1;
		UartInit();
	}

	do {
		rdata = uart_reg_read(UARTDATA_ADDRESS);
	} while (UARTDATA_UARTTXCSR_GET(rdata) == 0);

	rdata = UARTDATA_UARTTXRXDATA_SET((unsigned int)byte);
	rdata |= UARTDATA_UARTTXCSR_SET(1);

	uart_reg_write(UARTDATA_ADDRESS, rdata);
}
int serial_tstc (void)
{
    return (UARTDATA_UARTRXCSR_GET(uart_reg_read(UARTDATA_ADDRESS)));
}