Lines Matching refs:port
117 struct uart_port port;
121 #define to_rda_uart_port(port) container_of(port, struct rda_uart_port, port)
125 static inline void rda_uart_write(struct uart_port *port, u32 val,
128 writel(val, port->membase + off);
131 static inline u32 rda_uart_read(struct uart_port *port, unsigned int off)
133 return readl(port->membase + off);
136 static unsigned int rda_uart_tx_empty(struct uart_port *port)
142 spin_lock_irqsave(&port->lock, flags);
144 val = rda_uart_read(port, RDA_UART_STATUS);
147 spin_unlock_irqrestore(&port->lock, flags);
152 static unsigned int rda_uart_get_mctrl(struct uart_port *port)
157 cmd_set = rda_uart_read(port, RDA_UART_CMD_SET);
158 status = rda_uart_read(port, RDA_UART_STATUS);
167 static void rda_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
172 val = rda_uart_read(port, RDA_UART_CMD_SET);
173 rda_uart_write(port, (val | RDA_UART_RTS), RDA_UART_CMD_SET);
176 val = rda_uart_read(port, RDA_UART_CMD_CLR);
177 rda_uart_write(port, (val | RDA_UART_RTS), RDA_UART_CMD_CLR);
180 val = rda_uart_read(port, RDA_UART_CTRL);
187 rda_uart_write(port, val, RDA_UART_CTRL);
190 static void rda_uart_stop_tx(struct uart_port *port)
194 val = rda_uart_read(port, RDA_UART_IRQ_MASK);
196 rda_uart_write(port, val, RDA_UART_IRQ_MASK);
198 val = rda_uart_read(port, RDA_UART_CMD_SET);
200 rda_uart_write(port, val, RDA_UART_CMD_SET);
203 static void rda_uart_stop_rx(struct uart_port *port)
207 val = rda_uart_read(port, RDA_UART_IRQ_MASK);
209 rda_uart_write(port, val, RDA_UART_IRQ_MASK);
212 val = rda_uart_read(port, RDA_UART_RXTX_BUFFER);
214 val = rda_uart_read(port, RDA_UART_CMD_SET);
216 rda_uart_write(port, val, RDA_UART_CMD_SET);
219 static void rda_uart_start_tx(struct uart_port *port)
223 if (uart_tx_stopped(port)) {
224 rda_uart_stop_tx(port);
228 val = rda_uart_read(port, RDA_UART_IRQ_MASK);
230 rda_uart_write(port, val, RDA_UART_IRQ_MASK);
239 static void rda_uart_set_termios(struct uart_port *port,
243 struct rda_uart_port *rda_port = to_rda_uart_port(port);
249 spin_lock_irqsave(&port->lock, flags);
251 baud = uart_get_baud_rate(port, termios, old, 9600, port->uartclk / 4);
254 ctrl = rda_uart_read(port, RDA_UART_CTRL);
255 cmd_set = rda_uart_read(port, RDA_UART_CMD_SET);
256 cmd_clr = rda_uart_read(port, RDA_UART_CMD_CLR);
261 dev_warn(port->dev, "bit size not supported, using 7 bits\n");
311 irq_mask = rda_uart_read(port, RDA_UART_IRQ_MASK);
312 rda_uart_write(port, 0, RDA_UART_IRQ_MASK);
314 rda_uart_write(port, triggers, RDA_UART_IRQ_TRIGGERS);
315 rda_uart_write(port, ctrl, RDA_UART_CTRL);
316 rda_uart_write(port, cmd_set, RDA_UART_CMD_SET);
317 rda_uart_write(port, cmd_clr, RDA_UART_CMD_CLR);
319 rda_uart_write(port, irq_mask, RDA_UART_IRQ_MASK);
325 /* update the per-port timeout */
326 uart_update_timeout(port, termios->c_cflag, baud);
328 spin_unlock_irqrestore(&port->lock, flags);
331 static void rda_uart_send_chars(struct uart_port *port)
333 struct circ_buf *xmit = &port->state->xmit;
337 if (uart_tx_stopped(port))
340 if (port->x_char) {
341 while (!(rda_uart_read(port, RDA_UART_STATUS) &
345 rda_uart_write(port, port->x_char, RDA_UART_RXTX_BUFFER);
346 port->icount.tx++;
347 port->x_char = 0;
350 while (rda_uart_read(port, RDA_UART_STATUS) & RDA_UART_TX_FIFO_MASK) {
355 rda_uart_write(port, ch, RDA_UART_RXTX_BUFFER);
356 uart_xmit_advance(port, 1);
360 uart_write_wakeup(port);
364 val = rda_uart_read(port, RDA_UART_IRQ_MASK);
366 rda_uart_write(port, val, RDA_UART_IRQ_MASK);
370 static void rda_uart_receive_chars(struct uart_port *port)
374 status = rda_uart_read(port, RDA_UART_STATUS);
379 port->icount.parity++;
384 port->icount.frame++;
389 port->icount.overrun++;
393 val = rda_uart_read(port, RDA_UART_RXTX_BUFFER);
396 port->icount.rx++;
397 tty_insert_flip_char(&port->state->port, val, flag);
399 status = rda_uart_read(port, RDA_UART_STATUS);
402 tty_flip_buffer_push(&port->state->port);
407 struct uart_port *port = dev_id;
411 spin_lock_irqsave(&port->lock, flags);
414 val = rda_uart_read(port, RDA_UART_IRQ_CAUSE);
415 rda_uart_write(port, val, RDA_UART_IRQ_CAUSE);
418 rda_uart_receive_chars(port);
421 irq_mask = rda_uart_read(port, RDA_UART_IRQ_MASK);
423 rda_uart_write(port, irq_mask, RDA_UART_IRQ_MASK);
425 rda_uart_send_chars(port);
428 spin_unlock_irqrestore(&port->lock, flags);
433 static int rda_uart_startup(struct uart_port *port)
439 spin_lock_irqsave(&port->lock, flags);
440 rda_uart_write(port, 0, RDA_UART_IRQ_MASK);
441 spin_unlock_irqrestore(&port->lock, flags);
443 ret = request_irq(port->irq, rda_interrupt, IRQF_NO_SUSPEND,
444 "rda-uart", port);
448 spin_lock_irqsave(&port->lock, flags);
450 val = rda_uart_read(port, RDA_UART_CTRL);
452 rda_uart_write(port, val, RDA_UART_CTRL);
455 val = rda_uart_read(port, RDA_UART_IRQ_MASK);
457 rda_uart_write(port, val, RDA_UART_IRQ_MASK);
459 spin_unlock_irqrestore(&port->lock, flags);
464 static void rda_uart_shutdown(struct uart_port *port)
469 spin_lock_irqsave(&port->lock, flags);
471 rda_uart_stop_tx(port);
472 rda_uart_stop_rx(port);
474 val = rda_uart_read(port, RDA_UART_CTRL);
476 rda_uart_write(port, val, RDA_UART_CTRL);
478 spin_unlock_irqrestore(&port->lock, flags);
481 static const char *rda_uart_type(struct uart_port *port)
483 return (port->type == PORT_RDA) ? "rda-uart" : NULL;
486 static int rda_uart_request_port(struct uart_port *port)
488 struct platform_device *pdev = to_platform_device(port->dev);
495 if (!devm_request_mem_region(port->dev, port->mapbase,
496 resource_size(res), dev_name(port->dev)))
499 if (port->flags & UPF_IOREMAP) {
500 port->membase = devm_ioremap(port->dev, port->mapbase,
502 if (!port->membase)
509 static void rda_uart_config_port(struct uart_port *port, int flags)
514 port->type = PORT_RDA;
515 rda_uart_request_port(port);
518 spin_lock_irqsave(&port->lock, irq_flags);
521 rda_uart_write(port, 0, RDA_UART_IRQ_MASK);
524 rda_uart_write(port, 0, RDA_UART_STATUS);
526 spin_unlock_irqrestore(&port->lock, irq_flags);
529 static void rda_uart_release_port(struct uart_port *port)
531 struct platform_device *pdev = to_platform_device(port->dev);
538 if (port->flags & UPF_IOREMAP) {
539 devm_release_mem_region(port->dev, port->mapbase,
541 devm_iounmap(port->dev, port->membase);
542 port->membase = NULL;
546 static int rda_uart_verify_port(struct uart_port *port,
549 if (port->type != PORT_RDA)
552 if (port->irq != ser->irq)
577 static void rda_console_putchar(struct uart_port *port, unsigned char ch)
579 if (!port->membase)
582 while (!(rda_uart_read(port, RDA_UART_STATUS) & RDA_UART_TX_FIFO_MASK))
585 rda_uart_write(port, ch, RDA_UART_RXTX_BUFFER);
588 static void rda_uart_port_write(struct uart_port *port, const char *s,
597 if (port->sysrq) {
600 locked = spin_trylock(&port->lock);
602 spin_lock(&port->lock);
606 old_irq_mask = rda_uart_read(port, RDA_UART_IRQ_MASK);
607 rda_uart_write(port, 0, RDA_UART_IRQ_MASK);
609 uart_console_write(port, s, count, rda_console_putchar);
612 while (!(rda_uart_read(port, RDA_UART_STATUS) & RDA_UART_TX_FIFO_MASK))
615 rda_uart_write(port, old_irq_mask, RDA_UART_IRQ_MASK);
618 spin_unlock(&port->lock);
632 rda_uart_port_write(&rda_port->port, s, count);
647 if (!rda_port || !rda_port->port.membase)
653 return uart_set_options(&rda_port->port, co, baud, parity, bits, flow);
680 rda_uart_port_write(&dev->port, s, count);
686 if (!device->port.membase)
741 dev_err(&pdev->dev, "port %d already allocated\n", pdev->id);
755 rda_port->port.dev = &pdev->dev;
756 rda_port->port.regshift = 0;
757 rda_port->port.line = pdev->id;
758 rda_port->port.type = PORT_RDA;
759 rda_port->port.iotype = UPIO_MEM;
760 rda_port->port.mapbase = res_mem->start;
761 rda_port->port.irq = irq;
762 rda_port->port.uartclk = clk_get_rate(rda_port->clk);
763 if (rda_port->port.uartclk == 0) {
767 rda_port->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP |
769 rda_port->port.x_char = 0;
770 rda_port->port.fifosize = RDA_UART_TX_FIFO_SIZE;
771 rda_port->port.ops = &rda_uart_ops;
776 ret = uart_add_one_port(&rda_uart_driver, &rda_port->port);
787 uart_remove_one_port(&rda_uart_driver, &rda_port->port);