Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/tty/serial/apbuart.c

  1 /*
  2  *  Driver for GRLIB serial ports (APBUART)
  3  *
  4  *  Based on linux/drivers/serial/amba.c
  5  *
  6  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
  7  *  Copyright (C) 2003 Konrad Eisele <eiselekd@web.de>
  8  *  Copyright (C) 2006 Daniel Hellstrom <daniel@gaisler.com>, Aeroflex Gaisler AB
  9  *  Copyright (C) 2008 Gilead Kutnick <kutnickg@zin-tech.com>
 10  *  Copyright (C) 2009 Kristoffer Glembo <kristoffer@gaisler.com>, Aeroflex Gaisler AB
 11  */
 12 
 13 #if defined(CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 14 #define SUPPORT_SYSRQ
 15 #endif
 16 
 17 #include <linux/module.h>
 18 #include <linux/tty.h>
 19 #include <linux/tty_flip.h>
 20 #include <linux/ioport.h>
 21 #include <linux/init.h>
 22 #include <linux/serial.h>
 23 #include <linux/console.h>
 24 #include <linux/sysrq.h>
 25 #include <linux/kthread.h>
 26 #include <linux/device.h>
 27 #include <linux/of.h>
 28 #include <linux/of_device.h>
 29 #include <linux/of_platform.h>
 30 #include <linux/of_irq.h>
 31 #include <linux/platform_device.h>
 32 #include <linux/io.h>
 33 #include <linux/serial_core.h>
 34 #include <asm/irq.h>
 35 
 36 #include "apbuart.h"
 37 
 38 #define SERIAL_APBUART_MAJOR    TTY_MAJOR
 39 #define SERIAL_APBUART_MINOR    64
 40 #define UART_DUMMY_RSR_RX       0x8000  /* for ignore all read */
 41 
 42 static void apbuart_tx_chars(struct uart_port *port);
 43 
 44 static void apbuart_stop_tx(struct uart_port *port)
 45 {
 46         unsigned int cr;
 47 
 48         cr = UART_GET_CTRL(port);
 49         cr &= ~UART_CTRL_TI;
 50         UART_PUT_CTRL(port, cr);
 51 }
 52 
 53 static void apbuart_start_tx(struct uart_port *port)
 54 {
 55         unsigned int cr;
 56 
 57         cr = UART_GET_CTRL(port);
 58         cr |= UART_CTRL_TI;
 59         UART_PUT_CTRL(port, cr);
 60 
 61         if (UART_GET_STATUS(port) & UART_STATUS_THE)
 62                 apbuart_tx_chars(port);
 63 }
 64 
 65 static void apbuart_stop_rx(struct uart_port *port)
 66 {
 67         unsigned int cr;
 68 
 69         cr = UART_GET_CTRL(port);
 70         cr &= ~(UART_CTRL_RI);
 71         UART_PUT_CTRL(port, cr);
 72 }
 73 
 74 static void apbuart_enable_ms(struct uart_port *port)
 75 {
 76         /* No modem status change interrupts for APBUART */
 77 }
 78 
 79 static void apbuart_rx_chars(struct uart_port *port)
 80 {
 81         unsigned int status, ch, rsr, flag;
 82         unsigned int max_chars = port->fifosize;
 83 
 84         status = UART_GET_STATUS(port);
 85 
 86         while (UART_RX_DATA(status) && (max_chars--)) {
 87 
 88                 ch = UART_GET_CHAR(port);
 89                 flag = TTY_NORMAL;
 90 
 91                 port->icount.rx++;
 92 
 93                 rsr = UART_GET_STATUS(port) | UART_DUMMY_RSR_RX;
 94                 UART_PUT_STATUS(port, 0);
 95                 if (rsr & UART_STATUS_ERR) {
 96 
 97                         if (rsr & UART_STATUS_BR) {
 98                                 rsr &= ~(UART_STATUS_FE | UART_STATUS_PE);
 99                                 port->icount.brk++;
100                                 if (uart_handle_break(port))
101                                         goto ignore_char;
102                         } else if (rsr & UART_STATUS_PE) {
103                                 port->icount.parity++;
104                         } else if (rsr & UART_STATUS_FE) {
105                                 port->icount.frame++;
106                         }
107                         if (rsr & UART_STATUS_OE)
108                                 port->icount.overrun++;
109 
110                         rsr &= port->read_status_mask;
111 
112                         if (rsr & UART_STATUS_PE)
113                                 flag = TTY_PARITY;
114                         else if (rsr & UART_STATUS_FE)
115                                 flag = TTY_FRAME;
116                 }
117 
118                 if (uart_handle_sysrq_char(port, ch))
119                         goto ignore_char;
120 
121                 uart_insert_char(port, rsr, UART_STATUS_OE, ch, flag);
122 
123 
124               ignore_char:
125                 status = UART_GET_STATUS(port);
126         }
127 
128         spin_unlock(&port->lock);
129         tty_flip_buffer_push(&port->state->port);
130         spin_lock(&port->lock);
131 }
132 
133 static void apbuart_tx_chars(struct uart_port *port)
134 {
135         struct circ_buf *xmit = &port->state->xmit;
136         int count;
137 
138         if (port->x_char) {
139                 UART_PUT_CHAR(port, port->x_char);
140                 port->icount.tx++;
141                 port->x_char = 0;
142                 return;
143         }
144 
145         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
146                 apbuart_stop_tx(port);
147                 return;
148         }
149 
150         /* amba: fill FIFO */
151         count = port->fifosize >> 1;
152         do {
153                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
154                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
155                 port->icount.tx++;
156                 if (uart_circ_empty(xmit))
157                         break;
158         } while (--count > 0);
159 
160         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
161                 uart_write_wakeup(port);
162 
163         if (uart_circ_empty(xmit))
164                 apbuart_stop_tx(port);
165 }
166 
167 static irqreturn_t apbuart_int(int irq, void *dev_id)
168 {
169         struct uart_port *port = dev_id;
170         unsigned int status;
171 
172         spin_lock(&port->lock);
173 
174         status = UART_GET_STATUS(port);
175         if (status & UART_STATUS_DR)
176                 apbuart_rx_chars(port);
177         if (status & UART_STATUS_THE)
178                 apbuart_tx_chars(port);
179 
180         spin_unlock(&port->lock);
181 
182         return IRQ_HANDLED;
183 }
184 
185 static unsigned int apbuart_tx_empty(struct uart_port *port)
186 {
187         unsigned int status = UART_GET_STATUS(port);
188         return status & UART_STATUS_THE ? TIOCSER_TEMT : 0;
189 }
190 
191 static unsigned int apbuart_get_mctrl(struct uart_port *port)
192 {
193         /* The GRLIB APBUART handles flow control in hardware */
194         return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
195 }
196 
197 static void apbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
198 {
199         /* The GRLIB APBUART handles flow control in hardware */
200 }
201 
202 static void apbuart_break_ctl(struct uart_port *port, int break_state)
203 {
204         /* We don't support sending break */
205 }
206 
207 static int apbuart_startup(struct uart_port *port)
208 {
209         int retval;
210         unsigned int cr;
211 
212         /* Allocate the IRQ */
213         retval = request_irq(port->irq, apbuart_int, 0, "apbuart", port);
214         if (retval)
215                 return retval;
216 
217         /* Finally, enable interrupts */
218         cr = UART_GET_CTRL(port);
219         UART_PUT_CTRL(port,
220                       cr | UART_CTRL_RE | UART_CTRL_TE |
221                       UART_CTRL_RI | UART_CTRL_TI);
222 
223         return 0;
224 }
225 
226 static void apbuart_shutdown(struct uart_port *port)
227 {
228         unsigned int cr;
229 
230         /* disable all interrupts, disable the port */
231         cr = UART_GET_CTRL(port);
232         UART_PUT_CTRL(port,
233                       cr & ~(UART_CTRL_RE | UART_CTRL_TE |
234                              UART_CTRL_RI | UART_CTRL_TI));
235 
236         /* Free the interrupt */
237         free_irq(port->irq, port);
238 }
239 
240 static void apbuart_set_termios(struct uart_port *port,
241                                 struct ktermios *termios, struct ktermios *old)
242 {
243         unsigned int cr;
244         unsigned long flags;
245         unsigned int baud, quot;
246 
247         /* Ask the core to calculate the divisor for us. */
248         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
249         if (baud == 0)
250                 panic("invalid baudrate %i\n", port->uartclk / 16);
251 
252         /* uart_get_divisor calc a *16 uart freq, apbuart is *8 */
253         quot = (uart_get_divisor(port, baud)) * 2;
254         cr = UART_GET_CTRL(port);
255         cr &= ~(UART_CTRL_PE | UART_CTRL_PS);
256 
257         if (termios->c_cflag & PARENB) {
258                 cr |= UART_CTRL_PE;
259                 if ((termios->c_cflag & PARODD))
260                         cr |= UART_CTRL_PS;
261         }
262 
263         /* Enable flow control. */
264         if (termios->c_cflag & CRTSCTS)
265                 cr |= UART_CTRL_FL;
266 
267         spin_lock_irqsave(&port->lock, flags);
268 
269         /* Update the per-port timeout. */
270         uart_update_timeout(port, termios->c_cflag, baud);
271 
272         port->read_status_mask = UART_STATUS_OE;
273         if (termios->c_iflag & INPCK)
274                 port->read_status_mask |= UART_STATUS_FE | UART_STATUS_PE;
275 
276         /* Characters to ignore */
277         port->ignore_status_mask = 0;
278         if (termios->c_iflag & IGNPAR)
279                 port->ignore_status_mask |= UART_STATUS_FE | UART_STATUS_PE;
280 
281         /* Ignore all characters if CREAD is not set. */
282         if ((termios->c_cflag & CREAD) == 0)
283                 port->ignore_status_mask |= UART_DUMMY_RSR_RX;
284 
285         /* Set baud rate */
286         quot -= 1;
287         UART_PUT_SCAL(port, quot);
288         UART_PUT_CTRL(port, cr);
289 
290         spin_unlock_irqrestore(&port->lock, flags);
291 }
292 
293 static const char *apbuart_type(struct uart_port *port)
294 {
295         return port->type == PORT_APBUART ? "GRLIB/APBUART" : NULL;
296 }
297 
298 static void apbuart_release_port(struct uart_port *port)
299 {
300         release_mem_region(port->mapbase, 0x100);
301 }
302 
303 static int apbuart_request_port(struct uart_port *port)
304 {
305         return request_mem_region(port->mapbase, 0x100, "grlib-apbuart")
306             != NULL ? 0 : -EBUSY;
307         return 0;
308 }
309 
310 /* Configure/autoconfigure the port */
311 static void apbuart_config_port(struct uart_port *port, int flags)
312 {
313         if (flags & UART_CONFIG_TYPE) {
314                 port->type = PORT_APBUART;
315                 apbuart_request_port(port);
316         }
317 }
318 
319 /* Verify the new serial_struct (for TIOCSSERIAL) */
320 static int apbuart_verify_port(struct uart_port *port,
321                                struct serial_struct *ser)
322 {
323         int ret = 0;
324         if (ser->type != PORT_UNKNOWN && ser->type != PORT_APBUART)
325                 ret = -EINVAL;
326         if (ser->irq < 0 || ser->irq >= NR_IRQS)
327                 ret = -EINVAL;
328         if (ser->baud_base < 9600)
329                 ret = -EINVAL;
330         return ret;
331 }
332 
333 static struct uart_ops grlib_apbuart_ops = {
334         .tx_empty = apbuart_tx_empty,
335         .set_mctrl = apbuart_set_mctrl,
336         .get_mctrl = apbuart_get_mctrl,
337         .stop_tx = apbuart_stop_tx,
338         .start_tx = apbuart_start_tx,
339         .stop_rx = apbuart_stop_rx,
340         .enable_ms = apbuart_enable_ms,
341         .break_ctl = apbuart_break_ctl,
342         .startup = apbuart_startup,
343         .shutdown = apbuart_shutdown,
344         .set_termios = apbuart_set_termios,
345         .type = apbuart_type,
346         .release_port = apbuart_release_port,
347         .request_port = apbuart_request_port,
348         .config_port = apbuart_config_port,
349         .verify_port = apbuart_verify_port,
350 };
351 
352 static struct uart_port grlib_apbuart_ports[UART_NR];
353 static struct device_node *grlib_apbuart_nodes[UART_NR];
354 
355 static int apbuart_scan_fifo_size(struct uart_port *port, int portnumber)
356 {
357         int ctrl, loop = 0;
358         int status;
359         int fifosize;
360         unsigned long flags;
361 
362         ctrl = UART_GET_CTRL(port);
363 
364         /*
365          * Enable the transceiver and wait for it to be ready to send data.
366          * Clear interrupts so that this process will not be externally
367          * interrupted in the middle (which can cause the transceiver to
368          * drain prematurely).
369          */
370 
371         local_irq_save(flags);
372 
373         UART_PUT_CTRL(port, ctrl | UART_CTRL_TE);
374 
375         while (!UART_TX_READY(UART_GET_STATUS(port)))
376                 loop++;
377 
378         /*
379          * Disable the transceiver so data isn't actually sent during the
380          * actual test.
381          */
382 
383         UART_PUT_CTRL(port, ctrl & ~(UART_CTRL_TE));
384 
385         fifosize = 1;
386         UART_PUT_CHAR(port, 0);
387 
388         /*
389          * So long as transmitting a character increments the tranceivier FIFO
390          * length the FIFO must be at least that big. These bytes will
391          * automatically drain off of the FIFO.
392          */
393 
394         status = UART_GET_STATUS(port);
395         while (((status >> 20) & 0x3F) == fifosize) {
396                 fifosize++;
397                 UART_PUT_CHAR(port, 0);
398                 status = UART_GET_STATUS(port);
399         }
400 
401         fifosize--;
402 
403         UART_PUT_CTRL(port, ctrl);
404         local_irq_restore(flags);
405 
406         if (fifosize == 0)
407                 fifosize = 1;
408 
409         return fifosize;
410 }
411 
412 static void apbuart_flush_fifo(struct uart_port *port)
413 {
414         int i;
415 
416         for (i = 0; i < port->fifosize; i++)
417                 UART_GET_CHAR(port);
418 }
419 
420 
421 /* ======================================================================== */
422 /* Console driver, if enabled                                               */
423 /* ======================================================================== */
424 
425 #ifdef CONFIG_SERIAL_GRLIB_GAISLER_APBUART_CONSOLE
426 
427 static void apbuart_console_putchar(struct uart_port *port, int ch)
428 {
429         unsigned int status;
430         do {
431                 status = UART_GET_STATUS(port);
432         } while (!UART_TX_READY(status));
433         UART_PUT_CHAR(port, ch);
434 }
435 
436 static void
437 apbuart_console_write(struct console *co, const char *s, unsigned int count)
438 {
439         struct uart_port *port = &grlib_apbuart_ports[co->index];
440         unsigned int status, old_cr, new_cr;
441 
442         /* First save the CR then disable the interrupts */
443         old_cr = UART_GET_CTRL(port);
444         new_cr = old_cr & ~(UART_CTRL_RI | UART_CTRL_TI);
445         UART_PUT_CTRL(port, new_cr);
446 
447         uart_console_write(port, s, count, apbuart_console_putchar);
448 
449         /*
450          *      Finally, wait for transmitter to become empty
451          *      and restore the TCR
452          */
453         do {
454                 status = UART_GET_STATUS(port);
455         } while (!UART_TX_READY(status));
456         UART_PUT_CTRL(port, old_cr);
457 }
458 
459 static void __init
460 apbuart_console_get_options(struct uart_port *port, int *baud,
461                             int *parity, int *bits)
462 {
463         if (UART_GET_CTRL(port) & (UART_CTRL_RE | UART_CTRL_TE)) {
464 
465                 unsigned int quot, status;
466                 status = UART_GET_STATUS(port);
467 
468                 *parity = 'n';
469                 if (status & UART_CTRL_PE) {
470                         if ((status & UART_CTRL_PS) == 0)
471                                 *parity = 'e';
472                         else
473                                 *parity = 'o';
474                 }
475 
476                 *bits = 8;
477                 quot = UART_GET_SCAL(port) / 8;
478                 *baud = port->uartclk / (16 * (quot + 1));
479         }
480 }
481 
482 static int __init apbuart_console_setup(struct console *co, char *options)
483 {
484         struct uart_port *port;
485         int baud = 38400;
486         int bits = 8;
487         int parity = 'n';
488         int flow = 'n';
489 
490         pr_debug("apbuart_console_setup co=%p, co->index=%i, options=%s\n",
491                  co, co->index, options);
492 
493         /*
494          * Check whether an invalid uart number has been specified, and
495          * if so, search for the first available port that does have
496          * console support.
497          */
498         if (co->index >= grlib_apbuart_port_nr)
499                 co->index = 0;
500 
501         port = &grlib_apbuart_ports[co->index];
502 
503         spin_lock_init(&port->lock);
504 
505         if (options)
506                 uart_parse_options(options, &baud, &parity, &bits, &flow);
507         else
508                 apbuart_console_get_options(port, &baud, &parity, &bits);
509 
510         return uart_set_options(port, co, baud, parity, bits, flow);
511 }
512 
513 static struct uart_driver grlib_apbuart_driver;
514 
515 static struct console grlib_apbuart_console = {
516         .name = "ttyS",
517         .write = apbuart_console_write,
518         .device = uart_console_device,
519         .setup = apbuart_console_setup,
520         .flags = CON_PRINTBUFFER,
521         .index = -1,
522         .data = &grlib_apbuart_driver,
523 };
524 
525 
526 static int grlib_apbuart_configure(void);
527 
528 static int __init apbuart_console_init(void)
529 {
530         if (grlib_apbuart_configure())
531                 return -ENODEV;
532         register_console(&grlib_apbuart_console);
533         return 0;
534 }
535 
536 console_initcall(apbuart_console_init);
537 
538 #define APBUART_CONSOLE (&grlib_apbuart_console)
539 #else
540 #define APBUART_CONSOLE NULL
541 #endif
542 
543 static struct uart_driver grlib_apbuart_driver = {
544         .owner = THIS_MODULE,
545         .driver_name = "serial",
546         .dev_name = "ttyS",
547         .major = SERIAL_APBUART_MAJOR,
548         .minor = SERIAL_APBUART_MINOR,
549         .nr = UART_NR,
550         .cons = APBUART_CONSOLE,
551 };
552 
553 
554 /* ======================================================================== */
555 /* OF Platform Driver                                                       */
556 /* ======================================================================== */
557 
558 static int apbuart_probe(struct platform_device *op)
559 {
560         int i;
561         struct uart_port *port = NULL;
562 
563         for (i = 0; i < grlib_apbuart_port_nr; i++) {
564                 if (op->dev.of_node == grlib_apbuart_nodes[i])
565                         break;
566         }
567 
568         port = &grlib_apbuart_ports[i];
569         port->dev = &op->dev;
570         port->irq = op->archdata.irqs[0];
571 
572         uart_add_one_port(&grlib_apbuart_driver, (struct uart_port *) port);
573 
574         apbuart_flush_fifo((struct uart_port *) port);
575 
576         printk(KERN_INFO "grlib-apbuart at 0x%llx, irq %d\n",
577                (unsigned long long) port->mapbase, port->irq);
578         return 0;
579 }
580 
581 static struct of_device_id apbuart_match[] = {
582         {
583          .name = "GAISLER_APBUART",
584          },
585         {
586          .name = "01_00c",
587          },
588         {},
589 };
590 
591 static struct platform_driver grlib_apbuart_of_driver = {
592         .probe = apbuart_probe,
593         .driver = {
594                 .owner = THIS_MODULE,
595                 .name = "grlib-apbuart",
596                 .of_match_table = apbuart_match,
597         },
598 };
599 
600 
601 static int __init grlib_apbuart_configure(void)
602 {
603         struct device_node *np;
604         int line = 0;
605 
606         for_each_matching_node(np, apbuart_match) {
607                 const int *ampopts;
608                 const u32 *freq_hz;
609                 const struct amba_prom_registers *regs;
610                 struct uart_port *port;
611                 unsigned long addr;
612 
613                 ampopts = of_get_property(np, "ampopts", NULL);
614                 if (ampopts && (*ampopts == 0))
615                         continue; /* Ignore if used by another OS instance */
616                 regs = of_get_property(np, "reg", NULL);
617                 /* Frequency of APB Bus is frequency of UART */
618                 freq_hz = of_get_property(np, "freq", NULL);
619 
620                 if (!regs || !freq_hz || (*freq_hz == 0))
621                         continue;
622 
623                 grlib_apbuart_nodes[line] = np;
624 
625                 addr = regs->phys_addr;
626 
627                 port = &grlib_apbuart_ports[line];
628 
629                 port->mapbase = addr;
630                 port->membase = ioremap(addr, sizeof(struct grlib_apbuart_regs_map));
631                 port->irq = 0;
632                 port->iotype = UPIO_MEM;
633                 port->ops = &grlib_apbuart_ops;
634                 port->flags = UPF_BOOT_AUTOCONF;
635                 port->line = line;
636                 port->uartclk = *freq_hz;
637                 port->fifosize = apbuart_scan_fifo_size((struct uart_port *) port, line);
638                 line++;
639 
640                 /* We support maximum UART_NR uarts ... */
641                 if (line == UART_NR)
642                         break;
643         }
644 
645         grlib_apbuart_driver.nr = grlib_apbuart_port_nr = line;
646         return line ? 0 : -ENODEV;
647 }
648 
649 static int __init grlib_apbuart_init(void)
650 {
651         int ret;
652 
653         /* Find all APBUARTS in device the tree and initialize their ports */
654         ret = grlib_apbuart_configure();
655         if (ret)
656                 return ret;
657 
658         printk(KERN_INFO "Serial: GRLIB APBUART driver\n");
659 
660         ret = uart_register_driver(&grlib_apbuart_driver);
661 
662         if (ret) {
663                 printk(KERN_ERR "%s: uart_register_driver failed (%i)\n",
664                        __FILE__, ret);
665                 return ret;
666         }
667 
668         ret = platform_driver_register(&grlib_apbuart_of_driver);
669         if (ret) {
670                 printk(KERN_ERR
671                        "%s: platform_driver_register failed (%i)\n",
672                        __FILE__, ret);
673                 uart_unregister_driver(&grlib_apbuart_driver);
674                 return ret;
675         }
676 
677         return ret;
678 }
679 
680 static void __exit grlib_apbuart_exit(void)
681 {
682         int i;
683 
684         for (i = 0; i < grlib_apbuart_port_nr; i++)
685                 uart_remove_one_port(&grlib_apbuart_driver,
686                                      &grlib_apbuart_ports[i]);
687 
688         uart_unregister_driver(&grlib_apbuart_driver);
689         platform_driver_unregister(&grlib_apbuart_of_driver);
690 }
691 
692 module_init(grlib_apbuart_init);
693 module_exit(grlib_apbuart_exit);
694 
695 MODULE_AUTHOR("Aeroflex Gaisler AB");
696 MODULE_DESCRIPTION("GRLIB APBUART serial driver");
697 MODULE_VERSION("2.1");
698 MODULE_LICENSE("GPL");
699 

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