Quelle  rsci.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2025 Renesas Electronics Corp.
 */

#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/serial_core.h>
#include <linux/serial_sci.h>
#include <linux/tty_flip.h>
#include "rsci.h"

MODULE_IMPORT_NS("SH_SCI");

/* RSCI registers */
#define RDR 0x00
#define TDR 0x04
#define CCR0 0x08
#define CCR1 0x0C
#define CCR2 0x10
#define CCR3 0x14
#define CCR4 0x18
#define FCR 0x24
#define DCR 0x30
#define CSR 0x48
#define FRSR 0x50
#define FTSR 0x54
#define CFCLR 0x68
#define FFCLR 0x70

/* RDR (Receive Data Register) */
#define RDR_FFER  BIT(12) /* FIFO Framing Error */
#define RDR_FPER  BIT(11) /* FIFO Parity Error */
#define RDR_RDAT_MSK  GENMASK(8, 0)

/* TDR (Transmit Data Register) */
#define TDR_MPBT  BIT(9) /* Multiprocessor Transfer */
#define TDR_TDAT_9BIT_LSHIFT 0
#define TDR_TDAT_9BIT_VAL 0x1FF
#define TDR_TDAT_9BIT_MSK (TDR_TDAT_9BIT_VAL << TDR_TDAT_9BIT_LSHIFT)

/* CCR0 (Common Control Register 0) */
#define CCR0_SSE  BIT(24) /* SSn# Pin Function Enable */
#define CCR0_TEIE  BIT(21) /* Transmit End Interrupt Enable */
#define CCR0_TIE  BIT(20) /* Transmit Interrupt Enable */
#define CCR0_RIE  BIT(16) /* Receive Interrupt Enable */
#define CCR0_IDSEL  BIT(10) /* ID Frame Select */
#define CCR0_DCME  BIT(9) /* Data Compare Match Enable */
#define CCR0_MPIE  BIT(8) /* Multiprocessor Interrupt Enable */
#define CCR0_TE   BIT(4) /* Transmit Enable */
#define CCR0_RE   BIT(0) /* Receive Enable */

/* CCR1 (Common Control Register 1) */
#define CCR1_NFEN  BIT(28) /* Digital Noise Filter Function */
#define CCR1_SHARPS  BIT(20) /* Half -duplex Communication Select */
#define CCR1_SPLP  BIT(16) /* Loopback Control */
#define CCR1_RINV  BIT(13) /* RxD invert */
#define CCR1_TINV  BIT(12) /* TxD invert */
#define CCR1_PM   BIT(9) /* Parity Mode */
#define CCR1_PE   BIT(8) /* Parity Enable */
#define CCR1_SPB2IO  BIT(5) /* Serial Port Break I/O */
#define CCR1_SPB2DT  BIT(4) /* Serial Port Break Data Select */
#define CCR1_CTSPEN  BIT(1) /* CTS External Pin Enable */
#define CCR1_CTSE  BIT(0) /* CTS Enable */

/* FCR (FIFO Control Register) */
#define FCR_RFRST  BIT(23) /* Receive FIFO Data Register Reset */
#define FCR_TFRST  BIT(15) /* Transmit FIFO Data Register Reset */
#define FCR_DRES  BIT(0) /* Incoming Data Ready Error Select */
#define FCR_RTRG4_0  GENMASK(20, 16)
#define FCR_TTRG  GENMASK(12, 8)

/* CSR (Common Status Register) */
#define CSR_RDRF  BIT(31) /* Receive Data Full */
#define CSR_TEND  BIT(30) /* Transmit End Flag */
#define CSR_TDRE  BIT(29) /* Transmit Data Empty */
#define CSR_FER   BIT(28) /* Framing Error */
#define CSR_PER   BIT(27) /* Parity Error */
#define CSR_MFF   BIT(26) /* Mode Fault Error */
#define CSR_ORER  BIT(24) /* Overrun Error */
#define CSR_DFER  BIT(18) /* Data Compare Match Framing Error */
#define CSR_DPER  BIT(17) /* Data Compare Match Parity Error */
#define CSR_DCMF  BIT(16) /* Data Compare Match */
#define CSR_RXDMON  BIT(15) /* Serial Input Data Monitor */
#define CSR_ERS   BIT(4) /* Error Signal Status */

