Lines Matching +full:mux +full:- +full:int +full:- +full:port
1 // SPDX-License-Identifier: GPL-2.0-only
4 * 8250-core based driver for Broadcom ns16550a UARTs
8 * mux for more accurate high speed baud rate selection and also
20 #include <linux/dma-mapping.h>
158 #define UDMA_RX_BUFS_REG_OFFSET (UDMA_RX_BUF1_PTR_LO - UDMA_RX_BUF0_PTR_LO)
170 #define UDMA_TX_BUFS_REG_OFFSET (UDMA_TX_BUF1_PTR_LO - UDMA_TX_BUF0_PTR_LO)
207 int line;
222 int rx_next_buf;
248 int reg_type, int offset)
250 return readl(priv->regs[reg_type] + offset);
254 int reg_type, int offset, u32 value)
256 writel(value, priv->regs[reg_type] + offset);
260 int reg_type, int offset, u32 bits)
262 void __iomem *reg = priv->regs[reg_type] + offset;
271 int reg_type, int offset, u32 bits)
273 void __iomem *reg = priv->regs[reg_type] + offset;
287 static int brcmuart_arbitration(struct brcmuart_priv *priv, bool acquire)
291 int waits;
292 int ret = 0;
304 if (waits-- == 0)
320 int x;
338 daddr = priv->rx_addr;
351 daddr = priv->tx_addr;
368 struct brcmuart_priv *priv = p->port.private_data;
369 int x;
381 priv->rx_next_buf = 0;
384 priv->rx_running = true;
389 struct brcmuart_priv *priv = p->port.private_data;
392 if (priv->rx_running)
396 static int stop_tx_dma(struct uart_8250_port *p)
398 struct brcmuart_priv *priv = p->port.private_data;
405 priv->tx_running = false;
413 static int brcmuart_tx_dma(struct uart_8250_port *p)
415 struct brcmuart_priv *priv = p->port.private_data;
416 struct tty_port *tport = &p->port.state->port;
419 if (uart_tx_stopped(&p->port) || priv->tx_running ||
420 kfifo_is_empty(&tport->xmit_fifo)) {
424 priv->dma.tx_err = 0;
425 tx_size = uart_fifo_out(&p->port, priv->tx_buf, UART_XMIT_SIZE);
427 if (kfifo_len(&tport->xmit_fifo) < WAKEUP_CHARS)
428 uart_write_wakeup(&p->port);
434 priv->tx_running = true;
439 static void brcmuart_rx_buf_done_isr(struct uart_port *up, int index)
441 struct brcmuart_priv *priv = up->private_data;
442 struct tty_port *tty_port = &up->state->port;
452 dev_err(up->dev, "RX done interrupt but DATA_RDY not found\n");
459 up->icount.overrun++;
460 dev_warn(up->dev, "RX OVERRUN Error\n");
463 up->icount.frame++;
464 dev_warn(up->dev, "RX FRAMING Error\n");
467 up->icount.parity++;
468 dev_warn(up->dev, "RX PARITY Error\n");
473 priv->rx_bufs + (index * RX_BUF_SIZE),
476 dev_warn(up->dev, "Flip buffer overrun of %d bytes\n",
477 length - copied);
478 up->icount.overrun += length - copied;
480 up->icount.rx += length;
482 priv->dma_rx_partial_buf++;
488 priv->rx_missing_close_timeout++;
490 priv->dma_rx_full_buf++;
497 struct brcmuart_priv *priv = up->private_data;
498 struct device *dev = up->dev;
504 check_isr = UDMA_INTR_RX_READY_BUF0 << priv->rx_next_buf;
506 brcmuart_rx_buf_done_isr(up, priv->rx_next_buf);
515 priv->rx_err++;
517 priv->rx_timeout++;
521 priv->rx_abort++;
522 priv->rx_running = false;
524 /* If not ABORT, re-enable RX buffer */
527 UDMA_RX_BUFx_STATUS(priv->rx_next_buf),
530 priv->rx_next_buf++;
531 if (priv->rx_next_buf == RX_BUFS_COUNT)
532 priv->rx_next_buf = 0;
538 struct brcmuart_priv *priv = up->private_data;
539 struct device *dev = up->dev;
541 struct tty_port *tport = &port_8250->port.state->port;
544 if (priv->tx_running)
548 priv->tx_running = false;
549 if (!kfifo_is_empty(&tport->xmit_fifo) && !uart_tx_stopped(up))
553 static irqreturn_t brcmuart_isr(int irq, void *dev_id)
556 struct device *dev = up->dev;
557 struct brcmuart_priv *priv = up->private_data;
585 static int brcmuart_startup(struct uart_port *port)
587 int res;
588 struct uart_8250_port *up = up_to_u8250p(port);
589 struct brcmuart_priv *priv = up->port.private_data;
591 priv->shutdown = false;
594 * prevent serial8250_do_startup() from allocating non-existent
597 up->dma = NULL;
599 res = serial8250_do_startup(port);
600 if (!priv->dma_enabled)
608 uart_port_lock_irq(port);
609 up->ier &= ~UART_IER_RDI;
610 serial_port_out(port, UART_IER, up->ier);
611 uart_port_unlock_irq(port);
613 priv->tx_running = false;
614 priv->dma.rx_dma = NULL;
615 priv->dma.tx_dma = brcmuart_tx_dma;
616 up->dma = &priv->dma;
623 static void brcmuart_shutdown(struct uart_port *port)
625 struct uart_8250_port *up = up_to_u8250p(port);
626 struct brcmuart_priv *priv = up->port.private_data;
629 uart_port_lock_irqsave(port, &flags);
630 priv->shutdown = true;
631 if (priv->dma_enabled) {
643 up->dma = NULL;
645 uart_port_unlock_irqrestore(port, flags);
646 serial8250_do_shutdown(port);
655 int x;
656 int rc;
658 priv->default_mux_rate = clk_get_rate(priv->baud_mux_clk);
659 for (x = 0; x < ARRAY_SIZE(priv->real_rates); x++) {
660 if (priv->rate_table[x] == 0) {
661 priv->real_rates[x] = 0;
664 rc = clk_set_rate(priv->baud_mux_clk, priv->rate_table[x]);
666 dev_err(dev, "Error selecting BAUD MUX clock for %u\n",
667 priv->rate_table[x]);
668 priv->real_rates[x] = priv->rate_table[x];
670 priv->real_rates[x] = clk_get_rate(priv->baud_mux_clk);
673 clk_set_rate(priv->baud_mux_clk, priv->default_mux_rate);
695 hires_err = (hires_rate - hires_baud);
697 hires_err = (hires_baud - hires_rate);
701 dev_dbg(dev, "Baud rate: %u, MUX Clk: %u, Error: %u.%u%%\n",
716 int rc;
717 int i;
718 int real_baud;
720 /* If the Baud Mux Clock was not specified, just return */
721 if (priv->baud_mux_clk == NULL)
725 quot = find_quot(up->dev, priv->default_mux_rate, baud, &percent);
728 best_freq = priv->default_mux_rate;
733 for (i = 0; i < ARRAY_SIZE(priv->real_rates); i++) {
734 freq = priv->real_rates[i];
735 if (freq == 0 || freq == priv->default_mux_rate)
737 quot = find_quot(up->dev, freq, baud, &percent);
749 dev_err(up->dev, "Error, %d BAUD rate is too fast.\n", baud);
752 rc = clk_set_rate(priv->baud_mux_clk, best_freq);
754 dev_err(up->dev, "Error selecting BAUD MUX clock\n");
758 dev_err(up->dev, "Error, baud: %d has %u.%u%% error\n",
762 dev_dbg(up->dev, "Selecting BAUD MUX rate: %u\n", best_freq);
763 dev_dbg(up->dev, "Requested baud: %u, Actual baud: %u\n",
769 priv->char_wait = ns_to_ktime(i);
771 up->uartclk = best_freq;
779 struct brcmuart_priv *priv = up->private_data;
781 if (priv->dma_enabled)
785 if (p8250->mcr & UART_MCR_AFE)
786 p8250->port.status |= UPSTAT_AUTOCTS;
787 if (priv->dma_enabled)
791 static int brcmuart_handle_irq(struct uart_port *p)
793 unsigned int iir = serial_port_in(p, UART_IIR);
794 struct brcmuart_priv *priv = p->private_data;
796 unsigned int status;
798 unsigned int ier;
799 unsigned int mcr;
800 int handled = 0;
806 if (((iir & UART_IIR_ID) == UART_IIR_RX_TIMEOUT) && !(priv->shutdown)) {
818 if ((ier & UART_IER_RDI) && (up->mcr & UART_MCR_AFE)) {
824 hrtimer_start(&priv->hrt, priv->char_wait,
842 struct uart_port *p = priv->up;
844 unsigned int status;
847 if (priv->shutdown)
859 priv->rx_bad_timeout_no_char++;
861 priv->rx_bad_timeout_late_char++;
864 /* re-enable receive unless upper layer has disabled it */
865 if ((up->ier & (UART_IER_RLSI | UART_IER_RDI)) ==
880 .compatible = "brcm,bcm7278-uart",
884 .compatible = "brcm,bcm7271-uart",
894 if (priv->rx_bufs)
895 dma_free_coherent(dev, priv->rx_size, priv->rx_bufs,
896 priv->rx_addr);
897 if (priv->tx_buf)
898 dma_free_coherent(dev, priv->tx_size, priv->tx_buf,
899 priv->tx_addr);
902 static void brcmuart_throttle(struct uart_port *port)
904 struct brcmuart_priv *priv = port->private_data;
909 static void brcmuart_unthrottle(struct uart_port *port)
911 struct brcmuart_priv *priv = port->private_data;
917 static int debugfs_stats_show(struct seq_file *s, void *unused)
919 struct brcmuart_priv *priv = s->private;
922 priv->rx_err);
924 priv->rx_timeout);
926 priv->rx_abort);
928 priv->rx_bad_timeout_late_char);
930 priv->rx_bad_timeout_no_char);
932 priv->rx_missing_close_timeout);
933 if (priv->dma_enabled) {
935 priv->dma_rx_partial_buf);
937 priv->dma_rx_full_buf);
946 priv->debugfs_dir = debugfs_create_dir(device, brcmuart_debugfs_root);
947 debugfs_create_file("stats", 0444, priv->debugfs_dir, priv,
952 static int brcmuart_probe(struct platform_device *pdev)
957 struct device *dev = &pdev->dev;
963 int ret;
964 int x;
965 int dma_irq;
973 return -ENOMEM;
975 of_id = of_match_node(brcmuart_dt_ids, dev->of_node);
976 if (!of_id || !of_id->data)
977 priv->rate_table = brcmstb_rate_table;
979 priv->rate_table = of_id->data;
986 priv->regs[x] = devm_ioremap(dev, regs->start,
988 if (!priv->regs[x])
989 return -ENOMEM;
991 mapbase = regs->start;
992 membase = priv->regs[x];
998 return dev_err_probe(dev, -EINVAL, "%s registers not specified\n",
1013 priv->dma_enabled = true;
1025 dev_dbg(dev, "DMA is %senabled\n", priv->dma_enabled ? "" : "not ");
1028 up.port.type = PORT_BCM7271;
1029 up.port.dev = dev;
1030 up.port.mapbase = mapbase;
1031 up.port.membase = membase;
1032 up.port.handle_irq = brcmuart_handle_irq;
1033 up.port.flags = UPF_BOOT_AUTOCONF | UPF_FIXED_PORT | UPF_FIXED_TYPE;
1034 up.port.private_data = priv;
1036 ret = uart_read_port_properties(&up.port);
1040 up.port.regshift = 2;
1041 up.port.iotype = device_is_big_endian(dev) ? UPIO_MEM32BE : UPIO_MEM32;
1049 dev_dbg(dev, "BAUD MUX clock found\n");
1051 priv->baud_mux_clk = baud_mux_clk;
1053 up.port.uartclk = priv->default_mux_rate;
1055 dev_dbg(dev, "BAUD MUX clock not specified\n");
1059 hrtimer_setup(&priv->hrt, brcmuart_hrtimer_func, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1061 up.port.shutdown = brcmuart_shutdown;
1062 up.port.startup = brcmuart_startup;
1063 up.port.throttle = brcmuart_throttle;
1064 up.port.unthrottle = brcmuart_unthrottle;
1065 up.port.set_termios = brcmstb_set_termios;
1067 if (priv->dma_enabled) {
1068 priv->rx_size = RX_BUF_SIZE * RX_BUFS_COUNT;
1069 priv->rx_bufs = dma_alloc_coherent(dev,
1070 priv->rx_size,
1071 &priv->rx_addr, GFP_KERNEL);
1072 if (!priv->rx_bufs) {
1073 ret = -ENOMEM;
1076 priv->tx_size = UART_XMIT_SIZE;
1077 priv->tx_buf = dma_alloc_coherent(dev,
1078 priv->tx_size,
1079 &priv->tx_addr, GFP_KERNEL);
1080 if (!priv->tx_buf) {
1081 ret = -ENOMEM;
1088 dev_err_probe(dev, ret, "unable to register 8250 port\n");
1091 priv->line = ret;
1093 priv->up = &new_port->port;
1094 if (priv->dma_enabled) {
1101 IRQF_SHARED, "uart DMA irq", &new_port->port);
1108 brcmuart_init_debugfs(priv, dev_name(&pdev->dev));
1112 serial8250_unregister_port(priv->line);
1116 if (priv->dma_enabled)
1125 debugfs_remove_recursive(priv->debugfs_dir);
1126 hrtimer_cancel(&priv->hrt);
1127 serial8250_unregister_port(priv->line);
1128 brcmuart_free_bufs(&pdev->dev, priv);
1129 if (priv->dma_enabled)
1133 static int __maybe_unused brcmuart_suspend(struct device *dev)
1136 struct uart_8250_port *up = serial8250_get_port(priv->line);
1137 struct uart_port *port = &up->port;
1144 uart_port_lock_irqsave(port, &flags);
1145 priv->saved_mctrl = port->mctrl;
1146 port->mctrl &= ~TIOCM_RTS;
1147 uart_port_unlock_irqrestore(port, flags);
1149 serial8250_suspend_port(priv->line);
1150 clk_disable_unprepare(priv->baud_mux_clk);
1155 static int __maybe_unused brcmuart_resume(struct device *dev)
1158 struct uart_8250_port *up = serial8250_get_port(priv->line);
1159 struct uart_port *port = &up->port;
1161 int ret;
1163 ret = clk_prepare_enable(priv->baud_mux_clk);
1165 dev_err(dev, "Error enabling BAUD MUX clock\n");
1171 ret = clk_set_rate(priv->baud_mux_clk, priv->default_mux_rate);
1173 dev_err(dev, "Error restoring default BAUD MUX clock\n");
1174 if (priv->dma_enabled) {
1177 return(-EBUSY);
1180 start_rx_dma(serial8250_get_port(priv->line));
1182 serial8250_resume_port(priv->line);
1184 if (priv->saved_mctrl & TIOCM_RTS) {
1186 uart_port_lock_irqsave(port, &flags);
1187 port->mctrl |= TIOCM_RTS;
1188 port->ops->set_mctrl(port, port->mctrl);
1189 uart_port_unlock_irqrestore(port, flags);
1201 .name = "bcm7271-uart",
1209 static int __init brcmuart_init(void)
1211 int ret;
1233 MODULE_DESCRIPTION("Broadcom NS16550A compatible serial port driver");