Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/tty/serial/pxa.c

  1 /*
  2  *  Based on drivers/serial/8250.c by Russell King.
  3  *
  4  *  Author:     Nicolas Pitre
  5  *  Created:    Feb 20, 2003
  6  *  Copyright:  (C) 2003 Monta Vista Software, Inc.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  *
 13  * Note 1: This driver is made separate from the already too overloaded
 14  * 8250.c because it needs some kirks of its own and that'll make it
 15  * easier to add DMA support.
 16  *
 17  * Note 2: I'm too sick of device allocation policies for serial ports.
 18  * If someone else wants to request an "official" allocation of major/minor
 19  * for this driver please be my guest.  And don't forget that new hardware
 20  * to come from Intel might have more than 3 or 4 of those UARTs.  Let's
 21  * hope for a better port registration and dynamic device allocation scheme
 22  * with the serial core maintainer satisfaction to appear soon.
 23  */
 24 
 25 
 26 #if defined(CONFIG_SERIAL_PXA_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 27 #define SUPPORT_SYSRQ
 28 #endif
 29 
 30 #include <linux/ioport.h>
 31 #include <linux/init.h>
 32 #include <linux/console.h>
 33 #include <linux/sysrq.h>
 34 #include <linux/serial_reg.h>
 35 #include <linux/circ_buf.h>
 36 #include <linux/delay.h>
 37 #include <linux/interrupt.h>
 38 #include <linux/of.h>
 39 #include <linux/platform_device.h>
 40 #include <linux/tty.h>
 41 #include <linux/tty_flip.h>
 42 #include <linux/serial_core.h>
 43 #include <linux/clk.h>
 44 #include <linux/io.h>
 45 #include <linux/slab.h>
 46 
 47 #define PXA_NAME_LEN            8
 48 
 49 struct uart_pxa_port {
 50         struct uart_port        port;
 51         unsigned char           ier;
 52         unsigned char           lcr;
 53         unsigned char           mcr;
 54         unsigned int            lsr_break_flag;
 55         struct clk              *clk;
 56         char                    name[PXA_NAME_LEN];
 57 };
 58 
 59 static inline unsigned int serial_in(struct uart_pxa_port *up, int offset)
 60 {
 61         offset <<= 2;
 62         return readl(up->port.membase + offset);
 63 }
 64 
 65 static inline void serial_out(struct uart_pxa_port *up, int offset, int value)
 66 {
 67         offset <<= 2;
 68         writel(value, up->port.membase + offset);
 69 }
 70 
 71 static void serial_pxa_enable_ms(struct uart_port *port)
 72 {
 73         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
 74 
 75         up->ier |= UART_IER_MSI;
 76         serial_out(up, UART_IER, up->ier);
 77 }
 78 
 79 static void serial_pxa_stop_tx(struct uart_port *port)
 80 {
 81         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
 82 
 83         if (up->ier & UART_IER_THRI) {
 84                 up->ier &= ~UART_IER_THRI;
 85                 serial_out(up, UART_IER, up->ier);
 86         }
 87 }
 88 
 89 static void serial_pxa_stop_rx(struct uart_port *port)
 90 {
 91         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
 92 
 93         up->ier &= ~UART_IER_RLSI;
 94         up->port.read_status_mask &= ~UART_LSR_DR;
 95         serial_out(up, UART_IER, up->ier);
 96 }
 97 
 98 static inline void receive_chars(struct uart_pxa_port *up, int *status)
 99 {
100         unsigned int ch, flag;
101         int max_count = 256;
102 
103         do {
104                 /* work around Errata #20 according to
105                  * Intel(R) PXA27x Processor Family
106                  * Specification Update (May 2005)
107                  *
108                  * Step 2
109                  * Disable the Reciever Time Out Interrupt via IER[RTOEI]
110                  */
111                 up->ier &= ~UART_IER_RTOIE;
112                 serial_out(up, UART_IER, up->ier);
113 
114                 ch = serial_in(up, UART_RX);
115                 flag = TTY_NORMAL;
116                 up->port.icount.rx++;
117 
118                 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
119                                        UART_LSR_FE | UART_LSR_OE))) {
120                         /*
121                          * For statistics only
122                          */
123                         if (*status & UART_LSR_BI) {
124                                 *status &= ~(UART_LSR_FE | UART_LSR_PE);
125                                 up->port.icount.brk++;
126                                 /*
127                                  * We do the SysRQ and SAK checking
128                                  * here because otherwise the break
129                                  * may get masked by ignore_status_mask
130                                  * or read_status_mask.
131                                  */
132                                 if (uart_handle_break(&up->port))
133                                         goto ignore_char;
134                         } else if (*status & UART_LSR_PE)
135                                 up->port.icount.parity++;
136                         else if (*status & UART_LSR_FE)
137                                 up->port.icount.frame++;
138                         if (*status & UART_LSR_OE)
139                                 up->port.icount.overrun++;
140 
141                         /*
142                          * Mask off conditions which should be ignored.
143                          */
144                         *status &= up->port.read_status_mask;
145 
146 #ifdef CONFIG_SERIAL_PXA_CONSOLE
147                         if (up->port.line == up->port.cons->index) {
148                                 /* Recover the break flag from console xmit */
149                                 *status |= up->lsr_break_flag;
150                                 up->lsr_break_flag = 0;
151                         }
152 #endif
153                         if (*status & UART_LSR_BI) {
154                                 flag = TTY_BREAK;
155                         } else if (*status & UART_LSR_PE)
156                                 flag = TTY_PARITY;
157                         else if (*status & UART_LSR_FE)
158                                 flag = TTY_FRAME;
159                 }
160 
161                 if (uart_handle_sysrq_char(&up->port, ch))
162                         goto ignore_char;
163 
164                 uart_insert_char(&up->port, *status, UART_LSR_OE, ch, flag);
165 
166         ignore_char:
167                 *status = serial_in(up, UART_LSR);
168         } while ((*status & UART_LSR_DR) && (max_count-- > 0));
169         tty_flip_buffer_push(&up->port.state->port);
170 
171         /* work around Errata #20 according to
172          * Intel(R) PXA27x Processor Family
173          * Specification Update (May 2005)
174          *
175          * Step 6:
176          * No more data in FIFO: Re-enable RTO interrupt via IER[RTOIE]
177          */
178         up->ier |= UART_IER_RTOIE;
179         serial_out(up, UART_IER, up->ier);
180 }
181 
182 static void transmit_chars(struct uart_pxa_port *up)
183 {
184         struct circ_buf *xmit = &up->port.state->xmit;
185         int count;
186 
187         if (up->port.x_char) {
188                 serial_out(up, UART_TX, up->port.x_char);
189                 up->port.icount.tx++;
190                 up->port.x_char = 0;
191                 return;
192         }
193         if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
194                 serial_pxa_stop_tx(&up->port);
195                 return;
196         }
197 
198         count = up->port.fifosize / 2;
199         do {
200                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
201                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
202                 up->port.icount.tx++;
203                 if (uart_circ_empty(xmit))
204                         break;
205         } while (--count > 0);
206 
207         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
208                 uart_write_wakeup(&up->port);
209 
210 
211         if (uart_circ_empty(xmit))
212                 serial_pxa_stop_tx(&up->port);
213 }
214 
215 static void serial_pxa_start_tx(struct uart_port *port)
216 {
217         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
218 
219         if (!(up->ier & UART_IER_THRI)) {
220                 up->ier |= UART_IER_THRI;
221                 serial_out(up, UART_IER, up->ier);
222         }
223 }
224 
225 /* should hold up->port.lock */
226 static inline void check_modem_status(struct uart_pxa_port *up)
227 {
228         int status;
229 
230         status = serial_in(up, UART_MSR);
231 
232         if ((status & UART_MSR_ANY_DELTA) == 0)
233                 return;
234 
235         if (status & UART_MSR_TERI)
236                 up->port.icount.rng++;
237         if (status & UART_MSR_DDSR)
238                 up->port.icount.dsr++;
239         if (status & UART_MSR_DDCD)
240                 uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
241         if (status & UART_MSR_DCTS)
242                 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
243 
244         wake_up_interruptible(&up->port.state->port.delta_msr_wait);
245 }
246 
247 /*
248  * This handles the interrupt from one port.
249  */
250 static inline irqreturn_t serial_pxa_irq(int irq, void *dev_id)
251 {
252         struct uart_pxa_port *up = dev_id;
253         unsigned int iir, lsr;
254 
255         iir = serial_in(up, UART_IIR);
256         if (iir & UART_IIR_NO_INT)
257                 return IRQ_NONE;
258         spin_lock(&up->port.lock);
259         lsr = serial_in(up, UART_LSR);
260         if (lsr & UART_LSR_DR)
261                 receive_chars(up, &lsr);
262         check_modem_status(up);
263         if (lsr & UART_LSR_THRE)
264                 transmit_chars(up);
265         spin_unlock(&up->port.lock);
266         return IRQ_HANDLED;
267 }
268 
269 static unsigned int serial_pxa_tx_empty(struct uart_port *port)
270 {
271         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
272         unsigned long flags;
273         unsigned int ret;
274 
275         spin_lock_irqsave(&up->port.lock, flags);
276         ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
277         spin_unlock_irqrestore(&up->port.lock, flags);
278 
279         return ret;
280 }
281 
282 static unsigned int serial_pxa_get_mctrl(struct uart_port *port)
283 {
284         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
285         unsigned char status;
286         unsigned int ret;
287 
288         status = serial_in(up, UART_MSR);
289 
290         ret = 0;
291         if (status & UART_MSR_DCD)
292                 ret |= TIOCM_CAR;
293         if (status & UART_MSR_RI)
294                 ret |= TIOCM_RNG;
295         if (status & UART_MSR_DSR)
296                 ret |= TIOCM_DSR;
297         if (status & UART_MSR_CTS)
298                 ret |= TIOCM_CTS;
299         return ret;
300 }
301 
302 static void serial_pxa_set_mctrl(struct uart_port *port, unsigned int mctrl)
303 {
304         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
305         unsigned char mcr = 0;
306 
307         if (mctrl & TIOCM_RTS)
308                 mcr |= UART_MCR_RTS;
309         if (mctrl & TIOCM_DTR)
310                 mcr |= UART_MCR_DTR;
311         if (mctrl & TIOCM_OUT1)
312                 mcr |= UART_MCR_OUT1;
313         if (mctrl & TIOCM_OUT2)
314                 mcr |= UART_MCR_OUT2;
315         if (mctrl & TIOCM_LOOP)
316                 mcr |= UART_MCR_LOOP;
317 
318         mcr |= up->mcr;
319 
320         serial_out(up, UART_MCR, mcr);
321 }
322 
323 static void serial_pxa_break_ctl(struct uart_port *port, int break_state)
324 {
325         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
326         unsigned long flags;
327 
328         spin_lock_irqsave(&up->port.lock, flags);
329         if (break_state == -1)
330                 up->lcr |= UART_LCR_SBC;
331         else
332                 up->lcr &= ~UART_LCR_SBC;
333         serial_out(up, UART_LCR, up->lcr);
334         spin_unlock_irqrestore(&up->port.lock, flags);
335 }
336 
337 static int serial_pxa_startup(struct uart_port *port)
338 {
339         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
340         unsigned long flags;
341         int retval;
342 
343         if (port->line == 3) /* HWUART */
344                 up->mcr |= UART_MCR_AFE;
345         else
346                 up->mcr = 0;
347 
348         up->port.uartclk = clk_get_rate(up->clk);
349 
350         /*
351          * Allocate the IRQ
352          */
353         retval = request_irq(up->port.irq, serial_pxa_irq, 0, up->name, up);
354         if (retval)
355                 return retval;
356 
357         /*
358          * Clear the FIFO buffers and disable them.
359          * (they will be reenabled in set_termios())
360          */
361         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
362         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
363                         UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
364         serial_out(up, UART_FCR, 0);
365 
366         /*
367          * Clear the interrupt registers.
368          */
369         (void) serial_in(up, UART_LSR);
370         (void) serial_in(up, UART_RX);
371         (void) serial_in(up, UART_IIR);
372         (void) serial_in(up, UART_MSR);
373 
374         /*
375          * Now, initialize the UART
376          */
377         serial_out(up, UART_LCR, UART_LCR_WLEN8);
378 
379         spin_lock_irqsave(&up->port.lock, flags);
380         up->port.mctrl |= TIOCM_OUT2;
381         serial_pxa_set_mctrl(&up->port, up->port.mctrl);
382         spin_unlock_irqrestore(&up->port.lock, flags);
383 
384         /*
385          * Finally, enable interrupts.  Note: Modem status interrupts
386          * are set via set_termios(), which will be occurring imminently
387          * anyway, so we don't enable them here.
388          */
389         up->ier = UART_IER_RLSI | UART_IER_RDI | UART_IER_RTOIE | UART_IER_UUE;
390         serial_out(up, UART_IER, up->ier);
391 
392         /*
393          * And clear the interrupt registers again for luck.
394          */
395         (void) serial_in(up, UART_LSR);
396         (void) serial_in(up, UART_RX);
397         (void) serial_in(up, UART_IIR);
398         (void) serial_in(up, UART_MSR);
399 
400         return 0;
401 }
402 
403 static void serial_pxa_shutdown(struct uart_port *port)
404 {
405         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
406         unsigned long flags;
407 
408         free_irq(up->port.irq, up);
409 
410         /*
411          * Disable interrupts from this port
412          */
413         up->ier = 0;
414         serial_out(up, UART_IER, 0);
415 
416         spin_lock_irqsave(&up->port.lock, flags);
417         up->port.mctrl &= ~TIOCM_OUT2;
418         serial_pxa_set_mctrl(&up->port, up->port.mctrl);
419         spin_unlock_irqrestore(&up->port.lock, flags);
420 
421         /*
422          * Disable break condition and FIFOs
423          */
424         serial_out(up, UART_LCR, serial_in(up, UART_LCR) & ~UART_LCR_SBC);
425         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
426                                   UART_FCR_CLEAR_RCVR |
427                                   UART_FCR_CLEAR_XMIT);
428         serial_out(up, UART_FCR, 0);
429 }
430 
431 static void
432 serial_pxa_set_termios(struct uart_port *port, struct ktermios *termios,
433                        struct ktermios *old)
434 {
435         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
436         unsigned char cval, fcr = 0;
437         unsigned long flags;
438         unsigned int baud, quot;
439         unsigned int dll;
440 
441         switch (termios->c_cflag & CSIZE) {
442         case CS5:
443                 cval = UART_LCR_WLEN5;
444                 break;
445         case CS6:
446                 cval = UART_LCR_WLEN6;
447                 break;
448         case CS7:
449                 cval = UART_LCR_WLEN7;
450                 break;
451         default:
452         case CS8:
453                 cval = UART_LCR_WLEN8;
454                 break;
455         }
456 
457         if (termios->c_cflag & CSTOPB)
458                 cval |= UART_LCR_STOP;
459         if (termios->c_cflag & PARENB)
460                 cval |= UART_LCR_PARITY;
461         if (!(termios->c_cflag & PARODD))
462                 cval |= UART_LCR_EPAR;
463 
464         /*
465          * Ask the core to calculate the divisor for us.
466          */
467         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
468         quot = uart_get_divisor(port, baud);
469 
470         if ((up->port.uartclk / quot) < (2400 * 16))
471                 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_PXAR1;
472         else if ((up->port.uartclk / quot) < (230400 * 16))
473                 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_PXAR8;
474         else
475                 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_PXAR32;
476 
477         /*
478          * Ok, we're now changing the port state.  Do it with
479          * interrupts disabled.
480          */
481         spin_lock_irqsave(&up->port.lock, flags);
482 
483         /*
484          * Ensure the port will be enabled.
485          * This is required especially for serial console.
486          */
487         up->ier |= UART_IER_UUE;
488 
489         /*
490          * Update the per-port timeout.
491          */
492         uart_update_timeout(port, termios->c_cflag, baud);
493 
494         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
495         if (termios->c_iflag & INPCK)
496                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
497         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
498                 up->port.read_status_mask |= UART_LSR_BI;
499 
500         /*
501          * Characters to ignore
502          */
503         up->port.ignore_status_mask = 0;
504         if (termios->c_iflag & IGNPAR)
505                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
506         if (termios->c_iflag & IGNBRK) {
507                 up->port.ignore_status_mask |= UART_LSR_BI;
508                 /*
509                  * If we're ignoring parity and break indicators,
510                  * ignore overruns too (for real raw support).
511                  */
512                 if (termios->c_iflag & IGNPAR)
513                         up->port.ignore_status_mask |= UART_LSR_OE;
514         }
515 
516         /*
517          * ignore all characters if CREAD is not set
518          */
519         if ((termios->c_cflag & CREAD) == 0)
520                 up->port.ignore_status_mask |= UART_LSR_DR;
521 
522         /*
523          * CTS flow control flag and modem status interrupts
524          */
525         up->ier &= ~UART_IER_MSI;
526         if (UART_ENABLE_MS(&up->port, termios->c_cflag))
527                 up->ier |= UART_IER_MSI;
528 
529         serial_out(up, UART_IER, up->ier);
530 
531         if (termios->c_cflag & CRTSCTS)
532                 up->mcr |= UART_MCR_AFE;
533         else
534                 up->mcr &= ~UART_MCR_AFE;
535 
536         serial_out(up, UART_LCR, cval | UART_LCR_DLAB); /* set DLAB */
537         serial_out(up, UART_DLL, quot & 0xff);          /* LS of divisor */
538 
539         /*
540          * work around Errata #75 according to Intel(R) PXA27x Processor Family
541          * Specification Update (Nov 2005)
542          */
543         dll = serial_in(up, UART_DLL);
544         WARN_ON(dll != (quot & 0xff));
545 
546         serial_out(up, UART_DLM, quot >> 8);            /* MS of divisor */
547         serial_out(up, UART_LCR, cval);                 /* reset DLAB */
548         up->lcr = cval;                                 /* Save LCR */
549         serial_pxa_set_mctrl(&up->port, up->port.mctrl);
550         serial_out(up, UART_FCR, fcr);
551         spin_unlock_irqrestore(&up->port.lock, flags);
552 }
553 
554 static void
555 serial_pxa_pm(struct uart_port *port, unsigned int state,
556               unsigned int oldstate)
557 {
558         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
559 
560         if (!state)
561                 clk_prepare_enable(up->clk);
562         else
563                 clk_disable_unprepare(up->clk);
564 }
565 
566 static void serial_pxa_release_port(struct uart_port *port)
567 {
568 }
569 
570 static int serial_pxa_request_port(struct uart_port *port)
571 {
572         return 0;
573 }
574 
575 static void serial_pxa_config_port(struct uart_port *port, int flags)
576 {
577         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
578         up->port.type = PORT_PXA;
579 }
580 
581 static int
582 serial_pxa_verify_port(struct uart_port *port, struct serial_struct *ser)
583 {
584         /* we don't want the core code to modify any port params */
585         return -EINVAL;
586 }
587 
588 static const char *
589 serial_pxa_type(struct uart_port *port)
590 {
591         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
592         return up->name;
593 }
594 
595 static struct uart_pxa_port *serial_pxa_ports[4];
596 static struct uart_driver serial_pxa_reg;
597 
598 #ifdef CONFIG_SERIAL_PXA_CONSOLE
599 
600 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
601 
602 /*
603  *      Wait for transmitter & holding register to empty
604  */
605 static void wait_for_xmitr(struct uart_pxa_port *up)
606 {
607         unsigned int status, tmout = 10000;
608 
609         /* Wait up to 10ms for the character(s) to be sent. */
610         do {
611                 status = serial_in(up, UART_LSR);
612 
613                 if (status & UART_LSR_BI)
614                         up->lsr_break_flag = UART_LSR_BI;
615 
616                 if (--tmout == 0)
617                         break;
618                 udelay(1);
619         } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
620 
621         /* Wait up to 1s for flow control if necessary */
622         if (up->port.flags & UPF_CONS_FLOW) {
623                 tmout = 1000000;
624                 while (--tmout &&
625                        ((serial_in(up, UART_MSR) & UART_MSR_CTS) == 0))
626                         udelay(1);
627         }
628 }
629 
630 static void serial_pxa_console_putchar(struct uart_port *port, int ch)
631 {
632         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
633 
634         wait_for_xmitr(up);
635         serial_out(up, UART_TX, ch);
636 }
637 
638 /*
639  * Print a string to the serial port trying not to disturb
640  * any possible real use of the port...
641  *
642  *      The console_lock must be held when we get here.
643  */
644 static void
645 serial_pxa_console_write(struct console *co, const char *s, unsigned int count)
646 {
647         struct uart_pxa_port *up = serial_pxa_ports[co->index];
648         unsigned int ier;
649         unsigned long flags;
650         int locked = 1;
651 
652         clk_enable(up->clk);
653         local_irq_save(flags);
654         if (up->port.sysrq)
655                 locked = 0;
656         else if (oops_in_progress)
657                 locked = spin_trylock(&up->port.lock);
658         else
659                 spin_lock(&up->port.lock);
660 
661         /*
662          *      First save the IER then disable the interrupts
663          */
664         ier = serial_in(up, UART_IER);
665         serial_out(up, UART_IER, UART_IER_UUE);
666 
667         uart_console_write(&up->port, s, count, serial_pxa_console_putchar);
668 
669         /*
670          *      Finally, wait for transmitter to become empty
671          *      and restore the IER
672          */
673         wait_for_xmitr(up);
674         serial_out(up, UART_IER, ier);
675 
676         if (locked)
677                 spin_unlock(&up->port.lock);
678         local_irq_restore(flags);
679         clk_disable(up->clk);
680 
681 }
682 
683 #ifdef CONFIG_CONSOLE_POLL
684 /*
685  * Console polling routines for writing and reading from the uart while
686  * in an interrupt or debug context.
687  */
688 
689 static int serial_pxa_get_poll_char(struct uart_port *port)
690 {
691         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
692         unsigned char lsr = serial_in(up, UART_LSR);
693 
694         while (!(lsr & UART_LSR_DR))
695                 lsr = serial_in(up, UART_LSR);
696 
697         return serial_in(up, UART_RX);
698 }
699 
700 
701 static void serial_pxa_put_poll_char(struct uart_port *port,
702                          unsigned char c)
703 {
704         unsigned int ier;
705         struct uart_pxa_port *up = (struct uart_pxa_port *)port;
706 
707         /*
708          *      First save the IER then disable the interrupts
709          */
710         ier = serial_in(up, UART_IER);
711         serial_out(up, UART_IER, UART_IER_UUE);
712 
713         wait_for_xmitr(up);
714         /*
715          *      Send the character out.
716          */
717         serial_out(up, UART_TX, c);
718 
719         /*
720          *      Finally, wait for transmitter to become empty
721          *      and restore the IER
722          */
723         wait_for_xmitr(up);
724         serial_out(up, UART_IER, ier);
725 }
726 
727 #endif /* CONFIG_CONSOLE_POLL */
728 
729 static int __init
730 serial_pxa_console_setup(struct console *co, char *options)
731 {
732         struct uart_pxa_port *up;
733         int baud = 9600;
734         int bits = 8;
735         int parity = 'n';
736         int flow = 'n';
737 
738         if (co->index == -1 || co->index >= serial_pxa_reg.nr)
739                 co->index = 0;
740         up = serial_pxa_ports[co->index];
741         if (!up)
742                 return -ENODEV;
743 
744         if (options)
745                 uart_parse_options(options, &baud, &parity, &bits, &flow);
746 
747         return uart_set_options(&up->port, co, baud, parity, bits, flow);
748 }
749 
750 static struct console serial_pxa_console = {
751         .name           = "ttyS",
752         .write          = serial_pxa_console_write,
753         .device         = uart_console_device,
754         .setup          = serial_pxa_console_setup,
755         .flags          = CON_PRINTBUFFER,
756         .index          = -1,
757         .data           = &serial_pxa_reg,
758 };
759 
760 #define PXA_CONSOLE     &serial_pxa_console
761 #else
762 #define PXA_CONSOLE     NULL
763 #endif
764 
765 static struct uart_ops serial_pxa_pops = {
766         .tx_empty       = serial_pxa_tx_empty,
767         .set_mctrl      = serial_pxa_set_mctrl,
768         .get_mctrl      = serial_pxa_get_mctrl,
769         .stop_tx        = serial_pxa_stop_tx,
770         .start_tx       = serial_pxa_start_tx,
771         .stop_rx        = serial_pxa_stop_rx,
772         .enable_ms      = serial_pxa_enable_ms,
773         .break_ctl      = serial_pxa_break_ctl,
774         .startup        = serial_pxa_startup,
775         .shutdown       = serial_pxa_shutdown,
776         .set_termios    = serial_pxa_set_termios,
777         .pm             = serial_pxa_pm,
778         .type           = serial_pxa_type,
779         .release_port   = serial_pxa_release_port,
780         .request_port   = serial_pxa_request_port,
781         .config_port    = serial_pxa_config_port,
782         .verify_port    = serial_pxa_verify_port,
783 #if defined(CONFIG_CONSOLE_POLL) && defined(CONFIG_SERIAL_PXA_CONSOLE)
784         .poll_get_char = serial_pxa_get_poll_char,
785         .poll_put_char = serial_pxa_put_poll_char,
786 #endif
787 };
788 
789 static struct uart_driver serial_pxa_reg = {
790         .owner          = THIS_MODULE,
791         .driver_name    = "PXA serial",
792         .dev_name       = "ttyS",
793         .major          = TTY_MAJOR,
794         .minor          = 64,
795         .nr             = 4,
796         .cons           = PXA_CONSOLE,
797 };
798 
799 #ifdef CONFIG_PM
800 static int serial_pxa_suspend(struct device *dev)
801 {
802         struct uart_pxa_port *sport = dev_get_drvdata(dev);
803 
804         if (sport)
805                 uart_suspend_port(&serial_pxa_reg, &sport->port);
806 
807         return 0;
808 }
809 
810 static int serial_pxa_resume(struct device *dev)
811 {
812         struct uart_pxa_port *sport = dev_get_drvdata(dev);
813 
814         if (sport)
815                 uart_resume_port(&serial_pxa_reg, &sport->port);
816 
817         return 0;
818 }
819 
820 static const struct dev_pm_ops serial_pxa_pm_ops = {
821         .suspend        = serial_pxa_suspend,
822         .resume         = serial_pxa_resume,
823 };
824 #endif
825 
826 static const struct of_device_id serial_pxa_dt_ids[] = {
827         { .compatible = "mrvl,pxa-uart", },
828         { .compatible = "mrvl,mmp-uart", },
829         {}
830 };
831 
832 static int serial_pxa_probe_dt(struct platform_device *pdev,
833                                struct uart_pxa_port *sport)
834 {
835         struct device_node *np = pdev->dev.of_node;
836         int ret;
837 
838         if (!np)
839                 return 1;
840 
841         ret = of_alias_get_id(np, "serial");
842         if (ret < 0) {
843                 dev_err(&pdev->dev, "failed to get alias id, errno %d\n", ret);
844                 return ret;
845         }
846         sport->port.line = ret;
847         return 0;
848 }
849 
850 static int serial_pxa_probe(struct platform_device *dev)
851 {
852         struct uart_pxa_port *sport;
853         struct resource *mmres, *irqres;
854         int ret;
855 
856         mmres = platform_get_resource(dev, IORESOURCE_MEM, 0);
857         irqres = platform_get_resource(dev, IORESOURCE_IRQ, 0);
858         if (!mmres || !irqres)
859                 return -ENODEV;
860 
861         sport = kzalloc(sizeof(struct uart_pxa_port), GFP_KERNEL);
862         if (!sport)
863                 return -ENOMEM;
864 
865         sport->clk = clk_get(&dev->dev, NULL);
866         if (IS_ERR(sport->clk)) {
867                 ret = PTR_ERR(sport->clk);
868                 goto err_free;
869         }
870 
871         ret = clk_prepare(sport->clk);
872         if (ret) {
873                 clk_put(sport->clk);
874                 goto err_free;
875         }
876 
877         sport->port.type = PORT_PXA;
878         sport->port.iotype = UPIO_MEM;
879         sport->port.mapbase = mmres->start;
880         sport->port.irq = irqres->start;
881         sport->port.fifosize = 64;
882         sport->port.ops = &serial_pxa_pops;
883         sport->port.dev = &dev->dev;
884         sport->port.flags = UPF_IOREMAP | UPF_BOOT_AUTOCONF;
885         sport->port.uartclk = clk_get_rate(sport->clk);
886 
887         ret = serial_pxa_probe_dt(dev, sport);
888         if (ret > 0)
889                 sport->port.line = dev->id;
890         else if (ret < 0)
891                 goto err_clk;
892         snprintf(sport->name, PXA_NAME_LEN - 1, "UART%d", sport->port.line + 1);
893 
894         sport->port.membase = ioremap(mmres->start, resource_size(mmres));
895         if (!sport->port.membase) {
896                 ret = -ENOMEM;
897                 goto err_clk;
898         }
899 
900         serial_pxa_ports[sport->port.line] = sport;
901 
902         uart_add_one_port(&serial_pxa_reg, &sport->port);
903         platform_set_drvdata(dev, sport);
904 
905         return 0;
906 
907  err_clk:
908         clk_unprepare(sport->clk);
909         clk_put(sport->clk);
910  err_free:
911         kfree(sport);
912         return ret;
913 }
914 
915 static struct platform_driver serial_pxa_driver = {
916         .probe          = serial_pxa_probe,
917 
918         .driver         = {
919                 .name   = "pxa2xx-uart",
920 #ifdef CONFIG_PM
921                 .pm     = &serial_pxa_pm_ops,
922 #endif
923                 .suppress_bind_attrs = true,
924                 .of_match_table = serial_pxa_dt_ids,
925         },
926 };
927 
928 static int __init serial_pxa_init(void)
929 {
930         int ret;
931 
932         ret = uart_register_driver(&serial_pxa_reg);
933         if (ret != 0)
934                 return ret;
935 
936         ret = platform_driver_register(&serial_pxa_driver);
937         if (ret != 0)
938                 uart_unregister_driver(&serial_pxa_reg);
939 
940         return ret;
941 }
942 device_initcall(serial_pxa_init);
943 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us