#define SCxSR_ERRORS(port) (to_sci_port(port)->params->error_mask)
#define SCxSR_ERROR_CLEAR(port) (to_sci_port(port)->params->error_clear)

#define RSCI_DEFAULT_ERROR_MASK (CSR_PER | CSR_FER)

#define RSCI_RDxF_CLEAR  (CFCLR_RDRFC)
#define RSCI_ERROR_CLEAR (CFCLR_PERC | CFCLR_FERC)
#define RSCI_TDxE_CLEAR  (CFCLR_TDREC)
#define RSCI_BREAK_CLEAR (CFCLR_PERC | CFCLR_FERC | CFCLR_ORERC)

/* FRSR (FIFO Receive Status Register) */
#define FRSR_R5_0  GENMASK(13, 8) /* Receive FIFO Data Count */
#define FRSR_DR   BIT(0) /* Receive Data Ready */

/* CFCLR (Common Flag CLear Register) */
#define CFCLR_RDRFC  BIT(31) /* RDRF Clear */
#define CFCLR_TDREC  BIT(29) /* TDRE Clear */
#define CFCLR_FERC  BIT(28) /* FER Clear */
#define CFCLR_PERC  BIT(27) /* PER Clear */
#define CFCLR_MFFC  BIT(26) /* MFF Clear */
#define CFCLR_ORERC  BIT(24) /* ORER Clear */
#define CFCLR_DFERC  BIT(18) /* DFER Clear */
#define CFCLR_DPERC  BIT(17) /* DPER Clear */
#define CFCLR_DCMFC  BIT(16) /* DCMF Clear */
#define CFCLR_ERSC  BIT(4) /* ERS Clear */
#define CFCLR_CLRFLAG  (CFCLR_RDRFC | CFCLR_FERC | CFCLR_PERC | \
     CFCLR_MFFC | CFCLR_ORERC | CFCLR_DFERC | \
     CFCLR_DPERC | CFCLR_DCMFC | CFCLR_ERSC)

/* FFCLR (FIFO Flag CLear Register) */
#define FFCLR_DRC  BIT(0) /* DR Clear */

#define DCR_DEPOL  BIT(0)

static u32 rsci_serial_in(struct uart_port *p, int offset)
{
 return readl(p->membase + offset);
}

static void rsci_serial_out(struct uart_port *p, int offset, int value)
{
 writel(value, p->membase + offset);
}

static void rsci_clear_DRxC(struct uart_port *port)
{
 rsci_serial_out(port, CFCLR, CFCLR_RDRFC);
 rsci_serial_out(port, FFCLR, FFCLR_DRC);
}

static void rsci_clear_SCxSR(struct uart_port *port, unsigned int mask)
{
 rsci_serial_out(port, CFCLR, mask);
}

static void rsci_start_rx(struct uart_port *port)
{
 unsigned int ctrl;

 ctrl = rsci_serial_in(port, CCR0);
 ctrl |= CCR0_RIE;
 rsci_serial_out(port, CCR0, ctrl);
}

static void rsci_set_termios(struct uart_port *port, struct ktermios *termios,
        const struct ktermios *old)
{
 struct sci_port *s = to_sci_port(port);
 unsigned long flags;

 sci_port_enable(s);
 uart_port_lock_irqsave(port, &flags);

 /* For now, only RX enabling is supported */
 if (termios->c_cflag & CREAD)
  rsci_start_rx(port);

 uart_port_unlock_irqrestore(port, flags);
 sci_port_disable(s);
}

static int rsci_txfill(struct uart_port *port)
{
 return rsci_serial_in(port, FTSR);
}

static int rsci_rxfill(struct uart_port *port)
{
 u32 val = rsci_serial_in(port, FRSR);

 return FIELD_GET(FRSR_R5_0, val);
}

static unsigned int rsci_tx_empty(struct uart_port *port)
{
 unsigned int status = rsci_serial_in(port, CSR);
 unsigned int in_tx_fifo = rsci_txfill(port);

 return (status & CSR_TEND) && !in_tx_fifo ? TIOCSER_TEMT : 0;
}

static void rsci_set_mctrl(struct uart_port *port, unsigned int mctrl)
{
 /* Not supported yet */
}

static unsigned int rsci_get_mctrl(struct uart_port *port)
{
 /* Not supported yet */
 return 0;
}

