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