?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / tty / serial / sirfsoc_uart.c
blob1fd564b8194b7affe59be4ae0d3b827829c7ba8a
1 /*
2 * Driver for CSR SiRFprimaII onboard UARTs.
3 *
4 * Copyright (c) 2011 Cambridge Silicon Radio Limited, a CSR plc group company.
5 *
6 * Licensed under GPLv2 or later.
7 */
8
9 #include <linux/module.h>
10 #include <linux/ioport.h>
11 #include <linux/platform_device.h>
12 #include <linux/init.h>
13 #include <linux/sysrq.h>
14 #include <linux/console.h>
15 #include <linux/tty.h>
16 #include <linux/tty_flip.h>
17 #include <linux/serial_core.h>
18 #include <linux/serial.h>
19 #include <linux/clk.h>
20 #include <linux/of.h>
21 #include <linux/slab.h>
22 #include <linux/io.h>
23 #include <asm/irq.h>
24 #include <asm/mach/irq.h>
25 #include <linux/pinctrl/consumer.h>
26
27 #include "sirfsoc_uart.h"
28
29 static unsigned int
30 sirfsoc_uart_pio_tx_chars(struct sirfsoc_uart_port *sirfport, int count);
31 static unsigned int
32 sirfsoc_uart_pio_rx_chars(struct uart_port *port, unsigned int max_rx_count);
33 static struct uart_driver sirfsoc_uart_drv;
34
35 static const struct sirfsoc_baudrate_to_regv baudrate_to_regv[] = {
36 {4000000, 2359296},
37 {3500000, 1310721},
38 {3000000, 1572865},
39 {2500000, 1245186},
40 {2000000, 1572866},
41 {1500000, 1245188},
42 {1152000, 1638404},
43 {1000000, 1572869},
44 {921600, 1114120},
45 {576000, 1245196},
46 {500000, 1245198},
47 {460800, 1572876},
48 {230400, 1310750},
49 {115200, 1310781},
50 {57600, 1310843},
51 {38400, 1114328},
52 {19200, 1114545},
53 {9600, 1114979},
54 };
55
56 static struct sirfsoc_uart_port sirfsoc_uart_ports[SIRFSOC_UART_NR] = {
57 [0] = {
58 .port = {
59 .iotype = UPIO_MEM,
60 .flags = UPF_BOOT_AUTOCONF,
61 .line = 0,
62 },
63 },
64 [1] = {
65 .port = {
66 .iotype = UPIO_MEM,
67 .flags = UPF_BOOT_AUTOCONF,
68 .line = 1,
69 },
70 },
71 [2] = {
72 .port = {
73 .iotype = UPIO_MEM,
74 .flags = UPF_BOOT_AUTOCONF,
75 .line = 2,
76 },
77 },
78 [3] = {
79 .port = {
80 .iotype = UPIO_MEM,
81 .flags = UPF_BOOT_AUTOCONF,
82 .line = 3,
83 },
84 },
85 [4] = {
86 .port = {
87 .iotype = UPIO_MEM,
88 .flags = UPF_BOOT_AUTOCONF,
89 .line = 4,
90 },
91 },
92 };
93
94 static inline struct sirfsoc_uart_port *to_sirfport(struct uart_port *port)
95 {
96 return container_of(port, struct sirfsoc_uart_port, port);
97 }
98
99 static inline unsigned int sirfsoc_uart_tx_empty(struct uart_port *port)
100 {
101 unsigned long reg;
102 reg = rd_regl(port, SIRFUART_TX_FIFO_STATUS);
103 if (reg & SIRFUART_FIFOEMPTY_MASK(port))
104 return TIOCSER_TEMT;
105 else
106 return 0;
107 }
108
109 static unsigned int sirfsoc_uart_get_mctrl(struct uart_port *port)
110 {
111 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
112 if (!(sirfport->ms_enabled)) {
113 goto cts_asserted;
114 } else if (sirfport->hw_flow_ctrl) {
115 if (!(rd_regl(port, SIRFUART_AFC_CTRL) &
116 SIRFUART_CTS_IN_STATUS))
117 goto cts_asserted;
118 else
119 goto cts_deasserted;
120 }
121 cts_deasserted:
122 return TIOCM_CAR | TIOCM_DSR;
123 cts_asserted:
124 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
125 }
126
127 static void sirfsoc_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
128 {
129 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
130 unsigned int assert = mctrl & TIOCM_RTS;
131 unsigned int val = assert ? SIRFUART_AFC_CTRL_RX_THD : 0x0;
132 unsigned int current_val;
133 if (sirfport->hw_flow_ctrl) {
134 current_val = rd_regl(port, SIRFUART_AFC_CTRL) & ~0xFF;
135 val |= current_val;
136 wr_regl(port, SIRFUART_AFC_CTRL, val);
137 }
138 }
139
140 static void sirfsoc_uart_stop_tx(struct uart_port *port)
141 {
142 unsigned int regv;
143 regv = rd_regl(port, SIRFUART_INT_EN);
144 wr_regl(port, SIRFUART_INT_EN, regv & ~SIRFUART_TX_INT_EN);
145 }
146
147 void sirfsoc_uart_start_tx(struct uart_port *port)
148 {
149 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
150 unsigned long regv;
151 sirfsoc_uart_pio_tx_chars(sirfport, 1);
152 wr_regl(port, SIRFUART_TX_FIFO_OP, SIRFUART_TX_FIFO_START);
153 regv = rd_regl(port, SIRFUART_INT_EN);
154 wr_regl(port, SIRFUART_INT_EN, regv | SIRFUART_TX_INT_EN);
155 }
156
157 static void sirfsoc_uart_stop_rx(struct uart_port *port)
158 {
159 unsigned long regv;
160 wr_regl(port, SIRFUART_RX_FIFO_OP, 0);
161 regv = rd_regl(port, SIRFUART_INT_EN);
162 wr_regl(port, SIRFUART_INT_EN, regv & ~SIRFUART_RX_IO_INT_EN);
163 }
164
165 static void sirfsoc_uart_disable_ms(struct uart_port *port)
166 {
167 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
168 unsigned long reg;
169 sirfport->ms_enabled = 0;
170 if (!sirfport->hw_flow_ctrl)
171 return;
172 reg = rd_regl(port, SIRFUART_AFC_CTRL);
173 wr_regl(port, SIRFUART_AFC_CTRL, reg & ~0x3FF);
174 reg = rd_regl(port, SIRFUART_INT_EN);
175 wr_regl(port, SIRFUART_INT_EN, reg & ~SIRFUART_CTS_INT_EN);
176 }
177
178 static void sirfsoc_uart_enable_ms(struct uart_port *port)
179 {
180 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
181 unsigned long reg;
182 unsigned long flg;
183 if (!sirfport->hw_flow_ctrl)
184 return;
185 flg = SIRFUART_AFC_RX_EN | SIRFUART_AFC_TX_EN;
186 reg = rd_regl(port, SIRFUART_AFC_CTRL);
187 wr_regl(port, SIRFUART_AFC_CTRL, reg | flg);
188 reg = rd_regl(port, SIRFUART_INT_EN);
189 wr_regl(port, SIRFUART_INT_EN, reg | SIRFUART_CTS_INT_EN);
190 uart_handle_cts_change(port,
191 !(rd_regl(port, SIRFUART_AFC_CTRL) & SIRFUART_CTS_IN_STATUS));
192 sirfport->ms_enabled = 1;
193 }
194
195 static void sirfsoc_uart_break_ctl(struct uart_port *port, int break_state)
196 {
197 unsigned long ulcon = rd_regl(port, SIRFUART_LINE_CTRL);
198 if (break_state)
199 ulcon |= SIRFUART_SET_BREAK;
200 else
201 ulcon &= ~SIRFUART_SET_BREAK;
202 wr_regl(port, SIRFUART_LINE_CTRL, ulcon);
203 }
204
205 static unsigned int
206 sirfsoc_uart_pio_rx_chars(struct uart_port *port, unsigned int max_rx_count)
207 {
208 unsigned int ch, rx_count = 0;
209
210 while (!(rd_regl(port, SIRFUART_RX_FIFO_STATUS) &
211 SIRFUART_FIFOEMPTY_MASK(port))) {
212 ch = rd_regl(port, SIRFUART_RX_FIFO_DATA) | SIRFUART_DUMMY_READ;
213 if (unlikely(uart_handle_sysrq_char(port, ch)))
214 continue;
215 uart_insert_char(port, 0, 0, ch, TTY_NORMAL);
216 rx_count++;
217 if (rx_count >= max_rx_count)
218 break;
219 }
220
221 port->icount.rx += rx_count;
222 tty_flip_buffer_push(&port->state->port);
223
224 return rx_count;
225 }
226
227 static unsigned int
228 sirfsoc_uart_pio_tx_chars(struct sirfsoc_uart_port *sirfport, int count)
229 {
230 struct uart_port *port = &sirfport->port;
231 struct circ_buf *xmit = &port->state->xmit;
232 unsigned int num_tx = 0;
233 while (!uart_circ_empty(xmit) &&
234 !(rd_regl(port, SIRFUART_TX_FIFO_STATUS) &
235 SIRFUART_FIFOFULL_MASK(port)) &&
236 count--) {
237 wr_regl(port, SIRFUART_TX_FIFO_DATA, xmit->buf[xmit->tail]);
238 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
239 port->icount.tx++;
240 num_tx++;
241 }
242 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
243 uart_write_wakeup(port);
244 return num_tx;
245 }
246
247 static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id)
248 {
249 unsigned long intr_status;
250 unsigned long cts_status;
251 unsigned long flag = TTY_NORMAL;
252 struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id;
253 struct uart_port *port = &sirfport->port;
254 struct uart_state *state = port->state;
255 struct circ_buf *xmit = &port->state->xmit;
256 spin_lock(&port->lock);
257 intr_status = rd_regl(port, SIRFUART_INT_STATUS);
258 wr_regl(port, SIRFUART_INT_STATUS, intr_status);
259 intr_status &= rd_regl(port, SIRFUART_INT_EN);
260 if (unlikely(intr_status & (SIRFUART_ERR_INT_STAT))) {
261 if (intr_status & SIRFUART_RXD_BREAK) {
262 if (uart_handle_break(port))
263 goto recv_char;
264 uart_insert_char(port, intr_status,
265 SIRFUART_RX_OFLOW, 0, TTY_BREAK);
266 spin_unlock(&port->lock);
267 return IRQ_HANDLED;
268 }
269 if (intr_status & SIRFUART_RX_OFLOW)
270 port->icount.overrun++;
271 if (intr_status & SIRFUART_FRM_ERR) {
272 port->icount.frame++;
273 flag = TTY_FRAME;
274 }
275 if (intr_status & SIRFUART_PARITY_ERR)
276 flag = TTY_PARITY;
277 wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_RESET);
278 wr_regl(port, SIRFUART_RX_FIFO_OP, 0);
279 wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_START);
280 intr_status &= port->read_status_mask;
281 uart_insert_char(port, intr_status,
282 SIRFUART_RX_OFLOW_INT, 0, flag);
283 }
284 recv_char:
285 if (intr_status & SIRFUART_CTS_INT_EN) {
286 cts_status = !(rd_regl(port, SIRFUART_AFC_CTRL) &
287 SIRFUART_CTS_IN_STATUS);
288 if (cts_status != 0) {
289 uart_handle_cts_change(port, 1);
290 } else {
291 uart_handle_cts_change(port, 0);
292 wake_up_interruptible(&state->port.delta_msr_wait);
293 }
294 }
295 if (intr_status & SIRFUART_RX_IO_INT_EN)
296 sirfsoc_uart_pio_rx_chars(port, SIRFSOC_UART_IO_RX_MAX_CNT);
297 if (intr_status & SIRFUART_TX_INT_EN) {
298 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
299 spin_unlock(&port->lock);
300 return IRQ_HANDLED;
301 } else {
302 sirfsoc_uart_pio_tx_chars(sirfport,
303 SIRFSOC_UART_IO_TX_REASONABLE_CNT);
304 if ((uart_circ_empty(xmit)) &&
305 (rd_regl(port, SIRFUART_TX_FIFO_STATUS) &
306 SIRFUART_FIFOEMPTY_MASK(port)))
307 sirfsoc_uart_stop_tx(port);
308 }
309 }
310 spin_unlock(&port->lock);
311 return IRQ_HANDLED;
312 }
313
314 static void sirfsoc_uart_start_rx(struct uart_port *port)
315 {
316 unsigned long regv;
317 regv = rd_regl(port, SIRFUART_INT_EN);
318 wr_regl(port, SIRFUART_INT_EN, regv | SIRFUART_RX_IO_INT_EN);
319 wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_RESET);
320 wr_regl(port, SIRFUART_RX_FIFO_OP, 0);
321 wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_START);
322 }
323
324 static unsigned int
325 sirfsoc_calc_sample_div(unsigned long baud_rate,
326 unsigned long ioclk_rate, unsigned long *setted_baud)
327 {
328 unsigned long min_delta = ~0UL;
329 unsigned short sample_div;
330 unsigned int regv = 0;
331 unsigned long ioclk_div;
332 unsigned long baud_tmp;
333 int temp_delta;
334
335 for (sample_div = SIRF_MIN_SAMPLE_DIV;
336 sample_div <= SIRF_MAX_SAMPLE_DIV; sample_div++) {
337 ioclk_div = (ioclk_rate / (baud_rate * (sample_div + 1))) - 1;
338 if (ioclk_div > SIRF_IOCLK_DIV_MAX)
339 continue;
340 baud_tmp = ioclk_rate / ((ioclk_div + 1) * (sample_div + 1));
341 temp_delta = baud_tmp - baud_rate;
342 temp_delta = (temp_delta > 0) ? temp_delta : -temp_delta;
343 if (temp_delta < min_delta) {
344 regv = regv & (~SIRF_IOCLK_DIV_MASK);
345 regv = regv | ioclk_div;
346 regv = regv & (~SIRF_SAMPLE_DIV_MASK);
347 regv = regv | (sample_div << SIRF_SAMPLE_DIV_SHIFT);
348 min_delta = temp_delta;
349 *setted_baud = baud_tmp;
350 }
351 }
352 return regv;
353 }
354
355 static void sirfsoc_uart_set_termios(struct uart_port *port,
356 struct ktermios *termios,
357 struct ktermios *old)
358 {
359 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
360 unsigned long config_reg = 0;
361 unsigned long baud_rate;
362 unsigned long setted_baud;
363 unsigned long flags;
364 unsigned long ic;
365 unsigned int clk_div_reg = 0;
366 unsigned long temp_reg_val;
367 unsigned long rx_time_out;
368 int threshold_div;
369 int temp;
370
371 switch (termios->c_cflag & CSIZE) {
372 default:
373 case CS8:
374 config_reg |= SIRFUART_DATA_BIT_LEN_8;
375 break;
376 case CS7:
377 config_reg |= SIRFUART_DATA_BIT_LEN_7;
378 break;
379 case CS6:
380 config_reg |= SIRFUART_DATA_BIT_LEN_6;
381 break;
382 case CS5:
383 config_reg |= SIRFUART_DATA_BIT_LEN_5;
384 break;
385 }
386 if (termios->c_cflag & CSTOPB)
387 config_reg |= SIRFUART_STOP_BIT_LEN_2;
388 baud_rate = uart_get_baud_rate(port, termios, old, 0, 4000000);
389 spin_lock_irqsave(&port->lock, flags);
390 port->read_status_mask = SIRFUART_RX_OFLOW_INT;
391 port->ignore_status_mask = 0;
392 /* read flags */
393 if (termios->c_iflag & INPCK)
394 port->read_status_mask |=
395 SIRFUART_FRM_ERR_INT | SIRFUART_PARITY_ERR_INT;
396 if (termios->c_iflag & (BRKINT | PARMRK))
397 port->read_status_mask |= SIRFUART_RXD_BREAK_INT;
398 /* ignore flags */
399 if (termios->c_iflag & IGNPAR)
400 port->ignore_status_mask |=
401 SIRFUART_FRM_ERR_INT | SIRFUART_PARITY_ERR_INT;
402 if ((termios->c_cflag & CREAD) == 0)
403 port->ignore_status_mask |= SIRFUART_DUMMY_READ;
404 /* enable parity if PARENB is set*/
405 if (termios->c_cflag & PARENB) {
406 if (termios->c_cflag & CMSPAR) {
407 if (termios->c_cflag & PARODD)
408 config_reg |= SIRFUART_STICK_BIT_MARK;
409 else
410 config_reg |= SIRFUART_STICK_BIT_SPACE;
411 } else if (termios->c_cflag & PARODD) {
412 config_reg |= SIRFUART_STICK_BIT_ODD;
413 } else {
414 config_reg |= SIRFUART_STICK_BIT_EVEN;
415 }
416 }
417 /* Hardware Flow Control Settings */
418 if (UART_ENABLE_MS(port, termios->c_cflag)) {
419 if (!sirfport->ms_enabled)
420 sirfsoc_uart_enable_ms(port);
421 } else {
422 if (sirfport->ms_enabled)
423 sirfsoc_uart_disable_ms(port);
424 }
425
426 if (port->uartclk == 150000000) {
427 /* common rate: fast calculation */
428 for (ic = 0; ic < SIRF_BAUD_RATE_SUPPORT_NR; ic++)
429 if (baud_rate == baudrate_to_regv[ic].baud_rate)
430 clk_div_reg = baudrate_to_regv[ic].reg_val;
431 }
432
433 setted_baud = baud_rate;
434 /* arbitary rate setting */
435 if (unlikely(clk_div_reg == 0))
436 clk_div_reg = sirfsoc_calc_sample_div(baud_rate, port->uartclk,
437 &setted_baud);
438 wr_regl(port, SIRFUART_DIVISOR, clk_div_reg);
439
440 if (tty_termios_baud_rate(termios))
441 tty_termios_encode_baud_rate(termios, setted_baud, setted_baud);
442
443 /* set receive timeout */
444 rx_time_out = SIRFSOC_UART_RX_TIMEOUT(baud_rate, 20000);
445 rx_time_out = (rx_time_out > 0xFFFF) ? 0xFFFF : rx_time_out;
446 config_reg |= SIRFUART_RECV_TIMEOUT(rx_time_out);
447 temp_reg_val = rd_regl(port, SIRFUART_TX_FIFO_OP);
448 wr_regl(port, SIRFUART_RX_FIFO_OP, 0);
449 wr_regl(port, SIRFUART_TX_FIFO_OP,
450 temp_reg_val & ~SIRFUART_TX_FIFO_START);
451 wr_regl(port, SIRFUART_TX_DMA_IO_CTRL, SIRFUART_TX_MODE_IO);
452 wr_regl(port, SIRFUART_RX_DMA_IO_CTRL, SIRFUART_RX_MODE_IO);
453 wr_regl(port, SIRFUART_LINE_CTRL, config_reg);
454
455 /* Reset Rx/Tx FIFO Threshold level for proper baudrate */
456 if (baud_rate < 1000000)
457 threshold_div = 1;
458 else
459 threshold_div = 2;
460 temp = port->line == 1 ? 16 : 64;
461 wr_regl(port, SIRFUART_TX_FIFO_CTRL, temp / threshold_div);
462 wr_regl(port, SIRFUART_RX_FIFO_CTRL, temp / threshold_div);
463 temp_reg_val |= SIRFUART_TX_FIFO_START;
464 wr_regl(port, SIRFUART_TX_FIFO_OP, temp_reg_val);
465 uart_update_timeout(port, termios->c_cflag, baud_rate);
466 sirfsoc_uart_start_rx(port);
467 wr_regl(port, SIRFUART_TX_RX_EN, SIRFUART_TX_EN | SIRFUART_RX_EN);
468 spin_unlock_irqrestore(&port->lock, flags);
469 }
470
471 static void startup_uart_controller(struct uart_port *port)
472 {
473 unsigned long temp_regv;
474 int temp;
475 temp_regv = rd_regl(port, SIRFUART_TX_DMA_IO_CTRL);
476 wr_regl(port, SIRFUART_TX_DMA_IO_CTRL, temp_regv | SIRFUART_TX_MODE_IO);
477 temp_regv = rd_regl(port, SIRFUART_RX_DMA_IO_CTRL);
478 wr_regl(port, SIRFUART_RX_DMA_IO_CTRL, temp_regv | SIRFUART_RX_MODE_IO);
479 wr_regl(port, SIRFUART_TX_DMA_IO_LEN, 0);
480 wr_regl(port, SIRFUART_RX_DMA_IO_LEN, 0);
481 wr_regl(port, SIRFUART_TX_RX_EN, SIRFUART_RX_EN | SIRFUART_TX_EN);
482 wr_regl(port, SIRFUART_TX_FIFO_OP, SIRFUART_TX_FIFO_RESET);
483 wr_regl(port, SIRFUART_TX_FIFO_OP, 0);
484 wr_regl(port, SIRFUART_RX_FIFO_OP, SIRFUART_RX_FIFO_RESET);
485 wr_regl(port, SIRFUART_RX_FIFO_OP, 0);
486 temp = port->line == 1 ? 16 : 64;
487 wr_regl(port, SIRFUART_TX_FIFO_CTRL, temp);
488 wr_regl(port, SIRFUART_RX_FIFO_CTRL, temp);
489 }
490
491 static int sirfsoc_uart_startup(struct uart_port *port)
492 {
493 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
494 unsigned int index = port->line;
495 int ret;
496 set_irq_flags(port->irq, IRQF_VALID | IRQF_NOAUTOEN);
497 ret = request_irq(port->irq,
498 sirfsoc_uart_isr,
499 0,
500 SIRFUART_PORT_NAME,
501 sirfport);
502 if (ret != 0) {
503 dev_err(port->dev, "UART%d request IRQ line (%d) failed.\n",
504 index, port->irq);
505 goto irq_err;
506 }
507 startup_uart_controller(port);
508 enable_irq(port->irq);
509 irq_err:
510 return ret;
511 }
512
513 static void sirfsoc_uart_shutdown(struct uart_port *port)
514 {
515 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
516 wr_regl(port, SIRFUART_INT_EN, 0);
517 free_irq(port->irq, sirfport);
518 if (sirfport->ms_enabled) {
519 sirfsoc_uart_disable_ms(port);
520 sirfport->ms_enabled = 0;
521 }
522 }
523
524 static const char *sirfsoc_uart_type(struct uart_port *port)
525 {
526 return port->type == SIRFSOC_PORT_TYPE ? SIRFUART_PORT_NAME : NULL;
527 }
528
529 static int sirfsoc_uart_request_port(struct uart_port *port)
530 {
531 void *ret;
532 ret = request_mem_region(port->mapbase,
533 SIRFUART_MAP_SIZE, SIRFUART_PORT_NAME);
534 return ret ? 0 : -EBUSY;
535 }
536
537 static void sirfsoc_uart_release_port(struct uart_port *port)
538 {
539 release_mem_region(port->mapbase, SIRFUART_MAP_SIZE);
540 }
541
542 static void sirfsoc_uart_config_port(struct uart_port *port, int flags)
543 {
544 if (flags & UART_CONFIG_TYPE) {
545 port->type = SIRFSOC_PORT_TYPE;
546 sirfsoc_uart_request_port(port);
547 }
548 }
549
550 static struct uart_ops sirfsoc_uart_ops = {
551 .tx_empty = sirfsoc_uart_tx_empty,
552 .get_mctrl = sirfsoc_uart_get_mctrl,
553 .set_mctrl = sirfsoc_uart_set_mctrl,
554 .stop_tx = sirfsoc_uart_stop_tx,
555 .start_tx = sirfsoc_uart_start_tx,
556 .stop_rx = sirfsoc_uart_stop_rx,
557 .enable_ms = sirfsoc_uart_enable_ms,
558 .break_ctl = sirfsoc_uart_break_ctl,
559 .startup = sirfsoc_uart_startup,
560 .shutdown = sirfsoc_uart_shutdown,
561 .set_termios = sirfsoc_uart_set_termios,
562 .type = sirfsoc_uart_type,
563 .release_port = sirfsoc_uart_release_port,
564 .request_port = sirfsoc_uart_request_port,
565 .config_port = sirfsoc_uart_config_port,
566 };
567
568 #ifdef CONFIG_SERIAL_SIRFSOC_CONSOLE
569 static int __init sirfsoc_uart_console_setup(struct console *co, char *options)
570 {
571 unsigned int baud = 115200;
572 unsigned int bits = 8;
573 unsigned int parity = 'n';
574 unsigned int flow = 'n';
575 struct uart_port *port = &sirfsoc_uart_ports[co->index].port;
576
577 if (co->index < 0 || co->index >= SIRFSOC_UART_NR)
578 return -EINVAL;
579
580 if (!port->mapbase)
581 return -ENODEV;
582
583 if (options)
584 uart_parse_options(options, &baud, &parity, &bits, &flow);
585 port->cons = co;
586 return uart_set_options(port, co, baud, parity, bits, flow);
587 }
588
589 static void sirfsoc_uart_console_putchar(struct uart_port *port, int ch)
590 {
591 while (rd_regl(port,
592 SIRFUART_TX_FIFO_STATUS) & SIRFUART_FIFOFULL_MASK(port))
593 cpu_relax();
594 wr_regb(port, SIRFUART_TX_FIFO_DATA, ch);
595 }
596
597 static void sirfsoc_uart_console_write(struct console *co, const char *s,
598 unsigned int count)
599 {
600 struct uart_port *port = &sirfsoc_uart_ports[co->index].port;
601 uart_console_write(port, s, count, sirfsoc_uart_console_putchar);
602 }
603
604 static struct console sirfsoc_uart_console = {
605 .name = SIRFSOC_UART_NAME,
606 .device = uart_console_device,
607 .flags = CON_PRINTBUFFER,
608 .index = -1,
609 .write = sirfsoc_uart_console_write,
610 .setup = sirfsoc_uart_console_setup,
611 .data = &sirfsoc_uart_drv,
612 };
613
614 static int __init sirfsoc_uart_console_init(void)
615 {
616 register_console(&sirfsoc_uart_console);
617 return 0;
618 }
619 console_initcall(sirfsoc_uart_console_init);
620 #endif
621
622 static struct uart_driver sirfsoc_uart_drv = {
623 .owner = THIS_MODULE,
624 .driver_name = SIRFUART_PORT_NAME,
625 .nr = SIRFSOC_UART_NR,
626 .dev_name = SIRFSOC_UART_NAME,
627 .major = SIRFSOC_UART_MAJOR,
628 .minor = SIRFSOC_UART_MINOR,
629 #ifdef CONFIG_SERIAL_SIRFSOC_CONSOLE
630 .cons = &sirfsoc_uart_console,
631 #else
632 .cons = NULL,
633 #endif
634 };
635
636 int sirfsoc_uart_probe(struct platform_device *pdev)
637 {
638 struct sirfsoc_uart_port *sirfport;
639 struct uart_port *port;
640 struct resource *res;
641 int ret;
642
643 if (of_property_read_u32(pdev->dev.of_node, "cell-index", &pdev->id)) {
644 dev_err(&pdev->dev,
645 "Unable to find cell-index in uart node.\n");
646 ret = -EFAULT;
647 goto err;
648 }
649
650 sirfport = &sirfsoc_uart_ports[pdev->id];
651 port = &sirfport->port;
652 port->dev = &pdev->dev;
653 port->private_data = sirfport;
654
655 if (of_find_property(pdev->dev.of_node, "hw_flow_ctrl", NULL))
656 sirfport->hw_flow_ctrl = 1;
657
658 if (of_property_read_u32(pdev->dev.of_node,
659 "fifosize",
660 &port->fifosize)) {
661 dev_err(&pdev->dev,
662 "Unable to find fifosize in uart node.\n");
663 ret = -EFAULT;
664 goto err;
665 }
666
667 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
668 if (res == NULL) {
669 dev_err(&pdev->dev, "Insufficient resources.\n");
670 ret = -EFAULT;
671 goto err;
672 }
673 port->mapbase = res->start;
674 port->membase = devm_ioremap(&pdev->dev, res->start, resource_size(res));
675 if (!port->membase) {
676 dev_err(&pdev->dev, "Cannot remap resource.\n");
677 ret = -ENOMEM;
678 goto err;
679 }
680 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
681 if (res == NULL) {
682 dev_err(&pdev->dev, "Insufficient resources.\n");
683 ret = -EFAULT;
684 goto err;
685 }
686 port->irq = res->start;
687
688 if (sirfport->hw_flow_ctrl) {
689 sirfport->p = pinctrl_get_select_default(&pdev->dev);
690 if (IS_ERR(sirfport->p)) {
691 ret = PTR_ERR(sirfport->p);
692 goto err;
693 }
694 }
695
696 sirfport->clk = clk_get(&pdev->dev, NULL);
697 if (IS_ERR(sirfport->clk)) {
698 ret = PTR_ERR(sirfport->clk);
699 goto clk_err;
700 }
701 clk_prepare_enable(sirfport->clk);
702 port->uartclk = clk_get_rate(sirfport->clk);
703
704 port->ops = &sirfsoc_uart_ops;
705 spin_lock_init(&port->lock);
706
707 platform_set_drvdata(pdev, sirfport);
708 ret = uart_add_one_port(&sirfsoc_uart_drv, port);
709 if (ret != 0) {
710 dev_err(&pdev->dev, "Cannot add UART port(%d).\n", pdev->id);
711 goto port_err;
712 }
713
714 return 0;
715
716 port_err:
717 clk_disable_unprepare(sirfport->clk);
718 clk_put(sirfport->clk);
719 clk_err:
720 platform_set_drvdata(pdev, NULL);
721 if (sirfport->hw_flow_ctrl)
722 pinctrl_put(sirfport->p);
723 err:
724 return ret;
725 }
726
727 static int sirfsoc_uart_remove(struct platform_device *pdev)
728 {
729 struct sirfsoc_uart_port *sirfport = platform_get_drvdata(pdev);
730 struct uart_port *port = &sirfport->port;
731 platform_set_drvdata(pdev, NULL);
732 if (sirfport->hw_flow_ctrl)
733 pinctrl_put(sirfport->p);
734 clk_disable_unprepare(sirfport->clk);
735 clk_put(sirfport->clk);
736 uart_remove_one_port(&sirfsoc_uart_drv, port);
737 return 0;
738 }
739
740 static int
741 sirfsoc_uart_suspend(struct platform_device *pdev, pm_message_t state)
742 {
743 struct sirfsoc_uart_port *sirfport = platform_get_drvdata(pdev);
744 struct uart_port *port = &sirfport->port;
745 uart_suspend_port(&sirfsoc_uart_drv, port);
746 return 0;
747 }
748
749 static int sirfsoc_uart_resume(struct platform_device *pdev)
750 {
751 struct sirfsoc_uart_port *sirfport = platform_get_drvdata(pdev);
752 struct uart_port *port = &sirfport->port;
753 uart_resume_port(&sirfsoc_uart_drv, port);
754 return 0;
755 }
756
757 static struct of_device_id sirfsoc_uart_ids[] = {
758 { .compatible = "sirf,prima2-uart", },
759 { .compatible = "sirf,marco-uart", },
760 {}
761 };
762 MODULE_DEVICE_TABLE(of, sirfsoc_uart_ids);
763
764 static struct platform_driver sirfsoc_uart_driver = {
765 .probe = sirfsoc_uart_probe,
766 .remove = sirfsoc_uart_remove,
767 .suspend = sirfsoc_uart_suspend,
768 .resume = sirfsoc_uart_resume,
769 .driver = {
770 .name = SIRFUART_PORT_NAME,
771 .owner = THIS_MODULE,
772 .of_match_table = sirfsoc_uart_ids,
773 },
774 };
775
776 static int __init sirfsoc_uart_init(void)
777 {
778 int ret = 0;
779
780 ret = uart_register_driver(&sirfsoc_uart_drv);
781 if (ret)
782 goto out;
783
784 ret = platform_driver_register(&sirfsoc_uart_driver);
785 if (ret)
786 uart_unregister_driver(&sirfsoc_uart_drv);
787 out:
788 return ret;
789 }
790 module_init(sirfsoc_uart_init);
791
792 static void __exit sirfsoc_uart_exit(void)
793 {
794 platform_driver_unregister(&sirfsoc_uart_driver);
795 uart_unregister_driver(&sirfsoc_uart_drv);
796 }
797 module_exit(sirfsoc_uart_exit);
798
799 MODULE_LICENSE("GPL v2");
800 MODULE_AUTHOR("Bin Shi <Bin.Shi@csr.com>, Rong Wang<Rong.Wang@csr.com>");
801 MODULE_DESCRIPTION("CSR SiRFprimaII Uart Driver");
CRIS linux kernel tree