static void rsci_clear_CFC(struct uart_port *port, unsigned int mask)
{
 rsci_serial_out(port, CFCLR, mask);
}

static void rsci_start_tx(struct uart_port *port)
{
 struct sci_port *sp = to_sci_port(port);
 u32 ctrl;

 if (sp->chan_tx)
  return;

 /*
 * TE (Transmit Enable) must be set after setting TIE
 * (Transmit Interrupt Enable) or in the same instruction
 * to start the transmit process.
 */
 ctrl = rsci_serial_in(port, CCR0);
 ctrl |= CCR0_TIE | CCR0_TE;
 rsci_serial_out(port, CCR0, ctrl);
}

static void rsci_stop_tx(struct uart_port *port)
{
 u32 ctrl;

 ctrl = rsci_serial_in(port, CCR0);
 ctrl &= ~CCR0_TIE;
 rsci_serial_out(port, CCR0, ctrl);
}

static void rsci_stop_rx(struct uart_port *port)
{
 u32 ctrl;

 ctrl = rsci_serial_in(port, CCR0);
 ctrl &= ~CCR0_RIE;
 rsci_serial_out(port, CCR0, ctrl);
}

static int rsci_txroom(struct uart_port *port)
{
 return port->fifosize - rsci_txfill(port);
}

static void rsci_transmit_chars(struct uart_port *port)
{
 unsigned int stopped = uart_tx_stopped(port);
 struct tty_port *tport = &port->state->port;
 u32 status, ctrl;
 int count;

 status = rsci_serial_in(port, CSR);
 if (!(status & CSR_TDRE)) {
  ctrl = rsci_serial_in(port, CCR0);
  if (kfifo_is_empty(&tport->xmit_fifo))
   ctrl &= ~CCR0_TIE;
  else
   ctrl |= CCR0_TIE;
  rsci_serial_out(port, CCR0, ctrl);
  return;
 }

 count = rsci_txroom(port);

 do {
  unsigned char c;

  if (port->x_char) {
   c = port->x_char;
   port->x_char = 0;
  } else if (stopped || !kfifo_get(&tport->xmit_fifo, &c)) {
   break;
  }

  rsci_clear_CFC(port, CFCLR_TDREC);
  rsci_serial_out(port, TDR, c);

  port->icount.tx++;
 } while (--count > 0);

 if (kfifo_len(&tport->xmit_fifo) < WAKEUP_CHARS)
  uart_write_wakeup(port);

 if (kfifo_is_empty(&tport->xmit_fifo)) {
  ctrl = rsci_serial_in(port, CCR0);
  ctrl &= ~CCR0_TIE;
  ctrl |= CCR0_TEIE;
  rsci_serial_out(port, CCR0, ctrl);
 }
}

static void rsci_receive_chars(struct uart_port *port)
{
 struct tty_port *tport = &port->state->port;
 u32 rdat, status, frsr_status = 0;
 int i, count, copied = 0;
 unsigned char flag;

 status = rsci_serial_in(port, CSR);
 frsr_status = rsci_serial_in(port, FRSR);

 if (!(status & CSR_RDRF) && !(frsr_status & FRSR_DR))
  return;

 while (1) {
  /* Don't copy more bytes than there is room for in the buffer */
  count = tty_buffer_request_room(tport, rsci_rxfill(port));

  /* If for any reason we can't copy more data, we're done! */
  if (count == 0)
   break;

  for (i = 0; i < count; i++) {
   char c;

   rdat = rsci_serial_in(port, RDR);
   /* 9-bits data is not supported yet */
   c = rdat & RDR_RDAT_MSK;

   if (uart_handle_sysrq_char(port, c)) {
    count--;
    i--;
    continue;
   }

   /* Store data and status.
 * Non FIFO mode is not supported
 */
   if (rdat & RDR_FFER) {
    flag = TTY_FRAME;
    port->icount.frame++;
   } else if (rdat & RDR_FPER) {
    flag = TTY_PARITY;
    port->icount.parity++;
   } else {
    flag = TTY_NORMAL;
   }

   tty_insert_flip_char(tport, c, flag);
  }

  rsci_serial_in(port, CSR); /* dummy read */
  rsci_clear_DRxC(port);

  copied += count;
  port->icount.rx += count;
 }

 if (copied) {
  /* Tell the rest of the system the news. New characters! */
  tty_flip_buffer_push(tport);
 } else {
  /* TTY buffers full; read from RX reg to prevent lockup */
  rsci_serial_in(port, RDR);
  rsci_serial_in(port, CSR); /* dummy read */
  rsci_clear_DRxC(port);
 }
}

