Lines Matching refs:port
122 struct uart_port port;
134 static int sprd_start_dma_rx(struct uart_port *port);
135 static int sprd_tx_dma_config(struct uart_port *port);
137 static inline unsigned int serial_in(struct uart_port *port,
140 return readl_relaxed(port->membase + offset);
143 static inline void serial_out(struct uart_port *port, unsigned int offset,
146 writel_relaxed(value, port->membase + offset);
149 static unsigned int sprd_tx_empty(struct uart_port *port)
151 if (serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
157 static unsigned int sprd_get_mctrl(struct uart_port *port)
162 static void sprd_set_mctrl(struct uart_port *port, unsigned int mctrl)
164 u32 val = serial_in(port, SPRD_CTL1);
171 serial_out(port, SPRD_CTL1, val);
174 static void sprd_stop_rx(struct uart_port *port)
177 container_of(port, struct sprd_uart_port, port);
183 iclr = serial_in(port, SPRD_ICLR);
184 ien = serial_in(port, SPRD_IEN);
189 serial_out(port, SPRD_IEN, ien);
190 serial_out(port, SPRD_ICLR, iclr);
193 static void sprd_uart_dma_enable(struct uart_port *port, bool enable)
195 u32 val = serial_in(port, SPRD_CTL1);
202 serial_out(port, SPRD_CTL1, val);
205 static void sprd_stop_tx_dma(struct uart_port *port)
208 container_of(port, struct sprd_uart_port, port);
209 struct circ_buf *xmit = &port->state->xmit;
219 port->icount.tx += trans_len;
220 dma_unmap_single(port->dev, sp->tx_dma.phys_addr,
228 static int sprd_tx_buf_remap(struct uart_port *port)
231 container_of(port, struct sprd_uart_port, port);
232 struct circ_buf *xmit = &port->state->xmit;
237 sp->tx_dma.phys_addr = dma_map_single(port->dev,
241 return dma_mapping_error(port->dev, sp->tx_dma.phys_addr);
246 struct uart_port *port = (struct uart_port *)data;
248 container_of(port, struct sprd_uart_port, port);
249 struct circ_buf *xmit = &port->state->xmit;
252 spin_lock_irqsave(&port->lock, flags);
253 dma_unmap_single(port->dev, sp->tx_dma.phys_addr,
257 port->icount.tx += sp->tx_dma.trans_len;
260 uart_write_wakeup(port);
262 if (uart_circ_empty(xmit) || sprd_tx_buf_remap(port) ||
263 sprd_tx_dma_config(port))
266 spin_unlock_irqrestore(&port->lock, flags);
269 static int sprd_uart_dma_submit(struct uart_port *port,
288 dma_des->callback_param = port;
299 static int sprd_tx_dma_config(struct uart_port *port)
302 container_of(port, struct sprd_uart_port, port);
307 .dst_addr = port->mapbase + SPRD_TXD,
317 return sprd_uart_dma_submit(port, &sp->tx_dma, sp->tx_dma.trans_len,
321 static void sprd_start_tx_dma(struct uart_port *port)
324 container_of(port, struct sprd_uart_port, port);
325 struct circ_buf *xmit = &port->state->xmit;
327 if (port->x_char) {
328 serial_out(port, SPRD_TXD, port->x_char);
329 port->icount.tx++;
330 port->x_char = 0;
334 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
335 sprd_stop_tx_dma(port);
342 if (sprd_tx_buf_remap(port) || sprd_tx_dma_config(port))
346 static void sprd_rx_full_thld(struct uart_port *port, u32 thld)
348 u32 val = serial_in(port, SPRD_CTL2);
352 serial_out(port, SPRD_CTL2, val);
357 sp->rx_dma.virt = dma_alloc_coherent(sp->port.dev, SPRD_UART_RX_SIZE,
368 dma_free_coherent(sp->port.dev, SPRD_UART_RX_SIZE,
373 static int sprd_rx_dma_config(struct uart_port *port, u32 burst)
376 container_of(port, struct sprd_uart_port, port);
378 .src_addr = port->mapbase + SPRD_RXD,
387 static void sprd_uart_dma_rx(struct uart_port *port)
390 container_of(port, struct sprd_uart_port, port);
391 struct tty_port *tty = &port->state->port;
393 port->icount.rx += sp->rx_dma.trans_len;
398 static void sprd_uart_dma_irq(struct uart_port *port)
401 container_of(port, struct sprd_uart_port, port);
408 sprd_stop_rx(port);
422 sprd_uart_dma_rx(port);
428 struct uart_port *port = (struct uart_port *)data;
430 container_of(port, struct sprd_uart_port, port);
435 spin_lock_irqsave(&port->lock, flags);
440 sprd_stop_rx(port);
441 spin_unlock_irqrestore(&port->lock, flags);
448 sprd_uart_dma_rx(port);
452 if (sprd_start_dma_rx(port))
453 sprd_stop_rx(port);
455 spin_unlock_irqrestore(&port->lock, flags);
458 static int sprd_start_dma_rx(struct uart_port *port)
461 container_of(port, struct sprd_uart_port, port);
469 sprd_rx_full_thld(port, SPRD_RX_FIFO_FULL);
470 ret = sprd_rx_dma_config(port, SPRD_RX_DMA_STEP);
474 return sprd_uart_dma_submit(port, &sp->rx_dma, SPRD_UART_RX_SIZE,
478 static void sprd_release_dma(struct uart_port *port)
481 container_of(port, struct sprd_uart_port, port);
483 sprd_uart_dma_enable(port, false);
495 static void sprd_request_dma(struct uart_port *port)
498 container_of(port, struct sprd_uart_port, port);
503 sp->tx_dma.chn = dma_request_chan(port->dev, "tx");
505 dev_err(port->dev, "request TX DMA channel failed, ret = %ld\n",
510 sp->rx_dma.chn = dma_request_chan(port->dev, "rx");
512 dev_err(port->dev, "request RX DMA channel failed, ret = %ld\n",
518 static void sprd_stop_tx(struct uart_port *port)
520 struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
521 port);
525 sprd_stop_tx_dma(port);
529 iclr = serial_in(port, SPRD_ICLR);
530 ien = serial_in(port, SPRD_IEN);
535 serial_out(port, SPRD_IEN, ien);
536 serial_out(port, SPRD_ICLR, iclr);
539 static void sprd_start_tx(struct uart_port *port)
541 struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
542 port);
546 sprd_start_tx_dma(port);
550 ien = serial_in(port, SPRD_IEN);
553 serial_out(port, SPRD_IEN, ien);
558 static void sprd_break_ctl(struct uart_port *port, int break_state)
563 static int handle_lsr_errors(struct uart_port *port,
572 port->icount.brk++;
573 ret = uart_handle_break(port);
577 port->icount.parity++;
579 port->icount.frame++;
581 port->icount.overrun++;
584 *lsr &= port->read_status_mask;
595 static inline void sprd_rx(struct uart_port *port)
597 struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
598 port);
599 struct tty_port *tty = &port->state->port;
603 sprd_uart_dma_irq(port);
607 while ((serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK) &&
609 lsr = serial_in(port, SPRD_LSR);
610 ch = serial_in(port, SPRD_RXD);
612 port->icount.rx++;
616 if (handle_lsr_errors(port, &flag, &lsr))
618 if (uart_handle_sysrq_char(port, ch))
621 uart_insert_char(port, lsr, SPRD_LSR_OE, ch, flag);
627 static inline void sprd_tx(struct uart_port *port)
629 struct circ_buf *xmit = &port->state->xmit;
632 if (port->x_char) {
633 serial_out(port, SPRD_TXD, port->x_char);
634 port->icount.tx++;
635 port->x_char = 0;
639 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
640 sprd_stop_tx(port);
646 serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]);
648 port->icount.tx++;
654 uart_write_wakeup(port);
657 sprd_stop_tx(port);
660 /* this handles the interrupt from one port */
663 struct uart_port *port = dev_id;
666 spin_lock(&port->lock);
668 ims = serial_in(port, SPRD_IMSR);
671 spin_unlock(&port->lock);
676 serial_out(port, SPRD_ICLR, SPRD_ICLR_TIMEOUT);
679 serial_out(port, SPRD_ICLR, SPRD_IMSR_BREAK_DETECT);
683 sprd_rx(port);
686 sprd_tx(port);
688 spin_unlock(&port->lock);
693 static void sprd_uart_dma_startup(struct uart_port *port,
698 sprd_request_dma(port);
702 ret = sprd_start_dma_rx(port);
706 dev_warn(port->dev, "fail to start RX dma mode\n");
709 sprd_uart_dma_enable(port, true);
712 static int sprd_startup(struct uart_port *port)
720 serial_out(port, SPRD_CTL2,
725 while (timeout-- && serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK)
726 serial_in(port, SPRD_RXD);
730 while (timeout-- && serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
734 serial_out(port, SPRD_IEN, 0);
735 serial_out(port, SPRD_ICLR, ~0);
738 sp = container_of(port, struct sprd_uart_port, port);
739 snprintf(sp->name, sizeof(sp->name), "sprd_serial%d", port->line);
741 sprd_uart_dma_startup(port, sp);
743 ret = devm_request_irq(port->dev, port->irq, sprd_handle_irq,
744 IRQF_SHARED, sp->name, port);
746 dev_err(port->dev, "fail to request serial irq %d, ret=%d\n",
747 port->irq, ret);
750 fc = serial_in(port, SPRD_CTL1);
752 serial_out(port, SPRD_CTL1, fc);
755 spin_lock_irqsave(&port->lock, flags);
756 ien = serial_in(port, SPRD_IEN);
760 serial_out(port, SPRD_IEN, ien);
761 spin_unlock_irqrestore(&port->lock, flags);
766 static void sprd_shutdown(struct uart_port *port)
768 sprd_release_dma(port);
769 serial_out(port, SPRD_IEN, 0);
770 serial_out(port, SPRD_ICLR, ~0);
771 devm_free_irq(port->dev, port->irq, port);
774 static void sprd_set_termios(struct uart_port *port,
783 baud = uart_get_baud_rate(port, termios, old, 0, SPRD_BAUD_IO_LIMIT);
785 quot = port->uartclk / baud;
822 spin_lock_irqsave(&port->lock, flags);
824 /* update the per-port timeout */
825 uart_update_timeout(port, termios->c_cflag, baud);
827 port->read_status_mask = SPRD_LSR_OE;
829 port->read_status_mask |= SPRD_LSR_FE | SPRD_LSR_PE;
831 port->read_status_mask |= SPRD_LSR_BI;
834 port->ignore_status_mask = 0;
836 port->ignore_status_mask |= SPRD_LSR_PE | SPRD_LSR_FE;
838 port->ignore_status_mask |= SPRD_LSR_BI;
844 port->ignore_status_mask |= SPRD_LSR_OE;
848 fc = serial_in(port, SPRD_CTL1);
857 serial_out(port, SPRD_CLKD0, quot & SPRD_CLKD0_MASK);
860 serial_out(port, SPRD_CLKD1,
862 serial_out(port, SPRD_LCR, lcr);
864 serial_out(port, SPRD_CTL1, fc);
866 spin_unlock_irqrestore(&port->lock, flags);
873 static const char *sprd_type(struct uart_port *port)
878 static void sprd_release_port(struct uart_port *port)
883 static int sprd_request_port(struct uart_port *port)
888 static void sprd_config_port(struct uart_port *port, int flags)
891 port->type = PORT_SPRD;
894 static int sprd_verify_port(struct uart_port *port, struct serial_struct *ser)
898 if (port->irq != ser->irq)
900 if (port->iotype != ser->io_type)
905 static void sprd_pm(struct uart_port *port, unsigned int state,
909 container_of(port, struct sprd_uart_port, port);
922 static int sprd_poll_init(struct uart_port *port)
924 if (port->state->pm_state != UART_PM_STATE_ON) {
925 sprd_pm(port, UART_PM_STATE_ON, 0);
926 port->state->pm_state = UART_PM_STATE_ON;
932 static int sprd_poll_get_char(struct uart_port *port)
934 while (!(serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK))
937 return serial_in(port, SPRD_RXD);
940 static void sprd_poll_put_char(struct uart_port *port, unsigned char ch)
942 while (serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
945 serial_out(port, SPRD_TXD, ch);
974 static void wait_for_xmitr(struct uart_port *port)
980 status = serial_in(port, SPRD_STS1);
987 static void sprd_console_putchar(struct uart_port *port, int ch)
989 wait_for_xmitr(port);
990 serial_out(port, SPRD_TXD, ch);
996 struct uart_port *port = &sprd_port[co->index]->port;
1000 if (port->sysrq)
1003 locked = spin_trylock_irqsave(&port->lock, flags);
1005 spin_lock_irqsave(&port->lock, flags);
1007 uart_console_write(port, s, count, sprd_console_putchar);
1010 wait_for_xmitr(port);
1013 spin_unlock_irqrestore(&port->lock, flags);
1028 if (!sprd_uart_port || !sprd_uart_port->port.membase) {
1029 pr_info("serial port %d not yet initialized\n", co->index);
1036 return uart_set_options(&sprd_uart_port->port, co, baud,
1061 static void sprd_putc(struct uart_port *port, int c)
1066 !(readl(port->membase + SPRD_LSR) & SPRD_LSR_TX_OVER))
1069 writeb(c, port->membase + SPRD_TXD);
1076 uart_console_write(&dev->port, s, n, sprd_putc);
1082 if (!device->port.membase)
1110 uart_remove_one_port(&sprd_uart_driver, &sup->port);
1111 sprd_port[sup->port.line] = NULL;
1136 struct sprd_uart_port *u = container_of(uport, struct sprd_uart_port, port);
1194 up = &sport->port;
1262 uart_suspend_port(&sprd_uart_driver, &sup->port);
1271 uart_resume_port(&sprd_uart_driver, &sup->port);