1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#if defined(CONFIG_SERIAL_OMAP_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
24#define SUPPORT_SYSRQ
25#endif
26
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/console.h>
30#include <linux/serial_reg.h>
31#include <linux/delay.h>
32#include <linux/slab.h>
33#include <linux/tty.h>
34#include <linux/tty_flip.h>
35#include <linux/platform_device.h>
36#include <linux/io.h>
37#include <linux/clk.h>
38#include <linux/serial_core.h>
39#include <linux/irq.h>
40#include <linux/pm_runtime.h>
41#include <linux/pm_wakeirq.h>
42#include <linux/of.h>
43#include <linux/of_irq.h>
44#include <linux/gpio.h>
45#include <linux/of_gpio.h>
46#include <linux/platform_data/serial-omap.h>
47
48#include <dt-bindings/gpio/gpio.h>
49
50#define OMAP_MAX_HSUART_PORTS 10
51
52#define UART_BUILD_REVISION(x, y) (((x) << 8) | (y))
53
54#define OMAP_UART_REV_42 0x0402
55#define OMAP_UART_REV_46 0x0406
56#define OMAP_UART_REV_52 0x0502
57#define OMAP_UART_REV_63 0x0603
58
59#define OMAP_UART_TX_WAKEUP_EN BIT(7)
60
61
62#define OMAP_UART_WER_HAS_TX_WAKEUP BIT(0)
63
64#define UART_ERRATA_i202_MDR1_ACCESS BIT(0)
65#define UART_ERRATA_i291_DMA_FORCEIDLE BIT(1)
66
67#define DEFAULT_CLK_SPEED 48000000
68
69
70#define OMAP_UART_SCR_RX_TRIG_GRANU1_MASK (1 << 7)
71#define OMAP_UART_SCR_TX_TRIG_GRANU1_MASK (1 << 6)
72#define OMAP_UART_SCR_TX_EMPTY (1 << 3)
73
74
75#define OMAP_UART_FCR_RX_FIFO_TRIG_MASK (0x3 << 6)
76#define OMAP_UART_FCR_TX_FIFO_TRIG_MASK (0x3 << 4)
77
78
79#define OMAP_UART_MVR_SCHEME_SHIFT 30
80
81#define OMAP_UART_LEGACY_MVR_MAJ_MASK 0xf0
82#define OMAP_UART_LEGACY_MVR_MAJ_SHIFT 4
83#define OMAP_UART_LEGACY_MVR_MIN_MASK 0x0f
84
85#define OMAP_UART_MVR_MAJ_MASK 0x700
86#define OMAP_UART_MVR_MAJ_SHIFT 8
87#define OMAP_UART_MVR_MIN_MASK 0x3f
88
89#define OMAP_UART_DMA_CH_FREE -1
90
91#define MSR_SAVE_FLAGS UART_MSR_ANY_DELTA
92#define OMAP_MODE13X_SPEED 230400
93
94
95
96
97#define OMAP_UART_WER_MOD_WKUP 0x7F
98
99
100#define OMAP_UART_SW_TX 0x08
101
102
103#define OMAP_UART_SW_RX 0x02
104
105#define OMAP_UART_SW_CLR 0xF0
106
107#define OMAP_UART_TCR_TRIG 0x0F
108
109struct uart_omap_dma {
110 u8 uart_dma_tx;
111 u8 uart_dma_rx;
112 int rx_dma_channel;
113 int tx_dma_channel;
114 dma_addr_t rx_buf_dma_phys;
115 dma_addr_t tx_buf_dma_phys;
116 unsigned int uart_base;
117
118
119
120
121 unsigned char *rx_buf;
122 unsigned int prev_rx_dma_pos;
123 int tx_buf_size;
124 int tx_dma_used;
125 int rx_dma_used;
126 spinlock_t tx_lock;
127 spinlock_t rx_lock;
128
129 struct timer_list rx_timer;
130 unsigned int rx_buf_size;
131 unsigned int rx_poll_rate;
132 unsigned int rx_timeout;
133};
134
135struct uart_omap_port {
136 struct uart_port port;
137 struct uart_omap_dma uart_dma;
138 struct device *dev;
139 int wakeirq;
140
141 unsigned char ier;
142 unsigned char lcr;
143 unsigned char mcr;
144 unsigned char fcr;
145 unsigned char efr;
146 unsigned char dll;
147 unsigned char dlh;
148 unsigned char mdr1;
149 unsigned char scr;
150 unsigned char wer;
151
152 int use_dma;
153
154
155
156
157
158 unsigned int lsr_break_flag;
159 unsigned char msr_saved_flags;
160 char name[20];
161 unsigned long port_activity;
162 int context_loss_cnt;
163 u32 errata;
164 u32 features;
165
166 int rts_gpio;
167
168 struct pm_qos_request pm_qos_request;
169 u32 latency;
170 u32 calc_latency;
171 struct work_struct qos_work;
172 bool is_suspending;
173};
174
175#define to_uart_omap_port(p) ((container_of((p), struct uart_omap_port, port)))
176
177static struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS];
178
179
180static void serial_omap_mdr1_errataset(struct uart_omap_port *up, u8 mdr1);
181
182static inline unsigned int serial_in(struct uart_omap_port *up, int offset)
183{
184 offset <<= up->port.regshift;
185 return readw(up->port.membase + offset);
186}
187
188static inline void serial_out(struct uart_omap_port *up, int offset, int value)
189{
190 offset <<= up->port.regshift;
191 writew(value, up->port.membase + offset);
192}
193
194static inline void serial_omap_clear_fifos(struct uart_omap_port *up)
195{
196 serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
197 serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
198 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
199 serial_out(up, UART_FCR, 0);
200}
201
202#ifdef CONFIG_PM
203static int serial_omap_get_context_loss_count(struct uart_omap_port *up)
204{
205 struct omap_uart_port_info *pdata = dev_get_platdata(up->dev);
206
207 if (!pdata || !pdata->get_context_loss_count)
208 return -EINVAL;
209
210 return pdata->get_context_loss_count(up->dev);
211}
212
213
214static void serial_omap_enable_wakeup(struct uart_omap_port *up, bool enable)
215{
216 struct omap_uart_port_info *pdata = dev_get_platdata(up->dev);
217
218 if (!pdata || !pdata->enable_wakeup)
219 return;
220
221 pdata->enable_wakeup(up->dev, enable);
222}
223#endif
224
225
226
227
228
229static inline int calculate_baud_abs_diff(struct uart_port *port,
230 unsigned int baud, unsigned int mode)
231{
232 unsigned int n = port->uartclk / (mode * baud);
233 int abs_diff;
234
235 if (n == 0)
236 n = 1;
237
238 abs_diff = baud - (port->uartclk / (mode * n));
239 if (abs_diff < 0)
240 abs_diff = -abs_diff;
241
242 return abs_diff;
243}
244
245
246
247
248
249
250
251
252
253
254
255
256static bool
257serial_omap_baud_is_mode16(struct uart_port *port, unsigned int baud)
258{
259 int abs_diff_13 = calculate_baud_abs_diff(port, baud, 13);
260 int abs_diff_16 = calculate_baud_abs_diff(port, baud, 16);
261
262 return (abs_diff_13 >= abs_diff_16);
263}
264
265
266
267
268
269
270static unsigned int
271serial_omap_get_divisor(struct uart_port *port, unsigned int baud)
272{
273 unsigned int mode;
274
275 if (!serial_omap_baud_is_mode16(port, baud))
276 mode = 13;
277 else
278 mode = 16;
279 return port->uartclk/(mode * baud);
280}
281
282static void serial_omap_enable_ms(struct uart_port *port)
283{
284 struct uart_omap_port *up = to_uart_omap_port(port);
285
286 dev_dbg(up->port.dev, "serial_omap_enable_ms+%d\n", up->port.line);
287
288 pm_runtime_get_sync(up->dev);
289 up->ier |= UART_IER_MSI;
290 serial_out(up, UART_IER, up->ier);
291 pm_runtime_mark_last_busy(up->dev);
292 pm_runtime_put_autosuspend(up->dev);
293}
294
295static void serial_omap_stop_tx(struct uart_port *port)
296{
297 struct uart_omap_port *up = to_uart_omap_port(port);
298 int res;
299
300 pm_runtime_get_sync(up->dev);
301
302
303 if (port->rs485.flags & SER_RS485_ENABLED) {
304 if (up->scr & OMAP_UART_SCR_TX_EMPTY) {
305
306
307
308
309
310
311
312 up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
313 serial_out(up, UART_OMAP_SCR, up->scr);
314 res = (port->rs485.flags & SER_RS485_RTS_AFTER_SEND) ?
315 1 : 0;
316 if (gpio_get_value(up->rts_gpio) != res) {
317 if (port->rs485.delay_rts_after_send > 0)
318 mdelay(
319 port->rs485.delay_rts_after_send);
320 gpio_set_value(up->rts_gpio, res);
321 }
322 } else {
323
324
325
326
327
328
329
330
331 up->scr |= OMAP_UART_SCR_TX_EMPTY;
332 serial_out(up, UART_OMAP_SCR, up->scr);
333 return;
334 }
335 }
336
337 if (up->ier & UART_IER_THRI) {
338 up->ier &= ~UART_IER_THRI;
339 serial_out(up, UART_IER, up->ier);
340 }
341
342 if ((port->rs485.flags & SER_RS485_ENABLED) &&
343 !(port->rs485.flags & SER_RS485_RX_DURING_TX)) {
344
345
346
347
348 serial_out(up, UART_FCR, up->fcr | UART_FCR_CLEAR_RCVR);
349
350 up->ier |= UART_IER_RLSI | UART_IER_RDI;
351 up->port.read_status_mask |= UART_LSR_DR;
352 serial_out(up, UART_IER, up->ier);
353 }
354
355 pm_runtime_mark_last_busy(up->dev);
356 pm_runtime_put_autosuspend(up->dev);
357}
358
359static void serial_omap_stop_rx(struct uart_port *port)
360{
361 struct uart_omap_port *up = to_uart_omap_port(port);
362
363 pm_runtime_get_sync(up->dev);
364 up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
365 up->port.read_status_mask &= ~UART_LSR_DR;
366 serial_out(up, UART_IER, up->ier);
367 pm_runtime_mark_last_busy(up->dev);
368 pm_runtime_put_autosuspend(up->dev);
369}
370
371static void transmit_chars(struct uart_omap_port *up, unsigned int lsr)
372{
373 struct circ_buf *xmit = &up->port.state->xmit;
374 int count;
375
376 if (up->port.x_char) {
377 serial_out(up, UART_TX, up->port.x_char);
378 up->port.icount.tx++;
379 up->port.x_char = 0;
380 return;
381 }
382 if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
383 serial_omap_stop_tx(&up->port);
384 return;
385 }
386 count = up->port.fifosize / 4;
387 do {
388 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
389 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
390 up->port.icount.tx++;
391 if (uart_circ_empty(xmit))
392 break;
393 } while (--count > 0);
394
395 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
396 uart_write_wakeup(&up->port);
397
398 if (uart_circ_empty(xmit))
399 serial_omap_stop_tx(&up->port);
400}
401
402static inline void serial_omap_enable_ier_thri(struct uart_omap_port *up)
403{
404 if (!(up->ier & UART_IER_THRI)) {
405 up->ier |= UART_IER_THRI;
406 serial_out(up, UART_IER, up->ier);
407 }
408}
409
410static void serial_omap_start_tx(struct uart_port *port)
411{
412 struct uart_omap_port *up = to_uart_omap_port(port);
413 int res;
414
415 pm_runtime_get_sync(up->dev);
416
417
418 if (port->rs485.flags & SER_RS485_ENABLED) {
419
420 up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
421 serial_out(up, UART_OMAP_SCR, up->scr);
422
423
424 res = (port->rs485.flags & SER_RS485_RTS_ON_SEND) ? 1 : 0;
425 if (gpio_get_value(up->rts_gpio) != res) {
426 gpio_set_value(up->rts_gpio, res);
427 if (port->rs485.delay_rts_before_send > 0)
428 mdelay(port->rs485.delay_rts_before_send);
429 }
430 }
431
432 if ((port->rs485.flags & SER_RS485_ENABLED) &&
433 !(port->rs485.flags & SER_RS485_RX_DURING_TX))
434 serial_omap_stop_rx(port);
435
436 serial_omap_enable_ier_thri(up);
437 pm_runtime_mark_last_busy(up->dev);
438 pm_runtime_put_autosuspend(up->dev);
439}
440
441static void serial_omap_throttle(struct uart_port *port)
442{
443 struct uart_omap_port *up = to_uart_omap_port(port);
444 unsigned long flags;
445
446 pm_runtime_get_sync(up->dev);
447 spin_lock_irqsave(&up->port.lock, flags);
448 up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
449 serial_out(up, UART_IER, up->ier);
450 spin_unlock_irqrestore(&up->port.lock, flags);
451 pm_runtime_mark_last_busy(up->dev);
452 pm_runtime_put_autosuspend(up->dev);
453}
454
455static void serial_omap_unthrottle(struct uart_port *port)
456{
457 struct uart_omap_port *up = to_uart_omap_port(port);
458 unsigned long flags;
459
460 pm_runtime_get_sync(up->dev);
461 spin_lock_irqsave(&up->port.lock, flags);
462 up->ier |= UART_IER_RLSI | UART_IER_RDI;
463 serial_out(up, UART_IER, up->ier);
464 spin_unlock_irqrestore(&up->port.lock, flags);
465 pm_runtime_mark_last_busy(up->dev);
466 pm_runtime_put_autosuspend(up->dev);
467}
468
469static unsigned int check_modem_status(struct uart_omap_port *up)
470{
471 unsigned int status;
472
473 status = serial_in(up, UART_MSR);
474 status |= up->msr_saved_flags;
475 up->msr_saved_flags = 0;
476 if ((status & UART_MSR_ANY_DELTA) == 0)
477 return status;
478
479 if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
480 up->port.state != NULL) {
481 if (status & UART_MSR_TERI)
482 up->port.icount.rng++;
483 if (status & UART_MSR_DDSR)
484 up->port.icount.dsr++;
485 if (status & UART_MSR_DDCD)
486 uart_handle_dcd_change
487 (&up->port, status & UART_MSR_DCD);
488 if (status & UART_MSR_DCTS)
489 uart_handle_cts_change
490 (&up->port, status & UART_MSR_CTS);
491 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
492 }
493
494 return status;
495}
496
497static void serial_omap_rlsi(struct uart_omap_port *up, unsigned int lsr)
498{
499 unsigned int flag;
500 unsigned char ch = 0;
501
502 if (likely(lsr & UART_LSR_DR))
503 ch = serial_in(up, UART_RX);
504
505 up->port.icount.rx++;
506 flag = TTY_NORMAL;
507
508 if (lsr & UART_LSR_BI) {
509 flag = TTY_BREAK;
510 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
511 up->port.icount.brk++;
512
513
514
515
516
517
518 if (uart_handle_break(&up->port))
519 return;
520
521 }
522
523 if (lsr & UART_LSR_PE) {
524 flag = TTY_PARITY;
525 up->port.icount.parity++;
526 }
527
528 if (lsr & UART_LSR_FE) {
529 flag = TTY_FRAME;
530 up->port.icount.frame++;
531 }
532
533 if (lsr & UART_LSR_OE)
534 up->port.icount.overrun++;
535
536#ifdef CONFIG_SERIAL_OMAP_CONSOLE
537 if (up->port.line == up->port.cons->index) {
538
539 lsr |= up->lsr_break_flag;
540 }
541#endif
542 uart_insert_char(&up->port, lsr, UART_LSR_OE, 0, flag);
543}
544
545static void serial_omap_rdi(struct uart_omap_port *up, unsigned int lsr)
546{
547 unsigned char ch = 0;
548 unsigned int flag;
549
550 if (!(lsr & UART_LSR_DR))
551 return;
552
553 ch = serial_in(up, UART_RX);
554 flag = TTY_NORMAL;
555 up->port.icount.rx++;
556
557 if (uart_handle_sysrq_char(&up->port, ch))
558 return;
559
560 uart_insert_char(&up->port, lsr, UART_LSR_OE, ch, flag);
561}
562
563
564
565
566
567
568static irqreturn_t serial_omap_irq(int irq, void *dev_id)
569{
570 struct uart_omap_port *up = dev_id;
571 unsigned int iir, lsr;
572 unsigned int type;
573 irqreturn_t ret = IRQ_NONE;
574 int max_count = 256;
575
576 spin_lock(&up->port.lock);
577 pm_runtime_get_sync(up->dev);
578
579 do {
580 iir = serial_in(up, UART_IIR);
581 if (iir & UART_IIR_NO_INT)
582 break;
583
584 ret = IRQ_HANDLED;
585 lsr = serial_in(up, UART_LSR);
586
587
588 type = iir & 0x3e;
589
590 switch (type) {
591 case UART_IIR_MSI:
592 check_modem_status(up);
593 break;
594 case UART_IIR_THRI:
595 transmit_chars(up, lsr);
596 break;
597 case UART_IIR_RX_TIMEOUT:
598
599 case UART_IIR_RDI:
600 serial_omap_rdi(up, lsr);
601 break;
602 case UART_IIR_RLSI:
603 serial_omap_rlsi(up, lsr);
604 break;
605 case UART_IIR_CTS_RTS_DSR:
606
607 break;
608 case UART_IIR_XOFF:
609
610 default:
611 break;
612 }
613 } while (!(iir & UART_IIR_NO_INT) && max_count--);
614
615 spin_unlock(&up->port.lock);
616
617 tty_flip_buffer_push(&up->port.state->port);
618
619 pm_runtime_mark_last_busy(up->dev);
620 pm_runtime_put_autosuspend(up->dev);
621 up->port_activity = jiffies;
622
623 return ret;
624}
625
626static unsigned int serial_omap_tx_empty(struct uart_port *port)
627{
628 struct uart_omap_port *up = to_uart_omap_port(port);
629 unsigned long flags = 0;
630 unsigned int ret = 0;
631
632 pm_runtime_get_sync(up->dev);
633 dev_dbg(up->port.dev, "serial_omap_tx_empty+%d\n", up->port.line);
634 spin_lock_irqsave(&up->port.lock, flags);
635 ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
636 spin_unlock_irqrestore(&up->port.lock, flags);
637 pm_runtime_mark_last_busy(up->dev);
638 pm_runtime_put_autosuspend(up->dev);
639 return ret;
640}
641
642static unsigned int serial_omap_get_mctrl(struct uart_port *port)
643{
644 struct uart_omap_port *up = to_uart_omap_port(port);
645 unsigned int status;
646 unsigned int ret = 0;
647
648 pm_runtime_get_sync(up->dev);
649 status = check_modem_status(up);
650 pm_runtime_mark_last_busy(up->dev);
651 pm_runtime_put_autosuspend(up->dev);
652
653 dev_dbg(up->port.dev, "serial_omap_get_mctrl+%d\n", up->port.line);
654
655 if (status & UART_MSR_DCD)
656 ret |= TIOCM_CAR;
657 if (status & UART_MSR_RI)
658 ret |= TIOCM_RNG;
659 if (status & UART_MSR_DSR)
660 ret |= TIOCM_DSR;
661 if (status & UART_MSR_CTS)
662 ret |= TIOCM_CTS;
663 return ret;
664}
665
666static void serial_omap_set_mctrl(struct uart_port *port, unsigned int mctrl)
667{
668 struct uart_omap_port *up = to_uart_omap_port(port);
669 unsigned char mcr = 0, old_mcr, lcr;
670
671 dev_dbg(up->port.dev, "serial_omap_set_mctrl+%d\n", up->port.line);
672 if (mctrl & TIOCM_RTS)
673 mcr |= UART_MCR_RTS;
674 if (mctrl & TIOCM_DTR)
675 mcr |= UART_MCR_DTR;
676 if (mctrl & TIOCM_OUT1)
677 mcr |= UART_MCR_OUT1;
678 if (mctrl & TIOCM_OUT2)
679 mcr |= UART_MCR_OUT2;
680 if (mctrl & TIOCM_LOOP)
681 mcr |= UART_MCR_LOOP;
682
683 pm_runtime_get_sync(up->dev);
684 old_mcr = serial_in(up, UART_MCR);
685 old_mcr &= ~(UART_MCR_LOOP | UART_MCR_OUT2 | UART_MCR_OUT1 |
686 UART_MCR_DTR | UART_MCR_RTS);
687 up->mcr = old_mcr | mcr;
688 serial_out(up, UART_MCR, up->mcr);
689
690
691 lcr = serial_in(up, UART_LCR);
692 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
693 if ((mctrl & TIOCM_RTS) && (port->status & UPSTAT_AUTORTS))
694 up->efr |= UART_EFR_RTS;
695 else
696 up->efr &= UART_EFR_RTS;
697 serial_out(up, UART_EFR, up->efr);
698 serial_out(up, UART_LCR, lcr);
699
700 pm_runtime_mark_last_busy(up->dev);
701 pm_runtime_put_autosuspend(up->dev);
702}
703
704static void serial_omap_break_ctl(struct uart_port *port, int break_state)
705{
706 struct uart_omap_port *up = to_uart_omap_port(port);
707 unsigned long flags = 0;
708
709 dev_dbg(up->port.dev, "serial_omap_break_ctl+%d\n", up->port.line);
710 pm_runtime_get_sync(up->dev);
711 spin_lock_irqsave(&up->port.lock, flags);
712 if (break_state == -1)
713 up->lcr |= UART_LCR_SBC;
714 else
715 up->lcr &= ~UART_LCR_SBC;
716 serial_out(up, UART_LCR, up->lcr);
717 spin_unlock_irqrestore(&up->port.lock, flags);
718 pm_runtime_mark_last_busy(up->dev);
719 pm_runtime_put_autosuspend(up->dev);
720}
721
722static int serial_omap_startup(struct uart_port *port)
723{
724 struct uart_omap_port *up = to_uart_omap_port(port);
725 unsigned long flags = 0;
726 int retval;
727
728
729
730
731 retval = request_irq(up->port.irq, serial_omap_irq, up->port.irqflags,
732 up->name, up);
733 if (retval)
734 return retval;
735
736
737 if (up->wakeirq) {
738 retval = dev_pm_set_dedicated_wake_irq(up->dev, up->wakeirq);
739 if (retval) {
740 free_irq(up->port.irq, up);
741 return retval;
742 }
743 }
744
745 dev_dbg(up->port.dev, "serial_omap_startup+%d\n", up->port.line);
746
747 pm_runtime_get_sync(up->dev);
748
749
750
751
752 serial_omap_clear_fifos(up);
753
754
755
756
757 (void) serial_in(up, UART_LSR);
758 if (serial_in(up, UART_LSR) & UART_LSR_DR)
759 (void) serial_in(up, UART_RX);
760 (void) serial_in(up, UART_IIR);
761 (void) serial_in(up, UART_MSR);
762
763
764
765
766 serial_out(up, UART_LCR, UART_LCR_WLEN8);
767 spin_lock_irqsave(&up->port.lock, flags);
768
769
770
771 up->port.mctrl |= TIOCM_OUT2;
772 serial_omap_set_mctrl(&up->port, up->port.mctrl);
773 spin_unlock_irqrestore(&up->port.lock, flags);
774
775 up->msr_saved_flags = 0;
776
777
778
779
780
781 up->ier = UART_IER_RLSI | UART_IER_RDI;
782 serial_out(up, UART_IER, up->ier);
783
784
785 up->wer = OMAP_UART_WER_MOD_WKUP;
786 if (up->features & OMAP_UART_WER_HAS_TX_WAKEUP)
787 up->wer |= OMAP_UART_TX_WAKEUP_EN;
788
789 serial_out(up, UART_OMAP_WER, up->wer);
790
791 pm_runtime_mark_last_busy(up->dev);
792 pm_runtime_put_autosuspend(up->dev);
793 up->port_activity = jiffies;
794 return 0;
795}
796
797static void serial_omap_shutdown(struct uart_port *port)
798{
799 struct uart_omap_port *up = to_uart_omap_port(port);
800 unsigned long flags = 0;
801
802 dev_dbg(up->port.dev, "serial_omap_shutdown+%d\n", up->port.line);
803
804 pm_runtime_get_sync(up->dev);
805
806
807
808 up->ier = 0;
809 serial_out(up, UART_IER, 0);
810
811 spin_lock_irqsave(&up->port.lock, flags);
812 up->port.mctrl &= ~TIOCM_OUT2;
813 serial_omap_set_mctrl(&up->port, up->port.mctrl);
814 spin_unlock_irqrestore(&up->port.lock, flags);
815
816
817
818
819 serial_out(up, UART_LCR, serial_in(up, UART_LCR) & ~UART_LCR_SBC);
820 serial_omap_clear_fifos(up);
821
822
823
824
825 if (serial_in(up, UART_LSR) & UART_LSR_DR)
826 (void) serial_in(up, UART_RX);
827
828 pm_runtime_mark_last_busy(up->dev);
829 pm_runtime_put_autosuspend(up->dev);
830 free_irq(up->port.irq, up);
831 dev_pm_clear_wake_irq(up->dev);
832}
833
834static void serial_omap_uart_qos_work(struct work_struct *work)
835{
836 struct uart_omap_port *up = container_of(work, struct uart_omap_port,
837 qos_work);
838
839 pm_qos_update_request(&up->pm_qos_request, up->latency);
840}
841
842static void
843serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
844 struct ktermios *old)
845{
846 struct uart_omap_port *up = to_uart_omap_port(port);
847 unsigned char cval = 0;
848 unsigned long flags = 0;
849 unsigned int baud, quot;
850
851 switch (termios->c_cflag & CSIZE) {
852 case CS5:
853 cval = UART_LCR_WLEN5;
854 break;
855 case CS6:
856 cval = UART_LCR_WLEN6;
857 break;
858 case CS7:
859 cval = UART_LCR_WLEN7;
860 break;
861 default:
862 case CS8:
863 cval = UART_LCR_WLEN8;
864 break;
865 }
866
867 if (termios->c_cflag & CSTOPB)
868 cval |= UART_LCR_STOP;
869 if (termios->c_cflag & PARENB)
870 cval |= UART_LCR_PARITY;
871 if (!(termios->c_cflag & PARODD))
872 cval |= UART_LCR_EPAR;
873 if (termios->c_cflag & CMSPAR)
874 cval |= UART_LCR_SPAR;
875
876
877
878
879
880 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/13);
881 quot = serial_omap_get_divisor(port, baud);
882
883
884 up->calc_latency = (USEC_PER_SEC * up->port.fifosize) / (baud / 8);
885 up->latency = up->calc_latency;
886 schedule_work(&up->qos_work);
887
888 up->dll = quot & 0xff;
889 up->dlh = quot >> 8;
890 up->mdr1 = UART_OMAP_MDR1_DISABLE;
891
892 up->fcr = UART_FCR_R_TRIG_01 | UART_FCR_T_TRIG_01 |
893 UART_FCR_ENABLE_FIFO;
894
895
896
897
898
899 pm_runtime_get_sync(up->dev);
900 spin_lock_irqsave(&up->port.lock, flags);
901
902
903
904
905 uart_update_timeout(port, termios->c_cflag, baud);
906
907 up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
908 if (termios->c_iflag & INPCK)
909 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
910 if (termios->c_iflag & (BRKINT | PARMRK))
911 up->port.read_status_mask |= UART_LSR_BI;
912
913
914
915
916 up->port.ignore_status_mask = 0;
917 if (termios->c_iflag & IGNPAR)
918 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
919 if (termios->c_iflag & IGNBRK) {
920 up->port.ignore_status_mask |= UART_LSR_BI;
921
922
923
924
925 if (termios->c_iflag & IGNPAR)
926 up->port.ignore_status_mask |= UART_LSR_OE;
927 }
928
929
930
931
932 if ((termios->c_cflag & CREAD) == 0)
933 up->port.ignore_status_mask |= UART_LSR_DR;
934
935
936
937
938 up->ier &= ~UART_IER_MSI;
939 if (UART_ENABLE_MS(&up->port, termios->c_cflag))
940 up->ier |= UART_IER_MSI;
941 serial_out(up, UART_IER, up->ier);
942 serial_out(up, UART_LCR, cval);
943 up->lcr = cval;
944 up->scr = 0;
945
946
947
948
949
950
951
952 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
953 serial_out(up, UART_DLL, 0);
954 serial_out(up, UART_DLM, 0);
955 serial_out(up, UART_LCR, 0);
956
957 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
958
959 up->efr = serial_in(up, UART_EFR) & ~UART_EFR_ECB;
960 up->efr &= ~UART_EFR_SCD;
961 serial_out(up, UART_EFR, up->efr | UART_EFR_ECB);
962
963 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
964 up->mcr = serial_in(up, UART_MCR) & ~UART_MCR_TCRTLR;
965 serial_out(up, UART_MCR, up->mcr | UART_MCR_TCRTLR);
966
967
968 up->scr |= OMAP_UART_SCR_RX_TRIG_GRANU1_MASK;
969
970
971
972
973
974
975
976
977
978
979
980
981
982 up->fcr &= ~OMAP_UART_FCR_RX_FIFO_TRIG_MASK;
983 up->fcr &= ~OMAP_UART_FCR_TX_FIFO_TRIG_MASK;
984 up->fcr |= UART_FCR6_R_TRIGGER_16 | UART_FCR6_T_TRIGGER_24 |
985 UART_FCR_ENABLE_FIFO;
986
987 serial_out(up, UART_FCR, up->fcr);
988 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
989
990 serial_out(up, UART_OMAP_SCR, up->scr);
991
992
993 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
994 serial_out(up, UART_MCR, up->mcr);
995 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
996 serial_out(up, UART_EFR, up->efr);
997 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
998
999
1000
1001 if (up->errata & UART_ERRATA_i202_MDR1_ACCESS)
1002 serial_omap_mdr1_errataset(up, up->mdr1);
1003 else
1004 serial_out(up, UART_OMAP_MDR1, up->mdr1);
1005
1006 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1007 serial_out(up, UART_EFR, up->efr | UART_EFR_ECB);
1008
1009 serial_out(up, UART_LCR, 0);
1010 serial_out(up, UART_IER, 0);
1011 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1012
1013 serial_out(up, UART_DLL, up->dll);
1014 serial_out(up, UART_DLM, up->dlh);
1015
1016 serial_out(up, UART_LCR, 0);
1017 serial_out(up, UART_IER, up->ier);
1018 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1019
1020 serial_out(up, UART_EFR, up->efr);
1021 serial_out(up, UART_LCR, cval);
1022
1023 if (!serial_omap_baud_is_mode16(port, baud))
1024 up->mdr1 = UART_OMAP_MDR1_13X_MODE;
1025 else
1026 up->mdr1 = UART_OMAP_MDR1_16X_MODE;
1027
1028 if (up->errata & UART_ERRATA_i202_MDR1_ACCESS)
1029 serial_omap_mdr1_errataset(up, up->mdr1);
1030 else
1031 serial_out(up, UART_OMAP_MDR1, up->mdr1);
1032
1033
1034 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1035
1036
1037 serial_out(up, UART_XON1, termios->c_cc[VSTART]);
1038 serial_out(up, UART_XOFF1, termios->c_cc[VSTOP]);
1039
1040
1041 serial_out(up, UART_EFR, up->efr | UART_EFR_ECB);
1042 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
1043 serial_out(up, UART_MCR, up->mcr | UART_MCR_TCRTLR);
1044
1045 serial_out(up, UART_TI752_TCR, OMAP_UART_TCR_TRIG);
1046
1047 up->port.status &= ~(UPSTAT_AUTOCTS | UPSTAT_AUTORTS | UPSTAT_AUTOXOFF);
1048
1049 if (termios->c_cflag & CRTSCTS && up->port.flags & UPF_HARD_FLOW) {
1050
1051 up->port.status |= UPSTAT_AUTOCTS | UPSTAT_AUTORTS;
1052 up->efr |= UART_EFR_CTS;
1053 } else {
1054
1055 up->efr &= ~(UART_EFR_CTS | UART_EFR_RTS);
1056 }
1057
1058 if (up->port.flags & UPF_SOFT_FLOW) {
1059
1060 up->efr &= OMAP_UART_SW_CLR;
1061
1062
1063
1064
1065
1066
1067 if (termios->c_iflag & IXON)
1068 up->efr |= OMAP_UART_SW_RX;
1069
1070
1071
1072
1073
1074
1075 if (termios->c_iflag & IXOFF) {
1076 up->port.status |= UPSTAT_AUTOXOFF;
1077 up->efr |= OMAP_UART_SW_TX;
1078 }
1079
1080
1081
1082
1083
1084
1085
1086 if (termios->c_iflag & IXANY)
1087 up->mcr |= UART_MCR_XONANY;
1088 else
1089 up->mcr &= ~UART_MCR_XONANY;
1090 }
1091 serial_out(up, UART_MCR, up->mcr);
1092 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1093 serial_out(up, UART_EFR, up->efr);
1094 serial_out(up, UART_LCR, up->lcr);
1095
1096 serial_omap_set_mctrl(&up->port, up->port.mctrl);
1097
1098 spin_unlock_irqrestore(&up->port.lock, flags);
1099 pm_runtime_mark_last_busy(up->dev);
1100 pm_runtime_put_autosuspend(up->dev);
1101 dev_dbg(up->port.dev, "serial_omap_set_termios+%d\n", up->port.line);
1102}
1103
1104static void
1105serial_omap_pm(struct uart_port *port, unsigned int state,
1106 unsigned int oldstate)
1107{
1108 struct uart_omap_port *up = to_uart_omap_port(port);
1109 unsigned char efr;
1110
1111 dev_dbg(up->port.dev, "serial_omap_pm+%d\n", up->port.line);
1112
1113 pm_runtime_get_sync(up->dev);
1114 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1115 efr = serial_in(up, UART_EFR);
1116 serial_out(up, UART_EFR, efr | UART_EFR_ECB);
1117 serial_out(up, UART_LCR, 0);
1118
1119 serial_out(up, UART_IER, (state != 0) ? UART_IERX_SLEEP : 0);
1120 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1121 serial_out(up, UART_EFR, efr);
1122 serial_out(up, UART_LCR, 0);
1123
1124 pm_runtime_mark_last_busy(up->dev);
1125 pm_runtime_put_autosuspend(up->dev);
1126}
1127
1128static void serial_omap_release_port(struct uart_port *port)
1129{
1130 dev_dbg(port->dev, "serial_omap_release_port+\n");
1131}
1132
1133static int serial_omap_request_port(struct uart_port *port)
1134{
1135 dev_dbg(port->dev, "serial_omap_request_port+\n");
1136 return 0;
1137}
1138
1139static void serial_omap_config_port(struct uart_port *port, int flags)
1140{
1141 struct uart_omap_port *up = to_uart_omap_port(port);
1142
1143 dev_dbg(up->port.dev, "serial_omap_config_port+%d\n",
1144 up->port.line);
1145 up->port.type = PORT_OMAP;
1146 up->port.flags |= UPF_SOFT_FLOW | UPF_HARD_FLOW;
1147}
1148
1149static int
1150serial_omap_verify_port(struct uart_port *port, struct serial_struct *ser)
1151{
1152
1153 dev_dbg(port->dev, "serial_omap_verify_port+\n");
1154 return -EINVAL;
1155}
1156
1157static const char *
1158serial_omap_type(struct uart_port *port)
1159{
1160 struct uart_omap_port *up = to_uart_omap_port(port);
1161
1162 dev_dbg(up->port.dev, "serial_omap_type+%d\n", up->port.line);
1163 return up->name;
1164}
1165
1166#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
1167
1168static void __maybe_unused wait_for_xmitr(struct uart_omap_port *up)
1169{
1170 unsigned int status, tmout = 10000;
1171
1172
1173 do {
1174 status = serial_in(up, UART_LSR);
1175
1176 if (status & UART_LSR_BI)
1177 up->lsr_break_flag = UART_LSR_BI;
1178
1179 if (--tmout == 0)
1180 break;
1181 udelay(1);
1182 } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
1183
1184
1185 if (up->port.flags & UPF_CONS_FLOW) {
1186 tmout = 1000000;
1187 for (tmout = 1000000; tmout; tmout--) {
1188 unsigned int msr = serial_in(up, UART_MSR);
1189
1190 up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
1191 if (msr & UART_MSR_CTS)
1192 break;
1193
1194 udelay(1);
1195 }
1196 }
1197}
1198
1199#ifdef CONFIG_CONSOLE_POLL
1200
1201static void serial_omap_poll_put_char(struct uart_port *port, unsigned char ch)
1202{
1203 struct uart_omap_port *up = to_uart_omap_port(port);
1204
1205 pm_runtime_get_sync(up->dev);
1206 wait_for_xmitr(up);
1207 serial_out(up, UART_TX, ch);
1208 pm_runtime_mark_last_busy(up->dev);
1209 pm_runtime_put_autosuspend(up->dev);
1210}
1211
1212static int serial_omap_poll_get_char(struct uart_port *port)
1213{
1214 struct uart_omap_port *up = to_uart_omap_port(port);
1215 unsigned int status;
1216
1217 pm_runtime_get_sync(up->dev);
1218 status = serial_in(up, UART_LSR);
1219 if (!(status & UART_LSR_DR)) {
1220 status = NO_POLL_CHAR;
1221 goto out;
1222 }
1223
1224 status = serial_in(up, UART_RX);
1225
1226out:
1227 pm_runtime_mark_last_busy(up->dev);
1228 pm_runtime_put_autosuspend(up->dev);
1229
1230 return status;
1231}
1232
1233#endif
1234
1235#ifdef CONFIG_SERIAL_OMAP_CONSOLE
1236
1237#ifdef CONFIG_SERIAL_EARLYCON
1238static unsigned int __init omap_serial_early_in(struct uart_port *port,
1239 int offset)
1240{
1241 offset <<= port->regshift;
1242 return readw(port->membase + offset);
1243}
1244
1245static void __init omap_serial_early_out(struct uart_port *port, int offset,
1246 int value)
1247{
1248 offset <<= port->regshift;
1249 writew(value, port->membase + offset);
1250}
1251
1252static void __init omap_serial_early_putc(struct uart_port *port, int c)
1253{
1254 unsigned int status;
1255
1256 for (;;) {
1257 status = omap_serial_early_in(port, UART_LSR);
1258 if ((status & BOTH_EMPTY) == BOTH_EMPTY)
1259 break;
1260 cpu_relax();
1261 }
1262 omap_serial_early_out(port, UART_TX, c);
1263}
1264
1265static void __init early_omap_serial_write(struct console *console,
1266 const char *s, unsigned int count)
1267{
1268 struct earlycon_device *device = console->data;
1269 struct uart_port *port = &device->port;
1270
1271 uart_console_write(port, s, count, omap_serial_early_putc);
1272}
1273
1274static int __init early_omap_serial_setup(struct earlycon_device *device,
1275 const char *options)
1276{
1277 struct uart_port *port = &device->port;
1278
1279 if (!(device->port.membase || device->port.iobase))
1280 return -ENODEV;
1281
1282 port->regshift = 2;
1283 device->con->write = early_omap_serial_write;
1284 return 0;
1285}
1286
1287OF_EARLYCON_DECLARE(omapserial, "ti,omap2-uart", early_omap_serial_setup);
1288OF_EARLYCON_DECLARE(omapserial, "ti,omap3-uart", early_omap_serial_setup);
1289OF_EARLYCON_DECLARE(omapserial, "ti,omap4-uart", early_omap_serial_setup);
1290#endif
1291
1292static struct uart_omap_port *serial_omap_console_ports[OMAP_MAX_HSUART_PORTS];
1293
1294static struct uart_driver serial_omap_reg;
1295
1296static void serial_omap_console_putchar(struct uart_port *port, int ch)
1297{
1298 struct uart_omap_port *up = to_uart_omap_port(port);
1299
1300 wait_for_xmitr(up);
1301 serial_out(up, UART_TX, ch);
1302}
1303
1304static void
1305serial_omap_console_write(struct console *co, const char *s,
1306 unsigned int count)
1307{
1308 struct uart_omap_port *up = serial_omap_console_ports[co->index];
1309 unsigned long flags;
1310 unsigned int ier;
1311 int locked = 1;
1312
1313 pm_runtime_get_sync(up->dev);
1314
1315 local_irq_save(flags);
1316 if (up->port.sysrq)
1317 locked = 0;
1318 else if (oops_in_progress)
1319 locked = spin_trylock(&up->port.lock);
1320 else
1321 spin_lock(&up->port.lock);
1322
1323
1324
1325
1326 ier = serial_in(up, UART_IER);
1327 serial_out(up, UART_IER, 0);
1328
1329 uart_console_write(&up->port, s, count, serial_omap_console_putchar);
1330
1331
1332
1333
1334
1335 wait_for_xmitr(up);
1336 serial_out(up, UART_IER, ier);
1337
1338
1339
1340
1341
1342
1343
1344 if (up->msr_saved_flags)
1345 check_modem_status(up);
1346
1347 pm_runtime_mark_last_busy(up->dev);
1348 pm_runtime_put_autosuspend(up->dev);
1349 if (locked)
1350 spin_unlock(&up->port.lock);
1351 local_irq_restore(flags);
1352}
1353
1354static int __init
1355serial_omap_console_setup(struct console *co, char *options)
1356{
1357 struct uart_omap_port *up;
1358 int baud = 115200;
1359 int bits = 8;
1360 int parity = 'n';
1361 int flow = 'n';
1362
1363 if (serial_omap_console_ports[co->index] == NULL)
1364 return -ENODEV;
1365 up = serial_omap_console_ports[co->index];
1366
1367 if (options)
1368 uart_parse_options(options, &baud, &parity, &bits, &flow);
1369
1370 return uart_set_options(&up->port, co, baud, parity, bits, flow);
1371}
1372
1373static struct console serial_omap_console = {
1374 .name = OMAP_SERIAL_NAME,
1375 .write = serial_omap_console_write,
1376 .device = uart_console_device,
1377 .setup = serial_omap_console_setup,
1378 .flags = CON_PRINTBUFFER,
1379 .index = -1,
1380 .data = &serial_omap_reg,
1381};
1382
1383static void serial_omap_add_console_port(struct uart_omap_port *up)
1384{
1385 serial_omap_console_ports[up->port.line] = up;
1386}
1387
1388#define OMAP_CONSOLE (&serial_omap_console)
1389
1390#else
1391
1392#define OMAP_CONSOLE NULL
1393
1394static inline void serial_omap_add_console_port(struct uart_omap_port *up)
1395{}
1396
1397#endif
1398
1399
1400static int
1401serial_omap_config_rs485(struct uart_port *port, struct serial_rs485 *rs485)
1402{
1403 struct uart_omap_port *up = to_uart_omap_port(port);
1404 unsigned int mode;
1405 int val;
1406
1407 pm_runtime_get_sync(up->dev);
1408
1409
1410 mode = up->ier;
1411 up->ier = 0;
1412 serial_out(up, UART_IER, 0);
1413
1414
1415 rs485->delay_rts_before_send = min(rs485->delay_rts_before_send, 100U);
1416 rs485->delay_rts_after_send = min(rs485->delay_rts_after_send, 100U);
1417
1418
1419 port->rs485 = *rs485;
1420
1421
1422
1423
1424
1425 if (gpio_is_valid(up->rts_gpio)) {
1426
1427 val = (port->rs485.flags & SER_RS485_ENABLED) ?
1428 SER_RS485_RTS_AFTER_SEND : SER_RS485_RTS_ON_SEND;
1429 val = (port->rs485.flags & val) ? 1 : 0;
1430 gpio_set_value(up->rts_gpio, val);
1431 } else
1432 port->rs485.flags &= ~SER_RS485_ENABLED;
1433
1434
1435 up->ier = mode;
1436 serial_out(up, UART_IER, up->ier);
1437
1438
1439
1440
1441 if (!(port->rs485.flags & SER_RS485_ENABLED) &&
1442 (up->scr & OMAP_UART_SCR_TX_EMPTY)) {
1443 up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
1444 serial_out(up, UART_OMAP_SCR, up->scr);
1445 }
1446
1447 pm_runtime_mark_last_busy(up->dev);
1448 pm_runtime_put_autosuspend(up->dev);
1449
1450 return 0;
1451}
1452
1453static const struct uart_ops serial_omap_pops = {
1454 .tx_empty = serial_omap_tx_empty,
1455 .set_mctrl = serial_omap_set_mctrl,
1456 .get_mctrl = serial_omap_get_mctrl,
1457 .stop_tx = serial_omap_stop_tx,
1458 .start_tx = serial_omap_start_tx,
1459 .throttle = serial_omap_throttle,
1460 .unthrottle = serial_omap_unthrottle,
1461 .stop_rx = serial_omap_stop_rx,
1462 .enable_ms = serial_omap_enable_ms,
1463 .break_ctl = serial_omap_break_ctl,
1464 .startup = serial_omap_startup,
1465 .shutdown = serial_omap_shutdown,
1466 .set_termios = serial_omap_set_termios,
1467 .pm = serial_omap_pm,
1468 .type = serial_omap_type,
1469 .release_port = serial_omap_release_port,
1470 .request_port = serial_omap_request_port,
1471 .config_port = serial_omap_config_port,
1472 .verify_port = serial_omap_verify_port,
1473#ifdef CONFIG_CONSOLE_POLL
1474 .poll_put_char = serial_omap_poll_put_char,
1475 .poll_get_char = serial_omap_poll_get_char,
1476#endif
1477};
1478
1479static struct uart_driver serial_omap_reg = {
1480 .owner = THIS_MODULE,
1481 .driver_name = "OMAP-SERIAL",
1482 .dev_name = OMAP_SERIAL_NAME,
1483 .nr = OMAP_MAX_HSUART_PORTS,
1484 .cons = OMAP_CONSOLE,
1485};
1486
1487#ifdef CONFIG_PM_SLEEP
1488static int serial_omap_prepare(struct device *dev)
1489{
1490 struct uart_omap_port *up = dev_get_drvdata(dev);
1491
1492 up->is_suspending = true;
1493
1494 return 0;
1495}
1496
1497static void serial_omap_complete(struct device *dev)
1498{
1499 struct uart_omap_port *up = dev_get_drvdata(dev);
1500
1501 up->is_suspending = false;
1502}
1503
1504static int serial_omap_suspend(struct device *dev)
1505{
1506 struct uart_omap_port *up = dev_get_drvdata(dev);
1507
1508 uart_suspend_port(&serial_omap_reg, &up->port);
1509 flush_work(&up->qos_work);
1510
1511 if (device_may_wakeup(dev))
1512 serial_omap_enable_wakeup(up, true);
1513 else
1514 serial_omap_enable_wakeup(up, false);
1515
1516 return 0;
1517}
1518
1519static int serial_omap_resume(struct device *dev)
1520{
1521 struct uart_omap_port *up = dev_get_drvdata(dev);
1522
1523 if (device_may_wakeup(dev))
1524 serial_omap_enable_wakeup(up, false);
1525
1526 uart_resume_port(&serial_omap_reg, &up->port);
1527
1528 return 0;
1529}
1530#else
1531#define serial_omap_prepare NULL
1532#define serial_omap_complete NULL
1533#endif
1534
1535static void omap_serial_fill_features_erratas(struct uart_omap_port *up)
1536{
1537 u32 mvr, scheme;
1538 u16 revision, major, minor;
1539
1540 mvr = readl(up->port.membase + (UART_OMAP_MVER << up->port.regshift));
1541
1542
1543 scheme = mvr >> OMAP_UART_MVR_SCHEME_SHIFT;
1544
1545 switch (scheme) {
1546 case 0:
1547
1548 major = (mvr & OMAP_UART_LEGACY_MVR_MAJ_MASK) >>
1549 OMAP_UART_LEGACY_MVR_MAJ_SHIFT;
1550 minor = (mvr & OMAP_UART_LEGACY_MVR_MIN_MASK);
1551 break;
1552 case 1:
1553
1554
1555 major = (mvr & OMAP_UART_MVR_MAJ_MASK) >>
1556 OMAP_UART_MVR_MAJ_SHIFT;
1557 minor = (mvr & OMAP_UART_MVR_MIN_MASK);
1558 break;
1559 default:
1560 dev_warn(up->dev,
1561 "Unknown %s revision, defaulting to highest\n",
1562 up->name);
1563
1564 major = 0xff;
1565 minor = 0xff;
1566 }
1567
1568
1569 revision = UART_BUILD_REVISION(major, minor);
1570
1571 switch (revision) {
1572 case OMAP_UART_REV_46:
1573 up->errata |= (UART_ERRATA_i202_MDR1_ACCESS |
1574 UART_ERRATA_i291_DMA_FORCEIDLE);
1575 break;
1576 case OMAP_UART_REV_52:
1577 up->errata |= (UART_ERRATA_i202_MDR1_ACCESS |
1578 UART_ERRATA_i291_DMA_FORCEIDLE);
1579 up->features |= OMAP_UART_WER_HAS_TX_WAKEUP;
1580 break;
1581 case OMAP_UART_REV_63:
1582 up->errata |= UART_ERRATA_i202_MDR1_ACCESS;
1583 up->features |= OMAP_UART_WER_HAS_TX_WAKEUP;
1584 break;
1585 default:
1586 break;
1587 }
1588}
1589
1590static struct omap_uart_port_info *of_get_uart_port_info(struct device *dev)
1591{
1592 struct omap_uart_port_info *omap_up_info;
1593
1594 omap_up_info = devm_kzalloc(dev, sizeof(*omap_up_info), GFP_KERNEL);
1595 if (!omap_up_info)
1596 return NULL;
1597
1598 of_property_read_u32(dev->of_node, "clock-frequency",
1599 &omap_up_info->uartclk);
1600
1601 omap_up_info->flags = UPF_BOOT_AUTOCONF;
1602
1603 return omap_up_info;
1604}
1605
1606static int serial_omap_probe_rs485(struct uart_omap_port *up,
1607 struct device_node *np)
1608{
1609 struct serial_rs485 *rs485conf = &up->port.rs485;
1610 u32 rs485_delay[2];
1611 enum of_gpio_flags flags;
1612 int ret;
1613
1614 rs485conf->flags = 0;
1615 up->rts_gpio = -EINVAL;
1616
1617 if (!np)
1618 return 0;
1619
1620 if (of_property_read_bool(np, "rs485-rts-active-high"))
1621 rs485conf->flags |= SER_RS485_RTS_ON_SEND;
1622 else
1623 rs485conf->flags |= SER_RS485_RTS_AFTER_SEND;
1624
1625
1626 up->rts_gpio = of_get_named_gpio_flags(np, "rts-gpio", 0, &flags);
1627 if (gpio_is_valid(up->rts_gpio)) {
1628 ret = devm_gpio_request(up->dev, up->rts_gpio, "omap-serial");
1629 if (ret < 0)
1630 return ret;
1631 ret = gpio_direction_output(up->rts_gpio,
1632 flags & SER_RS485_RTS_AFTER_SEND);
1633 if (ret < 0)
1634 return ret;
1635 } else if (up->rts_gpio == -EPROBE_DEFER) {
1636 return -EPROBE_DEFER;
1637 } else {
1638 up->rts_gpio = -EINVAL;
1639 }
1640
1641 if (of_property_read_u32_array(np, "rs485-rts-delay",
1642 rs485_delay, 2) == 0) {
1643 rs485conf->delay_rts_before_send = rs485_delay[0];
1644 rs485conf->delay_rts_after_send = rs485_delay[1];
1645 }
1646
1647 if (of_property_read_bool(np, "rs485-rx-during-tx"))
1648 rs485conf->flags |= SER_RS485_RX_DURING_TX;
1649
1650 if (of_property_read_bool(np, "linux,rs485-enabled-at-boot-time"))
1651 rs485conf->flags |= SER_RS485_ENABLED;
1652
1653 return 0;
1654}
1655
1656static int serial_omap_probe(struct platform_device *pdev)
1657{
1658 struct omap_uart_port_info *omap_up_info = dev_get_platdata(&pdev->dev);
1659 struct uart_omap_port *up;
1660 struct resource *mem;
1661 void __iomem *base;
1662 int uartirq = 0;
1663 int wakeirq = 0;
1664 int ret;
1665
1666
1667 if (pdev->dev.of_node) {
1668 uartirq = irq_of_parse_and_map(pdev->dev.of_node, 0);
1669 if (!uartirq)
1670 return -EPROBE_DEFER;
1671 wakeirq = irq_of_parse_and_map(pdev->dev.of_node, 1);
1672 omap_up_info = of_get_uart_port_info(&pdev->dev);
1673 pdev->dev.platform_data = omap_up_info;
1674 } else {
1675 uartirq = platform_get_irq(pdev, 0);
1676 if (uartirq < 0)
1677 return -EPROBE_DEFER;
1678 }
1679
1680 up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL);
1681 if (!up)
1682 return -ENOMEM;
1683
1684 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1685 base = devm_ioremap_resource(&pdev->dev, mem);
1686 if (IS_ERR(base))
1687 return PTR_ERR(base);
1688
1689 up->dev = &pdev->dev;
1690 up->port.dev = &pdev->dev;
1691 up->port.type = PORT_OMAP;
1692 up->port.iotype = UPIO_MEM;
1693 up->port.irq = uartirq;
1694 up->port.regshift = 2;
1695 up->port.fifosize = 64;
1696 up->port.ops = &serial_omap_pops;
1697
1698 if (pdev->dev.of_node)
1699 ret = of_alias_get_id(pdev->dev.of_node, "serial");
1700 else
1701 ret = pdev->id;
1702
1703 if (ret < 0) {
1704 dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n",
1705 ret);
1706 goto err_port_line;
1707 }
1708 up->port.line = ret;
1709
1710 if (up->port.line >= OMAP_MAX_HSUART_PORTS) {
1711 dev_err(&pdev->dev, "uart ID %d > MAX %d.\n", up->port.line,
1712 OMAP_MAX_HSUART_PORTS);
1713 ret = -ENXIO;
1714 goto err_port_line;
1715 }
1716
1717 up->wakeirq = wakeirq;
1718 if (!up->wakeirq)
1719 dev_info(up->port.dev, "no wakeirq for uart%d\n",
1720 up->port.line);
1721
1722 ret = serial_omap_probe_rs485(up, pdev->dev.of_node);
1723 if (ret < 0)
1724 goto err_rs485;
1725
1726 sprintf(up->name, "OMAP UART%d", up->port.line);
1727 up->port.mapbase = mem->start;
1728 up->port.membase = base;
1729 up->port.flags = omap_up_info->flags;
1730 up->port.uartclk = omap_up_info->uartclk;
1731 up->port.rs485_config = serial_omap_config_rs485;
1732 if (!up->port.uartclk) {
1733 up->port.uartclk = DEFAULT_CLK_SPEED;
1734 dev_warn(&pdev->dev,
1735 "No clock speed specified: using default: %d\n",
1736 DEFAULT_CLK_SPEED);
1737 }
1738
1739 up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
1740 up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
1741 pm_qos_add_request(&up->pm_qos_request,
1742 PM_QOS_CPU_DMA_LATENCY, up->latency);
1743 INIT_WORK(&up->qos_work, serial_omap_uart_qos_work);
1744
1745 platform_set_drvdata(pdev, up);
1746 if (omap_up_info->autosuspend_timeout == 0)
1747 omap_up_info->autosuspend_timeout = -1;
1748
1749 device_init_wakeup(up->dev, true);
1750 pm_runtime_use_autosuspend(&pdev->dev);
1751 pm_runtime_set_autosuspend_delay(&pdev->dev,
1752 omap_up_info->autosuspend_timeout);
1753
1754 pm_runtime_irq_safe(&pdev->dev);
1755 pm_runtime_enable(&pdev->dev);
1756
1757 pm_runtime_get_sync(&pdev->dev);
1758
1759 omap_serial_fill_features_erratas(up);
1760
1761 ui[up->port.line] = up;
1762 serial_omap_add_console_port(up);
1763
1764 ret = uart_add_one_port(&serial_omap_reg, &up->port);
1765 if (ret != 0)
1766 goto err_add_port;
1767
1768 pm_runtime_mark_last_busy(up->dev);
1769 pm_runtime_put_autosuspend(up->dev);
1770 return 0;
1771
1772err_add_port:
1773 pm_runtime_dont_use_autosuspend(&pdev->dev);
1774 pm_runtime_put_sync(&pdev->dev);
1775 pm_runtime_disable(&pdev->dev);
1776 pm_qos_remove_request(&up->pm_qos_request);
1777 device_init_wakeup(up->dev, false);
1778err_rs485:
1779err_port_line:
1780 return ret;
1781}
1782
1783static int serial_omap_remove(struct platform_device *dev)
1784{
1785 struct uart_omap_port *up = platform_get_drvdata(dev);
1786
1787 pm_runtime_get_sync(up->dev);
1788
1789 uart_remove_one_port(&serial_omap_reg, &up->port);
1790
1791 pm_runtime_dont_use_autosuspend(up->dev);
1792 pm_runtime_put_sync(up->dev);
1793 pm_runtime_disable(up->dev);
1794 pm_qos_remove_request(&up->pm_qos_request);
1795 device_init_wakeup(&dev->dev, false);
1796
1797 return 0;
1798}
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809static void serial_omap_mdr1_errataset(struct uart_omap_port *up, u8 mdr1)
1810{
1811 u8 timeout = 255;
1812
1813 serial_out(up, UART_OMAP_MDR1, mdr1);
1814 udelay(2);
1815 serial_out(up, UART_FCR, up->fcr | UART_FCR_CLEAR_XMIT |
1816 UART_FCR_CLEAR_RCVR);
1817
1818
1819
1820
1821 while (UART_LSR_THRE != (serial_in(up, UART_LSR) &
1822 (UART_LSR_THRE | UART_LSR_DR))) {
1823 timeout--;
1824 if (!timeout) {
1825
1826 dev_crit(up->dev, "Errata i202: timedout %x\n",
1827 serial_in(up, UART_LSR));
1828 break;
1829 }
1830 udelay(1);
1831 }
1832}
1833
1834#ifdef CONFIG_PM
1835static void serial_omap_restore_context(struct uart_omap_port *up)
1836{
1837 if (up->errata & UART_ERRATA_i202_MDR1_ACCESS)
1838 serial_omap_mdr1_errataset(up, UART_OMAP_MDR1_DISABLE);
1839 else
1840 serial_out(up, UART_OMAP_MDR1, UART_OMAP_MDR1_DISABLE);
1841
1842 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1843 serial_out(up, UART_EFR, UART_EFR_ECB);
1844 serial_out(up, UART_LCR, 0x0);
1845 serial_out(up, UART_IER, 0x0);
1846 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1847 serial_out(up, UART_DLL, up->dll);
1848 serial_out(up, UART_DLM, up->dlh);
1849 serial_out(up, UART_LCR, 0x0);
1850 serial_out(up, UART_IER, up->ier);
1851 serial_out(up, UART_FCR, up->fcr);
1852 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
1853 serial_out(up, UART_MCR, up->mcr);
1854 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1855 serial_out(up, UART_OMAP_SCR, up->scr);
1856 serial_out(up, UART_EFR, up->efr);
1857 serial_out(up, UART_LCR, up->lcr);
1858 if (up->errata & UART_ERRATA_i202_MDR1_ACCESS)
1859 serial_omap_mdr1_errataset(up, up->mdr1);
1860 else
1861 serial_out(up, UART_OMAP_MDR1, up->mdr1);
1862 serial_out(up, UART_OMAP_WER, up->wer);
1863}
1864
1865static int serial_omap_runtime_suspend(struct device *dev)
1866{
1867 struct uart_omap_port *up = dev_get_drvdata(dev);
1868
1869 if (!up)
1870 return -EINVAL;
1871
1872
1873
1874
1875
1876
1877
1878 if (up->is_suspending && !console_suspend_enabled &&
1879 uart_console(&up->port))
1880 return -EBUSY;
1881
1882 up->context_loss_cnt = serial_omap_get_context_loss_count(up);
1883
1884 serial_omap_enable_wakeup(up, true);
1885
1886 up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
1887 schedule_work(&up->qos_work);
1888
1889 return 0;
1890}
1891
1892static int serial_omap_runtime_resume(struct device *dev)
1893{
1894 struct uart_omap_port *up = dev_get_drvdata(dev);
1895
1896 int loss_cnt = serial_omap_get_context_loss_count(up);
1897
1898 serial_omap_enable_wakeup(up, false);
1899
1900 if (loss_cnt < 0) {
1901 dev_dbg(dev, "serial_omap_get_context_loss_count failed : %d\n",
1902 loss_cnt);
1903 serial_omap_restore_context(up);
1904 } else if (up->context_loss_cnt != loss_cnt) {
1905 serial_omap_restore_context(up);
1906 }
1907 up->latency = up->calc_latency;
1908 schedule_work(&up->qos_work);
1909
1910 return 0;
1911}
1912#endif
1913
1914static const struct dev_pm_ops serial_omap_dev_pm_ops = {
1915 SET_SYSTEM_SLEEP_PM_OPS(serial_omap_suspend, serial_omap_resume)
1916 SET_RUNTIME_PM_OPS(serial_omap_runtime_suspend,
1917 serial_omap_runtime_resume, NULL)
1918 .prepare = serial_omap_prepare,
1919 .complete = serial_omap_complete,
1920};
1921
1922#if defined(CONFIG_OF)
1923static const struct of_device_id omap_serial_of_match[] = {
1924 { .compatible = "ti,omap2-uart" },
1925 { .compatible = "ti,omap3-uart" },
1926 { .compatible = "ti,omap4-uart" },
1927 {},
1928};
1929MODULE_DEVICE_TABLE(of, omap_serial_of_match);
1930#endif
1931
1932static struct platform_driver serial_omap_driver = {
1933 .probe = serial_omap_probe,
1934 .remove = serial_omap_remove,
1935 .driver = {
1936 .name = OMAP_SERIAL_DRIVER_NAME,
1937 .pm = &serial_omap_dev_pm_ops,
1938 .of_match_table = of_match_ptr(omap_serial_of_match),
1939 },
1940};
1941
1942static int __init serial_omap_init(void)
1943{
1944 int ret;
1945
1946 ret = uart_register_driver(&serial_omap_reg);
1947 if (ret != 0)
1948 return ret;
1949 ret = platform_driver_register(&serial_omap_driver);
1950 if (ret != 0)
1951 uart_unregister_driver(&serial_omap_reg);
1952 return ret;
1953}
1954
1955static void __exit serial_omap_exit(void)
1956{
1957 platform_driver_unregister(&serial_omap_driver);
1958 uart_unregister_driver(&serial_omap_reg);
1959}
1960
1961module_init(serial_omap_init);
1962module_exit(serial_omap_exit);
1963
1964MODULE_DESCRIPTION("OMAP High Speed UART driver");
1965MODULE_LICENSE("GPL");
1966MODULE_AUTHOR("Texas Instruments Inc");
1967