static void rsci_poll_put_char(struct uart_port *port, unsigned char c)
{
 u32 status;
 int ret;

 ret = readl_relaxed_poll_timeout_atomic(port->membase + CSR, status,
      (status & CSR_TDRE), 100,
      USEC_PER_SEC);
 if (ret != 0) {
  dev_err(port->dev,
   "Error while sending data in UART TX : %d\n", ret);
  goto done;
 }
 rsci_serial_out(port, TDR, c);
done:
 rsci_clear_SCxSR(port, CFCLR_TDREC);
}

static void rsci_prepare_console_write(struct uart_port *port, u32 ctrl)
{
 struct sci_port *s = to_sci_port(port);
 u32 ctrl_temp =
  s->params->param_bits->rxtx_enable | CCR0_TIE |
  s->hscif_tot;
 rsci_serial_out(port, CCR0, ctrl_temp);
}

static const char *rsci_type(struct uart_port *port)
{
 return "rsci";
}

static size_t rsci_suspend_regs_size(void)
{
 return 0;
}

static void rsci_shutdown_complete(struct uart_port *port)
{
 /*
 * Stop RX and TX, disable related interrupts, keep clock source
 */
 rsci_serial_out(port, CCR0, 0);
}

static const struct sci_common_regs rsci_common_regs = {
 .status = CSR,
 .control = CCR0,
};

static const struct sci_port_params_bits rsci_port_param_bits = {
 .rxtx_enable = CCR0_RE | CCR0_TE,
 .te_clear = CCR0_TE | CCR0_TEIE,
 .poll_sent_bits = CSR_TDRE | CSR_TEND,
};

static const struct sci_port_params rsci_port_params = {
 .fifosize = 16,
 .overrun_reg = CSR,
 .overrun_mask = CSR_ORER,
 .sampling_rate_mask = SCI_SR(32),
 .error_mask = RSCI_DEFAULT_ERROR_MASK,
 .error_clear = RSCI_ERROR_CLEAR,
 .param_bits = &rsci_port_param_bits,
 .common_regs = &rsci_common_regs,
};

static const struct uart_ops rsci_uart_ops = {
 .tx_empty = rsci_tx_empty,
 .set_mctrl = rsci_set_mctrl,
 .get_mctrl = rsci_get_mctrl,
 .start_tx = rsci_start_tx,
 .stop_tx = rsci_stop_tx,
 .stop_rx = rsci_stop_rx,
 .startup = sci_startup,
 .shutdown = sci_shutdown,
 .set_termios = rsci_set_termios,
 .pm  = sci_pm,
 .type  = rsci_type,
 .release_port = sci_release_port,
 .request_port = sci_request_port,
 .config_port = sci_config_port,
 .verify_port = sci_verify_port,
};

static const struct sci_port_ops rsci_port_ops = {
 .read_reg  = rsci_serial_in,
 .write_reg  = rsci_serial_out,
 .clear_SCxSR  = rsci_clear_SCxSR,
 .transmit_chars  = rsci_transmit_chars,
 .receive_chars  = rsci_receive_chars,
 .poll_put_char  = rsci_poll_put_char,
 .prepare_console_write = rsci_prepare_console_write,
 .suspend_regs_size = rsci_suspend_regs_size,
 .shutdown_complete = rsci_shutdown_complete,
};

struct sci_of_data of_sci_rsci_data = {
 .type = SCI_PORT_RSCI,
 .ops = &rsci_port_ops,
 .uart_ops = &rsci_uart_ops,
 .params = &rsci_port_params,
};

#ifdef CONFIG_SERIAL_SH_SCI_EARLYCON

static int __init rsci_early_console_setup(struct earlycon_device *device,
        const char *opt)
{
 return scix_early_console_setup(device, &of_sci_rsci_data);
}

OF_EARLYCON_DECLARE(rsci, "renesas,r9a09g077-rsci", rsci_early_console_setup);

#endif /* CONFIG_SERIAL_SH_SCI_EARLYCON */

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("RSCI serial driver");