leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tty/serial: at91: remove bunch of macros to access UART registers

Browse Source 
This patch replaces the UART_PUT_*, resp. UART_GET_*, macros by
atmel_uart_writel(), resp. atmel_uart_readl(), inline function calls.

Signed-off-by: Cyrille Pitchen <cyrille.pitchen@atmel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Cyrille Pitchen 2015-07-02 15:18:11 +02:00 committed by Greg Kroah-Hartman
parent 3fad386014
commit 4e7decdaaa
1 changed files with 159 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

313
drivers/tty/serial/atmel_serial.c
View File

@ -88,37 +88,6 @@ static void atmel_stop_rx(struct uart_port *port);
#define ATMEL_ISR_PASS_LIMIT 256 #define ATMEL_ISR_PASS_LIMIT 256
/* UART registers. CR is write-only, hence no GET macro */
#define UART_PUT_CR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_CR)
#define UART_GET_MR(port) __raw_readl((port)->membase + ATMEL_US_MR)
#define UART_PUT_MR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_MR)
#define UART_PUT_IER(port,v) __raw_writel(v, (port)->membase + ATMEL_US_IER)
#define UART_PUT_IDR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_IDR)
#define UART_GET_IMR(port) __raw_readl((port)->membase + ATMEL_US_IMR)
#define UART_GET_CSR(port) __raw_readl((port)->membase + ATMEL_US_CSR)
#define UART_GET_CHAR(port) __raw_readl((port)->membase + ATMEL_US_RHR)
#define UART_PUT_CHAR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_THR)
#define UART_GET_BRGR(port) __raw_readl((port)->membase + ATMEL_US_BRGR)
#define UART_PUT_BRGR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_BRGR)
#define UART_PUT_RTOR(port,v) __raw_writel(v, (port)->membase + ATMEL_US_RTOR)
#define UART_PUT_TTGR(port, v) __raw_writel(v, (port)->membase + ATMEL_US_TTGR)
#define UART_GET_IP_NAME(port) __raw_readl((port)->membase + ATMEL_US_NAME)
#define UART_GET_IP_VERSION(port) __raw_readl((port)->membase + ATMEL_US_VERSION)
/* PDC registers */
#define UART_PUT_PTCR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_PTCR)
#define UART_GET_PTSR(port) __raw_readl((port)->membase + ATMEL_PDC_PTSR)
#define UART_PUT_RPR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_RPR)
#define UART_GET_RPR(port) __raw_readl((port)->membase + ATMEL_PDC_RPR)
#define UART_PUT_RCR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_RCR)
#define UART_PUT_RNPR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_RNPR)
#define UART_PUT_RNCR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_RNCR)
#define UART_PUT_TPR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_TPR)
#define UART_PUT_TCR(port,v) __raw_writel(v, (port)->membase + ATMEL_PDC_TCR)
#define UART_GET_TCR(port) __raw_readl((port)->membase + ATMEL_PDC_TCR)
struct atmel_dma_buffer { struct atmel_dma_buffer {
unsigned char *buf; unsigned char *buf;
dma_addr_t dma_addr; dma_addr_t dma_addr;
@ -212,6 +181,16 @@ to_atmel_uart_port(struct uart_port *uart)
return container_of(uart, struct atmel_uart_port, uart); return container_of(uart, struct atmel_uart_port, uart);
} }
static inline u32 atmel_uart_readl(struct uart_port *port, u32 reg)
{
return __raw_readl(port->membase + reg);
}
static inline void atmel_uart_writel(struct uart_port *port, u32 reg, u32 value)
{
__raw_writel(value, port->membase + reg);
}
#ifdef CONFIG_SERIAL_ATMEL_PDC #ifdef CONFIG_SERIAL_ATMEL_PDC
static bool atmel_use_pdc_rx(struct uart_port *port) static bool atmel_use_pdc_rx(struct uart_port *port)
{ {
@ -257,7 +236,7 @@ static unsigned int atmel_get_lines_status(struct uart_port *port)
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
unsigned int status, ret = 0; unsigned int status, ret = 0;
status = UART_GET_CSR(port); status = atmel_uart_readl(port, ATMEL_US_CSR);
mctrl_gpio_get(atmel_port->gpios, &ret); mctrl_gpio_get(atmel_port->gpios, &ret);
@ -304,9 +283,9 @@ static int atmel_config_rs485(struct uart_port *port,
unsigned int mode; unsigned int mode;
/* Disable interrupts */ /* Disable interrupts */
UART_PUT_IDR(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IDR, atmel_port->tx_done_mask);
mode = UART_GET_MR(port); mode = atmel_uart_readl(port, ATMEL_US_MR);
/* Resetting serial mode to RS232 (0x0) */ /* Resetting serial mode to RS232 (0x0) */
mode &= ~ATMEL_US_USMODE; mode &= ~ATMEL_US_USMODE;
@ -316,7 +295,8 @@ static int atmel_config_rs485(struct uart_port *port,
if (rs485conf->flags & SER_RS485_ENABLED) { if (rs485conf->flags & SER_RS485_ENABLED) {
dev_dbg(port->dev, "Setting UART to RS485\n"); dev_dbg(port->dev, "Setting UART to RS485\n");
atmel_port->tx_done_mask = ATMEL_US_TXEMPTY; atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;
UART_PUT_TTGR(port, rs485conf->delay_rts_after_send); atmel_uart_writel(port, ATMEL_US_TTGR,
rs485conf->delay_rts_after_send);
mode |= ATMEL_US_USMODE_RS485; mode |= ATMEL_US_USMODE_RS485;
} else { } else {
dev_dbg(port->dev, "Setting UART to RS232\n"); dev_dbg(port->dev, "Setting UART to RS232\n");
@ -326,10 +306,10 @@ static int atmel_config_rs485(struct uart_port *port,
else else
atmel_port->tx_done_mask = ATMEL_US_TXRDY; atmel_port->tx_done_mask = ATMEL_US_TXRDY;
} }
UART_PUT_MR(port, mode); atmel_uart_writel(port, ATMEL_US_MR, mode);
/* Enable interrupts */ /* Enable interrupts */
UART_PUT_IER(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IER, atmel_port->tx_done_mask);
return 0; return 0;
} }
@ -339,7 +319,9 @@ static int atmel_config_rs485(struct uart_port *port,
*/ */
static u_int atmel_tx_empty(struct uart_port *port) static u_int atmel_tx_empty(struct uart_port *port)
{ {
return (UART_GET_CSR(port) & ATMEL_US_TXEMPTY) ? TIOCSER_TEMT : 0; return (atmel_uart_readl(port, ATMEL_US_CSR) & ATMEL_US_TXEMPTY) ?
TIOCSER_TEMT :
0;
} }
/* /*
@ -348,13 +330,14 @@ static u_int atmel_tx_empty(struct uart_port *port)
static void atmel_set_mctrl(struct uart_port *port, u_int mctrl) static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
{ {
unsigned int control = 0; unsigned int control = 0;
unsigned int mode = UART_GET_MR(port); unsigned int mode = atmel_uart_readl(port, ATMEL_US_MR);
unsigned int rts_paused, rts_ready; unsigned int rts_paused, rts_ready;
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
/* override mode to RS485 if needed, otherwise keep the current mode */ /* override mode to RS485 if needed, otherwise keep the current mode */
if (port->rs485.flags & SER_RS485_ENABLED) { if (port->rs485.flags & SER_RS485_ENABLED) {
UART_PUT_TTGR(port, port->rs485.delay_rts_after_send); atmel_uart_writel(port, ATMEL_US_TTGR,
port->rs485.delay_rts_after_send);
mode &= ~ATMEL_US_USMODE; mode &= ~ATMEL_US_USMODE;
mode |= ATMEL_US_USMODE_RS485; mode |= ATMEL_US_USMODE_RS485;
} }
@ -384,7 +367,7 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
else else
control |= ATMEL_US_DTRDIS; control |= ATMEL_US_DTRDIS;
UART_PUT_CR(port, control); atmel_uart_writel(port, ATMEL_US_CR, control);
mctrl_gpio_set(atmel_port->gpios, mctrl); mctrl_gpio_set(atmel_port->gpios, mctrl);
@ -395,7 +378,7 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
else else
mode |= ATMEL_US_CHMODE_NORMAL; mode |= ATMEL_US_CHMODE_NORMAL;
UART_PUT_MR(port, mode); atmel_uart_writel(port, ATMEL_US_MR, mode);
} }
/* /*
@ -406,7 +389,7 @@ static u_int atmel_get_mctrl(struct uart_port *port)
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
unsigned int ret = 0, status; unsigned int ret = 0, status;
status = UART_GET_CSR(port); status = atmel_uart_readl(port, ATMEL_US_CSR);
/* /*
* The control signals are active low. * The control signals are active low.
@ -432,10 +415,10 @@ static void atmel_stop_tx(struct uart_port *port)
if (atmel_use_pdc_tx(port)) { if (atmel_use_pdc_tx(port)) {
/* disable PDC transmit */ /* disable PDC transmit */
UART_PUT_PTCR(port, ATMEL_PDC_TXTDIS); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTDIS);
} }
/* Disable interrupts */ /* Disable interrupts */
UART_PUT_IDR(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IDR, atmel_port->tx_done_mask);
if ((port->rs485.flags & SER_RS485_ENABLED) && if ((port->rs485.flags & SER_RS485_ENABLED) &&
!(port->rs485.flags & SER_RS485_RX_DURING_TX)) !(port->rs485.flags & SER_RS485_RX_DURING_TX))
@ -450,7 +433,7 @@ static void atmel_start_tx(struct uart_port *port)
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
if (atmel_use_pdc_tx(port)) { if (atmel_use_pdc_tx(port)) {
if (UART_GET_PTSR(port) & ATMEL_PDC_TXTEN) if (atmel_uart_readl(port, ATMEL_PDC_PTSR) & ATMEL_PDC_TXTEN)
/* The transmitter is already running. Yes, we /* The transmitter is already running. Yes, we
really need this.*/ really need this.*/
return; return;
@ -460,10 +443,10 @@ static void atmel_start_tx(struct uart_port *port)
atmel_stop_rx(port); atmel_stop_rx(port);
/* re-enable PDC transmit */ /* re-enable PDC transmit */
UART_PUT_PTCR(port, ATMEL_PDC_TXTEN); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTEN);
} }
/* Enable interrupts */ /* Enable interrupts */
UART_PUT_IER(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IER, atmel_port->tx_done_mask);
} }
/* /*
@ -471,17 +454,19 @@ static void atmel_start_tx(struct uart_port *port)
*/ */
static void atmel_start_rx(struct uart_port *port) static void atmel_start_rx(struct uart_port *port)
{ {
UART_PUT_CR(port, ATMEL_US_RSTSTA); /* reset status and receiver */ /* reset status and receiver */
atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA);
UART_PUT_CR(port, ATMEL_US_RXEN); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RXEN);
if (atmel_use_pdc_rx(port)) { if (atmel_use_pdc_rx(port)) {
/* enable PDC controller */ /* enable PDC controller */
UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT | atmel_uart_writel(port, ATMEL_US_IER,
port->read_status_mask); ATMEL_US_ENDRX | ATMEL_US_TIMEOUT |
UART_PUT_PTCR(port, ATMEL_PDC_RXTEN); port->read_status_mask);
atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_RXTEN);
} else { } else {
UART_PUT_IER(port, ATMEL_US_RXRDY); atmel_uart_writel(port, ATMEL_US_IER, ATMEL_US_RXRDY);
} }
} }
@ -490,15 +475,16 @@ static void atmel_start_rx(struct uart_port *port)
*/ */
static void atmel_stop_rx(struct uart_port *port) static void atmel_stop_rx(struct uart_port *port)
{ {
UART_PUT_CR(port, ATMEL_US_RXDIS); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RXDIS);
if (atmel_use_pdc_rx(port)) { if (atmel_use_pdc_rx(port)) {
/* disable PDC receive */ /* disable PDC receive */
UART_PUT_PTCR(port, ATMEL_PDC_RXTDIS); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_RXTDIS);
UART_PUT_IDR(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT | atmel_uart_writel(port, ATMEL_US_IDR,
port->read_status_mask); ATMEL_US_ENDRX | ATMEL_US_TIMEOUT |
port->read_status_mask);
} else { } else {
UART_PUT_IDR(port, ATMEL_US_RXRDY); atmel_uart_writel(port, ATMEL_US_IDR, ATMEL_US_RXRDY);
} }
} }
@ -538,7 +524,7 @@ static void atmel_enable_ms(struct uart_port *port)
else else
ier |= ATMEL_US_DCDIC; ier |= ATMEL_US_DCDIC;
UART_PUT_IER(port, ier); atmel_uart_writel(port, ATMEL_US_IER, ier);
} }
/* /*
@ -577,7 +563,7 @@ static void atmel_disable_ms(struct uart_port *port)
else else
idr |= ATMEL_US_DCDIC; idr |= ATMEL_US_DCDIC;
UART_PUT_IDR(port, idr); atmel_uart_writel(port, ATMEL_US_IDR, idr);
} }
/* /*
@ -586,9 +572,11 @@ static void atmel_disable_ms(struct uart_port *port)
static void atmel_break_ctl(struct uart_port *port, int break_state) static void atmel_break_ctl(struct uart_port *port, int break_state)
{ {
if (break_state != 0) if (break_state != 0)
UART_PUT_CR(port, ATMEL_US_STTBRK); /* start break */ /* start break */
atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STTBRK);
else else
UART_PUT_CR(port, ATMEL_US_STPBRK); /* stop break */ /* stop break */
atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STPBRK);
} }
/* /*
@ -622,7 +610,7 @@ atmel_buffer_rx_char(struct uart_port *port, unsigned int status,
static void atmel_pdc_rxerr(struct uart_port *port, unsigned int status) static void atmel_pdc_rxerr(struct uart_port *port, unsigned int status)
{ {
/* clear error */ /* clear error */
UART_PUT_CR(port, ATMEL_US_RSTSTA); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA);
if (status & ATMEL_US_RXBRK) { if (status & ATMEL_US_RXBRK) {
/* ignore side-effect */ /* ignore side-effect */
@ -645,9 +633,9 @@ static void atmel_rx_chars(struct uart_port *port)
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
unsigned int status, ch; unsigned int status, ch;
status = UART_GET_CSR(port); status = atmel_uart_readl(port, ATMEL_US_CSR);
while (status & ATMEL_US_RXRDY) { while (status & ATMEL_US_RXRDY) {
ch = UART_GET_CHAR(port); ch = atmel_uart_readl(port, ATMEL_US_RHR);
/* /*
* note that the error handling code is * note that the error handling code is
@ -658,12 +646,13 @@ static void atmel_rx_chars(struct uart_port *port)
|| atmel_port->break_active)) { || atmel_port->break_active)) {
/* clear error */ /* clear error */
UART_PUT_CR(port, ATMEL_US_RSTSTA); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA);
if (status & ATMEL_US_RXBRK if (status & ATMEL_US_RXBRK
&& !atmel_port->break_active) { && !atmel_port->break_active) {
atmel_port->break_active = 1; atmel_port->break_active = 1;
UART_PUT_IER(port, ATMEL_US_RXBRK); atmel_uart_writel(port, ATMEL_US_IER,
ATMEL_US_RXBRK);
} else { } else {
/* /*
* This is either the end-of-break * This is either the end-of-break
@ -672,14 +661,15 @@ static void atmel_rx_chars(struct uart_port *port)
* being set. In both cases, the next * being set. In both cases, the next
* RXBRK will indicate start-of-break. * RXBRK will indicate start-of-break.
*/ */
UART_PUT_IDR(port, ATMEL_US_RXBRK); atmel_uart_writel(port, ATMEL_US_IDR,
ATMEL_US_RXBRK);
status &= ~ATMEL_US_RXBRK; status &= ~ATMEL_US_RXBRK;
atmel_port->break_active = 0; atmel_port->break_active = 0;
} }
} }
atmel_buffer_rx_char(port, status, ch); atmel_buffer_rx_char(port, status, ch);
status = UART_GET_CSR(port); status = atmel_uart_readl(port, ATMEL_US_CSR);
} }
tasklet_schedule(&atmel_port->tasklet); tasklet_schedule(&atmel_port->tasklet);
@ -694,16 +684,18 @@ static void atmel_tx_chars(struct uart_port *port)
struct circ_buf *xmit = &port->state->xmit; struct circ_buf *xmit = &port->state->xmit;
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
if (port->x_char && UART_GET_CSR(port) & atmel_port->tx_done_mask) { if (port->x_char &&
UART_PUT_CHAR(port, port->x_char); (atmel_uart_readl(port, ATMEL_US_CSR) & atmel_port->tx_done_mask)) {
atmel_uart_writel(port, ATMEL_US_THR, port->x_char);
port->icount.tx++; port->icount.tx++;
port->x_char = 0; port->x_char = 0;
} }
if (uart_circ_empty(xmit) || uart_tx_stopped(port)) if (uart_circ_empty(xmit) || uart_tx_stopped(port))
return; return;
while (UART_GET_CSR(port) & atmel_port->tx_done_mask) { while (atmel_uart_readl(port, ATMEL_US_CSR) &
UART_PUT_CHAR(port, xmit->buf[xmit->tail]); atmel_port->tx_done_mask) {
atmel_uart_writel(port, ATMEL_US_THR, xmit->buf[xmit->tail]);
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
port->icount.tx++; port->icount.tx++;
if (uart_circ_empty(xmit)) if (uart_circ_empty(xmit))
@ -715,7 +707,8 @@ static void atmel_tx_chars(struct uart_port *port)
if (!uart_circ_empty(xmit)) if (!uart_circ_empty(xmit))
/* Enable interrupts */ /* Enable interrupts */
UART_PUT_IER(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IER,
atmel_port->tx_done_mask);
} }
static void atmel_complete_tx_dma(void *arg) static void atmel_complete_tx_dma(void *arg)
@ -935,14 +928,14 @@ static void atmel_rx_from_dma(struct uart_port *port)
/* Reset the UART timeout early so that we don't miss one */ /* Reset the UART timeout early so that we don't miss one */
UART_PUT_CR(port, ATMEL_US_STTTO); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STTTO);
dmastat = dmaengine_tx_status(chan, dmastat = dmaengine_tx_status(chan,
atmel_port->cookie_rx, atmel_port->cookie_rx,
&state); &state);
/* Restart a new tasklet if DMA status is error */ /* Restart a new tasklet if DMA status is error */
if (dmastat == DMA_ERROR) { if (dmastat == DMA_ERROR) {
dev_dbg(port->dev, "Get residue error, restart tasklet\n"); dev_dbg(port->dev, "Get residue error, restart tasklet\n");
UART_PUT_IER(port, ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IER, ATMEL_US_TIMEOUT);
tasklet_schedule(&atmel_port->tasklet); tasklet_schedule(&atmel_port->tasklet);
return; return;
} }
@ -1008,7 +1001,7 @@ static void atmel_rx_from_dma(struct uart_port *port)
tty_flip_buffer_push(tport); tty_flip_buffer_push(tport);
spin_lock(&port->lock); spin_lock(&port->lock);
UART_PUT_IER(port, ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IER, ATMEL_US_TIMEOUT);
} }
static int atmel_prepare_rx_dma(struct uart_port *port) static int atmel_prepare_rx_dma(struct uart_port *port)
@ -1118,8 +1111,8 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)
* the moment. * the moment.
*/ */
if (pending & (ATMEL_US_ENDRX | ATMEL_US_TIMEOUT)) { if (pending & (ATMEL_US_ENDRX | ATMEL_US_TIMEOUT)) {
UART_PUT_IDR(port, (ATMEL_US_ENDRX atmel_uart_writel(port, ATMEL_US_IDR,
| ATMEL_US_TIMEOUT)); (ATMEL_US_ENDRX | ATMEL_US_TIMEOUT));
tasklet_schedule(&atmel_port->tasklet); tasklet_schedule(&atmel_port->tasklet);
} }
@ -1130,7 +1123,8 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)
if (atmel_use_dma_rx(port)) { if (atmel_use_dma_rx(port)) {
if (pending & ATMEL_US_TIMEOUT) { if (pending & ATMEL_US_TIMEOUT) {
UART_PUT_IDR(port, ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IDR,
ATMEL_US_TIMEOUT);
tasklet_schedule(&atmel_port->tasklet); tasklet_schedule(&atmel_port->tasklet);
} }
} }
@ -1143,8 +1137,8 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)
* End of break detected. If it came along with a * End of break detected. If it came along with a
* character, atmel_rx_chars will handle it. * character, atmel_rx_chars will handle it.
*/ */
UART_PUT_CR(port, ATMEL_US_RSTSTA); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA);
UART_PUT_IDR(port, ATMEL_US_RXBRK); atmel_uart_writel(port, ATMEL_US_IDR, ATMEL_US_RXBRK);
atmel_port->break_active = 0; atmel_port->break_active = 0;
} }
} }
@ -1159,7 +1153,8 @@ atmel_handle_transmit(struct uart_port *port, unsigned int pending)
if (pending & atmel_port->tx_done_mask) { if (pending & atmel_port->tx_done_mask) {
/* Either PDC or interrupt transmission */ /* Either PDC or interrupt transmission */
UART_PUT_IDR(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IDR,
atmel_port->tx_done_mask);
tasklet_schedule(&atmel_port->tasklet); tasklet_schedule(&atmel_port->tasklet);
} }
} }
@ -1197,7 +1192,7 @@ static irqreturn_t atmel_interrupt(int irq, void *dev_id)
do { do {
status = atmel_get_lines_status(port); status = atmel_get_lines_status(port);
mask = UART_GET_IMR(port); mask = atmel_uart_readl(port, ATMEL_US_IMR);
pending = status & mask; pending = status & mask;
if (!gpio_handled) { if (!gpio_handled) {
/* /*
@ -1223,7 +1218,7 @@ static irqreturn_t atmel_interrupt(int irq, void *dev_id)
if (atmel_port->suspended) { if (atmel_port->suspended) {
atmel_port->pending |= pending; atmel_port->pending |= pending;
atmel_port->pending_status = status; atmel_port->pending_status = status;
UART_PUT_IDR(port, mask); atmel_uart_writel(port, ATMEL_US_IDR, mask);
pm_system_wakeup(); pm_system_wakeup();
break; break;
} }
@ -1260,7 +1255,7 @@ static void atmel_tx_pdc(struct uart_port *port)
int count; int count;
/* nothing left to transmit? */ /* nothing left to transmit? */
if (UART_GET_TCR(port)) if (atmel_uart_readl(port, ATMEL_PDC_TCR))
return; return;
xmit->tail += pdc->ofs; xmit->tail += pdc->ofs;
@ -1272,7 +1267,7 @@ static void atmel_tx_pdc(struct uart_port *port)
/* more to transmit - setup next transfer */ /* more to transmit - setup next transfer */
/* disable PDC transmit */ /* disable PDC transmit */
UART_PUT_PTCR(port, ATMEL_PDC_TXTDIS); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTDIS);
if (!uart_circ_empty(xmit) && !uart_tx_stopped(port)) { if (!uart_circ_empty(xmit) && !uart_tx_stopped(port)) {
dma_sync_single_for_device(port->dev, dma_sync_single_for_device(port->dev,
@ -1283,12 +1278,14 @@ static void atmel_tx_pdc(struct uart_port *port)
count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE); count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
pdc->ofs = count; pdc->ofs = count;
UART_PUT_TPR(port, pdc->dma_addr + xmit->tail); atmel_uart_writel(port, ATMEL_PDC_TPR,
UART_PUT_TCR(port, count); pdc->dma_addr + xmit->tail);
atmel_uart_writel(port, ATMEL_PDC_TCR, count);
/* re-enable PDC transmit */ /* re-enable PDC transmit */
UART_PUT_PTCR(port, ATMEL_PDC_TXTEN); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTEN);
/* Enable interrupts */ /* Enable interrupts */
UART_PUT_IER(port, atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IER,
atmel_port->tx_done_mask);
} else { } else {
if ((port->rs485.flags & SER_RS485_ENABLED) && if ((port->rs485.flags & SER_RS485_ENABLED) &&
!(port->rs485.flags & SER_RS485_RX_DURING_TX)) { !(port->rs485.flags & SER_RS485_RX_DURING_TX)) {
@ -1414,10 +1411,10 @@ static void atmel_rx_from_pdc(struct uart_port *port)
do { do {
/* Reset the UART timeout early so that we don't miss one */ /* Reset the UART timeout early so that we don't miss one */
UART_PUT_CR(port, ATMEL_US_STTTO); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STTTO);
pdc = &atmel_port->pdc_rx[rx_idx]; pdc = &atmel_port->pdc_rx[rx_idx];
head = UART_GET_RPR(port) - pdc->dma_addr; head = atmel_uart_readl(port, ATMEL_PDC_RPR) - pdc->dma_addr;
tail = pdc->ofs; tail = pdc->ofs;
/* If the PDC has switched buffers, RPR won't contain /* If the PDC has switched buffers, RPR won't contain
@ -1460,8 +1457,8 @@ static void atmel_rx_from_pdc(struct uart_port *port)
*/ */
if (head >= pdc->dma_size) { if (head >= pdc->dma_size) {
pdc->ofs = 0; pdc->ofs = 0;
UART_PUT_RNPR(port, pdc->dma_addr); atmel_uart_writel(port, ATMEL_PDC_RNPR, pdc->dma_addr);
UART_PUT_RNCR(port, pdc->dma_size); atmel_uart_writel(port, ATMEL_PDC_RNCR, pdc->dma_size);
rx_idx = !rx_idx; rx_idx = !rx_idx;
atmel_port->pdc_rx_idx = rx_idx; atmel_port->pdc_rx_idx = rx_idx;
@ -1476,7 +1473,8 @@ static void atmel_rx_from_pdc(struct uart_port *port)
tty_flip_buffer_push(tport); tty_flip_buffer_push(tport);
spin_lock(&port->lock); spin_lock(&port->lock);
UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IER,
ATMEL_US_ENDRX | ATMEL_US_TIMEOUT);
} }
static int atmel_prepare_rx_pdc(struct uart_port *port) static int atmel_prepare_rx_pdc(struct uart_port *port)
@ -1509,11 +1507,12 @@ static int atmel_prepare_rx_pdc(struct uart_port *port)
atmel_port->pdc_rx_idx = 0; atmel_port->pdc_rx_idx = 0;
UART_PUT_RPR(port, atmel_port->pdc_rx[0].dma_addr); atmel_uart_writel(port, ATMEL_PDC_RPR, atmel_port->pdc_rx[0].dma_addr);
UART_PUT_RCR(port, PDC_BUFFER_SIZE); atmel_uart_writel(port, ATMEL_PDC_RCR, PDC_BUFFER_SIZE);
UART_PUT_RNPR(port, atmel_port->pdc_rx[1].dma_addr); atmel_uart_writel(port, ATMEL_PDC_RNPR,
UART_PUT_RNCR(port, PDC_BUFFER_SIZE); atmel_port->pdc_rx[1].dma_addr);
atmel_uart_writel(port, ATMEL_PDC_RNCR, PDC_BUFFER_SIZE);
return 0; return 0;
} }
@ -1667,7 +1666,7 @@ static void atmel_set_ops(struct uart_port *port)
static void atmel_get_ip_name(struct uart_port *port) static void atmel_get_ip_name(struct uart_port *port)
{ {
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
int name = UART_GET_IP_NAME(port); int name = atmel_uart_readl(port, ATMEL_US_NAME);
u32 version; u32 version;
int usart, uart; int usart, uart;
/* usart and uart ascii */ /* usart and uart ascii */
@ -1684,7 +1683,7 @@ static void atmel_get_ip_name(struct uart_port *port)
atmel_port->is_usart = false; atmel_port->is_usart = false;
} else { } else {
/* fallback for older SoCs: use version field */ /* fallback for older SoCs: use version field */
version = UART_GET_IP_VERSION(port); version = atmel_uart_readl(port, ATMEL_US_VERSION);
switch (version) { switch (version) {
case 0x302: case 0x302:
case 0x10213: case 0x10213:
@ -1756,7 +1755,7 @@ static int atmel_startup(struct uart_port *port)
* request_irq() is called we could get stuck trying to * request_irq() is called we could get stuck trying to
* handle an unexpected interrupt * handle an unexpected interrupt
*/ */
UART_PUT_IDR(port, -1); atmel_uart_writel(port, ATMEL_US_IDR, -1);
atmel_port->ms_irq_enabled = false; atmel_port->ms_irq_enabled = false;
/* /*
@ -1804,9 +1803,9 @@ static int atmel_startup(struct uart_port *port)
/* /*
* Finally, enable the serial port * Finally, enable the serial port
*/ */
UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA | ATMEL_US_RSTRX);
/* enable xmit & rcvr */ /* enable xmit & rcvr */
UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_TXEN | ATMEL_US_RXEN);
setup_timer(&atmel_port->uart_timer, setup_timer(&atmel_port->uart_timer,
atmel_uart_timer_callback, atmel_uart_timer_callback,
@ -1819,13 +1818,14 @@ static int atmel_startup(struct uart_port *port)
jiffies + uart_poll_timeout(port)); jiffies + uart_poll_timeout(port));
/* set USART timeout */ /* set USART timeout */
} else { } else {
UART_PUT_RTOR(port, PDC_RX_TIMEOUT); atmel_uart_writel(port, ATMEL_US_RTOR, PDC_RX_TIMEOUT);
UART_PUT_CR(port, ATMEL_US_STTTO); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STTTO);
UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IER,
ATMEL_US_ENDRX | ATMEL_US_TIMEOUT);
} }
/* enable PDC controller */ /* enable PDC controller */
UART_PUT_PTCR(port, ATMEL_PDC_RXTEN); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_RXTEN);
} else if (atmel_use_dma_rx(port)) { } else if (atmel_use_dma_rx(port)) {
/* set UART timeout */ /* set UART timeout */
if (!atmel_port->is_usart) { if (!atmel_port->is_usart) {
@ -1833,14 +1833,15 @@ static int atmel_startup(struct uart_port *port)
jiffies + uart_poll_timeout(port)); jiffies + uart_poll_timeout(port));
/* set USART timeout */ /* set USART timeout */
} else { } else {
UART_PUT_RTOR(port, PDC_RX_TIMEOUT); atmel_uart_writel(port, ATMEL_US_RTOR, PDC_RX_TIMEOUT);
UART_PUT_CR(port, ATMEL_US_STTTO); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_STTTO);
UART_PUT_IER(port, ATMEL_US_TIMEOUT); atmel_uart_writel(port, ATMEL_US_IER,
ATMEL_US_TIMEOUT);
} }
} else { } else {
/* enable receive only */ /* enable receive only */
UART_PUT_IER(port, ATMEL_US_RXRDY); atmel_uart_writel(port, ATMEL_US_IER, ATMEL_US_RXRDY);
} }
return 0; return 0;
@ -1860,7 +1861,7 @@ static void atmel_flush_buffer(struct uart_port *port)
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
if (atmel_use_pdc_tx(port)) { if (atmel_use_pdc_tx(port)) {
UART_PUT_TCR(port, 0); atmel_uart_writel(port, ATMEL_PDC_TCR, 0);
atmel_port->pdc_tx.ofs = 0; atmel_port->pdc_tx.ofs = 0;
} }
} }
@ -1892,8 +1893,8 @@ static void atmel_shutdown(struct uart_port *port)
atmel_stop_rx(port); atmel_stop_rx(port);
atmel_stop_tx(port); atmel_stop_tx(port);
UART_PUT_CR(port, ATMEL_US_RSTSTA); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA);
UART_PUT_IDR(port, -1); atmel_uart_writel(port, ATMEL_US_IDR, -1);
/* /*
@ -1938,12 +1939,12 @@ static void atmel_serial_pm(struct uart_port *port, unsigned int state,
clk_prepare_enable(atmel_port->clk); clk_prepare_enable(atmel_port->clk);
/* re-enable interrupts if we disabled some on suspend */ /* re-enable interrupts if we disabled some on suspend */
UART_PUT_IER(port, atmel_port->backup_imr); atmel_uart_writel(port, ATMEL_US_IER, atmel_port->backup_imr);
break; break;
case 3: case 3:
/* Back up the interrupt mask and disable all interrupts */ /* Back up the interrupt mask and disable all interrupts */
atmel_port->backup_imr = UART_GET_IMR(port); atmel_port->backup_imr = atmel_uart_readl(port, ATMEL_US_IMR);
UART_PUT_IDR(port, -1); atmel_uart_writel(port, ATMEL_US_IDR, -1);
/* /*
* Disable the peripheral clock for this serial port. * Disable the peripheral clock for this serial port.
@ -1966,7 +1967,7 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
unsigned int old_mode, mode, imr, quot, baud; unsigned int old_mode, mode, imr, quot, baud;
/* save the current mode register */ /* save the current mode register */
mode = old_mode = UART_GET_MR(port); mode = old_mode = atmel_uart_readl(port, ATMEL_US_MR);
/* reset the mode, clock divisor, parity, stop bits and data size */ /* reset the mode, clock divisor, parity, stop bits and data size */
mode &= ~(ATMEL_US_USCLKS | ATMEL_US_CHRL | ATMEL_US_NBSTOP | mode &= ~(ATMEL_US_USCLKS | ATMEL_US_CHRL | ATMEL_US_NBSTOP |
@ -2025,7 +2026,7 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
if (atmel_use_pdc_rx(port)) if (atmel_use_pdc_rx(port))
/* need to enable error interrupts */ /* need to enable error interrupts */
UART_PUT_IER(port, port->read_status_mask); atmel_uart_writel(port, ATMEL_US_IER, port->read_status_mask);
/* /*
* Characters to ignore * Characters to ignore
@ -2052,15 +2053,16 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
* transmitter is empty if requested by the caller, so there's * transmitter is empty if requested by the caller, so there's
* no need to wait for it here. * no need to wait for it here.
*/ */
imr = UART_GET_IMR(port); imr = atmel_uart_readl(port, ATMEL_US_IMR);
UART_PUT_IDR(port, -1); atmel_uart_writel(port, ATMEL_US_IDR, -1);
/* disable receiver and transmitter */ /* disable receiver and transmitter */
UART_PUT_CR(port, ATMEL_US_TXDIS | ATMEL_US_RXDIS); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_TXDIS | ATMEL_US_RXDIS);
/* mode */ /* mode */
if (port->rs485.flags & SER_RS485_ENABLED) { if (port->rs485.flags & SER_RS485_ENABLED) {
UART_PUT_TTGR(port, port->rs485.delay_rts_after_send); atmel_uart_writel(port, ATMEL_US_TTGR,
port->rs485.delay_rts_after_send);
mode |= ATMEL_US_USMODE_RS485; mode |= ATMEL_US_USMODE_RS485;
} else if (termios->c_cflag & CRTSCTS) { } else if (termios->c_cflag & CRTSCTS) {
/* RS232 with hardware handshake (RTS/CTS) */ /* RS232 with hardware handshake (RTS/CTS) */
@ -2071,7 +2073,7 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
} }
/* set the mode, clock divisor, parity, stop bits and data size */ /* set the mode, clock divisor, parity, stop bits and data size */
UART_PUT_MR(port, mode); atmel_uart_writel(port, ATMEL_US_MR, mode);
/* /*
* when switching the mode, set the RTS line state according to the * when switching the mode, set the RTS line state according to the
@ -2088,16 +2090,16 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
rts_state = ATMEL_US_RTSEN; rts_state = ATMEL_US_RTSEN;
} }
UART_PUT_CR(port, rts_state); atmel_uart_writel(port, ATMEL_US_CR, rts_state);
} }
/* set the baud rate */ /* set the baud rate */
UART_PUT_BRGR(port, quot); atmel_uart_writel(port, ATMEL_US_BRGR, quot);
UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA | ATMEL_US_RSTRX);
UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_TXEN | ATMEL_US_RXEN);
/* restore interrupts */ /* restore interrupts */
UART_PUT_IER(port, imr); atmel_uart_writel(port, ATMEL_US_IER, imr);
/* CTS flow-control and modem-status interrupts */ /* CTS flow-control and modem-status interrupts */
if (UART_ENABLE_MS(port, termios->c_cflag)) if (UART_ENABLE_MS(port, termios->c_cflag))
@ -2208,18 +2210,18 @@ static int atmel_verify_port(struct uart_port *port, struct serial_struct *ser)
#ifdef CONFIG_CONSOLE_POLL #ifdef CONFIG_CONSOLE_POLL
static int atmel_poll_get_char(struct uart_port *port) static int atmel_poll_get_char(struct uart_port *port)
{ {
while (!(UART_GET_CSR(port) & ATMEL_US_RXRDY)) while (!(atmel_uart_readl(port, ATMEL_US_CSR) & ATMEL_US_RXRDY))
cpu_relax(); cpu_relax();
return UART_GET_CHAR(port); return atmel_uart_readl(port, ATMEL_US_RHR);
} }
static void atmel_poll_put_char(struct uart_port *port, unsigned char ch) static void atmel_poll_put_char(struct uart_port *port, unsigned char ch)
{ {
while (!(UART_GET_CSR(port) & ATMEL_US_TXRDY)) while (!(atmel_uart_readl(port, ATMEL_US_CSR) & ATMEL_US_TXRDY))
cpu_relax(); cpu_relax();
UART_PUT_CHAR(port, ch); atmel_uart_writel(port, ATMEL_US_THR, ch);
} }
#endif #endif
@ -2324,9 +2326,9 @@ struct platform_device *atmel_default_console_device; /* the serial console devi
#ifdef CONFIG_SERIAL_ATMEL_CONSOLE #ifdef CONFIG_SERIAL_ATMEL_CONSOLE
static void atmel_console_putchar(struct uart_port *port, int ch) static void atmel_console_putchar(struct uart_port *port, int ch)
{ {
while (!(UART_GET_CSR(port) & ATMEL_US_TXRDY)) while (!(atmel_uart_readl(port, ATMEL_US_CSR) & ATMEL_US_TXRDY))
cpu_relax(); cpu_relax();
UART_PUT_CHAR(port, ch); atmel_uart_writel(port, ATMEL_US_THR, ch);
} }
/* /*
@ -2342,12 +2344,13 @@ static void atmel_console_write(struct console *co, const char *s, u_int count)
/* /*
* First, save IMR and then disable interrupts * First, save IMR and then disable interrupts
*/ */
imr = UART_GET_IMR(port); imr = atmel_uart_readl(port, ATMEL_US_IMR);
UART_PUT_IDR(port, ATMEL_US_RXRDY | atmel_port->tx_done_mask); atmel_uart_writel(port, ATMEL_US_IDR,
ATMEL_US_RXRDY | atmel_port->tx_done_mask);
/* Store PDC transmit status and disable it */ /* Store PDC transmit status and disable it */
pdc_tx = UART_GET_PTSR(port) & ATMEL_PDC_TXTEN; pdc_tx = atmel_uart_readl(port, ATMEL_PDC_PTSR) & ATMEL_PDC_TXTEN;
UART_PUT_PTCR(port, ATMEL_PDC_TXTDIS); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTDIS);
uart_console_write(port, s, count, atmel_console_putchar); uart_console_write(port, s, count, atmel_console_putchar);
@ -2356,15 +2359,15 @@ static void atmel_console_write(struct console *co, const char *s, u_int count)
* and restore IMR * and restore IMR
*/ */
do { do {
status = UART_GET_CSR(port); status = atmel_uart_readl(port, ATMEL_US_CSR);
} while (!(status & ATMEL_US_TXRDY)); } while (!(status & ATMEL_US_TXRDY));
/* Restore PDC transmit status */ /* Restore PDC transmit status */
if (pdc_tx) if (pdc_tx)
UART_PUT_PTCR(port, ATMEL_PDC_TXTEN); atmel_uart_writel(port, ATMEL_PDC_PTCR, ATMEL_PDC_TXTEN);
/* set interrupts back the way they were */ /* set interrupts back the way they were */
UART_PUT_IER(port, imr); atmel_uart_writel(port, ATMEL_US_IER, imr);
} }
/* /*
@ -2380,17 +2383,17 @@ static void __init atmel_console_get_options(struct uart_port *port, int *baud,
* If the baud rate generator isn't running, the port wasn't * If the baud rate generator isn't running, the port wasn't
* initialized by the boot loader. * initialized by the boot loader.
*/ */
quot = UART_GET_BRGR(port) & ATMEL_US_CD; quot = atmel_uart_readl(port, ATMEL_US_BRGR) & ATMEL_US_CD;
if (!quot) if (!quot)
return; return;
mr = UART_GET_MR(port) & ATMEL_US_CHRL; mr = atmel_uart_readl(port, ATMEL_US_MR) & ATMEL_US_CHRL;
if (mr == ATMEL_US_CHRL_8) if (mr == ATMEL_US_CHRL_8)
*bits = 8; *bits = 8;
else else
*bits = 7; *bits = 7;
mr = UART_GET_MR(port) & ATMEL_US_PAR; mr = atmel_uart_readl(port, ATMEL_US_MR) & ATMEL_US_PAR;
if (mr == ATMEL_US_PAR_EVEN) if (mr == ATMEL_US_PAR_EVEN)
*parity = 'e'; *parity = 'e';
else if (mr == ATMEL_US_PAR_ODD) else if (mr == ATMEL_US_PAR_ODD)
@ -2423,9 +2426,9 @@ static int __init atmel_console_setup(struct console *co, char *options)
if (ret) if (ret)
return ret; return ret;
UART_PUT_IDR(port, -1); atmel_uart_writel(port, ATMEL_US_IDR, -1);
UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_RSTSTA | ATMEL_US_RSTRX);
UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); atmel_uart_writel(port, ATMEL_US_CR, ATMEL_US_TXEN | ATMEL_US_RXEN);
if (options) if (options)
uart_parse_options(options, &baud, &parity, &bits, &flow); uart_parse_options(options, &baud, &parity, &bits, &flow);
@ -2532,7 +2535,8 @@ static int atmel_serial_suspend(struct platform_device *pdev,
if (atmel_is_console_port(port) && console_suspend_enabled) { if (atmel_is_console_port(port) && console_suspend_enabled) {
/* Drain the TX shifter */ /* Drain the TX shifter */
while (!(UART_GET_CSR(port) & ATMEL_US_TXEMPTY)) while (!(atmel_uart_readl(port, ATMEL_US_CSR) &
ATMEL_US_TXEMPTY))
cpu_relax(); cpu_relax();
} }
@ -2684,8 +2688,9 @@ static int atmel_serial_probe(struct platform_device *pdev)
clk_prepare_enable(port->clk); clk_prepare_enable(port->clk);
if (rs485_enabled) { if (rs485_enabled) {
UART_PUT_MR(&port->uart, ATMEL_US_USMODE_NORMAL); atmel_uart_writel(&port->uart, ATMEL_US_MR,
UART_PUT_CR(&port->uart, ATMEL_US_RTSEN); ATMEL_US_USMODE_NORMAL);
atmel_uart_writel(&port->uart, ATMEL_US_CR, ATMEL_US_RTSEN);
} }
/* /*