1/*
2 * Copyright (C) 2012-2015 Spreadtrum Communications Inc.
3 *
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * GNU General Public License for more details.
12 */
13
14#if defined(CONFIG_SERIAL_SPRD_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
15#define SUPPORT_SYSRQ
16#endif
17
18#include <linux/clk.h>
19#include <linux/console.h>
20#include <linux/delay.h>
21#include <linux/io.h>
22#include <linux/ioport.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/of.h>
26#include <linux/platform_device.h>
27#include <linux/serial_core.h>
28#include <linux/serial.h>
29#include <linux/slab.h>
30#include <linux/tty.h>
31#include <linux/tty_flip.h>
32
33/* device name */
34#define UART_NR_MAX		8
35#define SPRD_TTY_NAME		"ttyS"
36#define SPRD_FIFO_SIZE		128
37#define SPRD_DEF_RATE		26000000
38#define SPRD_BAUD_IO_LIMIT	3000000
39#define SPRD_TIMEOUT		256
40
41/* the offset of serial registers and BITs for them */
42/* data registers */
43#define SPRD_TXD		0x0000
44#define SPRD_RXD		0x0004
45
46/* line status register and its BITs  */
47#define SPRD_LSR		0x0008
48#define SPRD_LSR_OE		BIT(4)
49#define SPRD_LSR_FE		BIT(3)
50#define SPRD_LSR_PE		BIT(2)
51#define SPRD_LSR_BI		BIT(7)
52#define SPRD_LSR_TX_OVER	BIT(15)
53
54/* data number in TX and RX fifo */
55#define SPRD_STS1		0x000C
56
57/* interrupt enable register and its BITs */
58#define SPRD_IEN		0x0010
59#define SPRD_IEN_RX_FULL	BIT(0)
60#define SPRD_IEN_TX_EMPTY	BIT(1)
61#define SPRD_IEN_BREAK_DETECT	BIT(7)
62#define SPRD_IEN_TIMEOUT	BIT(13)
63
64/* interrupt clear register */
65#define SPRD_ICLR		0x0014
66
67/* line control register */
68#define SPRD_LCR		0x0018
69#define SPRD_LCR_STOP_1BIT	0x10
70#define SPRD_LCR_STOP_2BIT	0x30
71#define SPRD_LCR_DATA_LEN	(BIT(2) | BIT(3))
72#define SPRD_LCR_DATA_LEN5	0x0
73#define SPRD_LCR_DATA_LEN6	0x4
74#define SPRD_LCR_DATA_LEN7	0x8
75#define SPRD_LCR_DATA_LEN8	0xc
76#define SPRD_LCR_PARITY	(BIT(0) | BIT(1))
77#define SPRD_LCR_PARITY_EN	0x2
78#define SPRD_LCR_EVEN_PAR	0x0
79#define SPRD_LCR_ODD_PAR	0x1
80
81/* control register 1 */
82#define SPRD_CTL1			0x001C
83#define RX_HW_FLOW_CTL_THLD	BIT(6)
84#define RX_HW_FLOW_CTL_EN	BIT(7)
85#define TX_HW_FLOW_CTL_EN	BIT(8)
86#define RX_TOUT_THLD_DEF	0x3E00
87#define RX_HFC_THLD_DEF	0x40
88
89/* fifo threshold register */
90#define SPRD_CTL2		0x0020
91#define THLD_TX_EMPTY	0x40
92#define THLD_RX_FULL	0x40
93
94/* config baud rate register */
95#define SPRD_CLKD0		0x0024
96#define SPRD_CLKD1		0x0028
97
98/* interrupt mask status register */
99#define SPRD_IMSR			0x002C
100#define SPRD_IMSR_RX_FIFO_FULL		BIT(0)
101#define SPRD_IMSR_TX_FIFO_EMPTY	BIT(1)
102#define SPRD_IMSR_BREAK_DETECT		BIT(7)
103#define SPRD_IMSR_TIMEOUT		BIT(13)
104
105struct reg_backup {
106	u32 ien;
107	u32 ctrl0;
108	u32 ctrl1;
109	u32 ctrl2;
110	u32 clkd0;
111	u32 clkd1;
112	u32 dspwait;
113};
114
115struct sprd_uart_port {
116	struct uart_port port;
117	struct reg_backup reg_bak;
118	char name[16];
119};
120
121static struct sprd_uart_port *sprd_port[UART_NR_MAX];
122static int sprd_ports_num;
123
124static inline unsigned int serial_in(struct uart_port *port, int offset)
125{
126	return readl_relaxed(port->membase + offset);
127}
128
129static inline void serial_out(struct uart_port *port, int offset, int value)
130{
131	writel_relaxed(value, port->membase + offset);
132}
133
134static unsigned int sprd_tx_empty(struct uart_port *port)
135{
136	if (serial_in(port, SPRD_STS1) & 0xff00)
137		return 0;
138	else
139		return TIOCSER_TEMT;
140}
141
142static unsigned int sprd_get_mctrl(struct uart_port *port)
143{
144	return TIOCM_DSR | TIOCM_CTS;
145}
146
147static void sprd_set_mctrl(struct uart_port *port, unsigned int mctrl)
148{
149	/* nothing to do */
150}
151
152static void sprd_stop_tx(struct uart_port *port)
153{
154	unsigned int ien, iclr;
155
156	iclr = serial_in(port, SPRD_ICLR);
157	ien = serial_in(port, SPRD_IEN);
158
159	iclr |= SPRD_IEN_TX_EMPTY;
160	ien &= ~SPRD_IEN_TX_EMPTY;
161
162	serial_out(port, SPRD_ICLR, iclr);
163	serial_out(port, SPRD_IEN, ien);
164}
165
166static void sprd_start_tx(struct uart_port *port)
167{
168	unsigned int ien;
169
170	ien = serial_in(port, SPRD_IEN);
171	if (!(ien & SPRD_IEN_TX_EMPTY)) {
172		ien |= SPRD_IEN_TX_EMPTY;
173		serial_out(port, SPRD_IEN, ien);
174	}
175}
176
177static void sprd_stop_rx(struct uart_port *port)
178{
179	unsigned int ien, iclr;
180
181	iclr = serial_in(port, SPRD_ICLR);
182	ien = serial_in(port, SPRD_IEN);
183
184	ien &= ~(SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT);
185	iclr |= SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT;
186
187	serial_out(port, SPRD_IEN, ien);
188	serial_out(port, SPRD_ICLR, iclr);
189}
190
191/* The Sprd serial does not support this function. */
192static void sprd_break_ctl(struct uart_port *port, int break_state)
193{
194	/* nothing to do */
195}
196
197static int handle_lsr_errors(struct uart_port *port,
198			     unsigned int *flag,
199			     unsigned int *lsr)
200{
201	int ret = 0;
202
203	/* statistics */
204	if (*lsr & SPRD_LSR_BI) {
205		*lsr &= ~(SPRD_LSR_FE | SPRD_LSR_PE);
206		port->icount.brk++;
207		ret = uart_handle_break(port);
208		if (ret)
209			return ret;
210	} else if (*lsr & SPRD_LSR_PE)
211		port->icount.parity++;
212	else if (*lsr & SPRD_LSR_FE)
213		port->icount.frame++;
214	if (*lsr & SPRD_LSR_OE)
215		port->icount.overrun++;
216
217	/* mask off conditions which should be ignored */
218	*lsr &= port->read_status_mask;
219	if (*lsr & SPRD_LSR_BI)
220		*flag = TTY_BREAK;
221	else if (*lsr & SPRD_LSR_PE)
222		*flag = TTY_PARITY;
223	else if (*lsr & SPRD_LSR_FE)
224		*flag = TTY_FRAME;
225
226	return ret;
227}
228
229static inline void sprd_rx(struct uart_port *port)
230{
231	struct tty_port *tty = &port->state->port;
232	unsigned int ch, flag, lsr, max_count = SPRD_TIMEOUT;
233
234	while ((serial_in(port, SPRD_STS1) & 0x00ff) && max_count--) {
235		lsr = serial_in(port, SPRD_LSR);
236		ch = serial_in(port, SPRD_RXD);
237		flag = TTY_NORMAL;
238		port->icount.rx++;
239
240		if (lsr & (SPRD_LSR_BI | SPRD_LSR_PE |
241			SPRD_LSR_FE | SPRD_LSR_OE))
242			if (handle_lsr_errors(port, &lsr, &flag))
243				continue;
244		if (uart_handle_sysrq_char(port, ch))
245			continue;
246
247		uart_insert_char(port, lsr, SPRD_LSR_OE, ch, flag);
248	}
249
250	tty_flip_buffer_push(tty);
251}
252
253static inline void sprd_tx(struct uart_port *port)
254{
255	struct circ_buf *xmit = &port->state->xmit;
256	int count;
257
258	if (port->x_char) {
259		serial_out(port, SPRD_TXD, port->x_char);
260		port->icount.tx++;
261		port->x_char = 0;
262		return;
263	}
264
265	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
266		sprd_stop_tx(port);
267		return;
268	}
269
270	count = THLD_TX_EMPTY;
271	do {
272		serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]);
273		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
274		port->icount.tx++;
275		if (uart_circ_empty(xmit))
276			break;
277	} while (--count > 0);
278
279	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
280		uart_write_wakeup(port);
281
282	if (uart_circ_empty(xmit))
283		sprd_stop_tx(port);
284}
285
286/* this handles the interrupt from one port */
287static irqreturn_t sprd_handle_irq(int irq, void *dev_id)
288{
289	struct uart_port *port = dev_id;
290	unsigned int ims;
291
292	spin_lock(&port->lock);
293
294	ims = serial_in(port, SPRD_IMSR);
295
296	if (!ims) {
297		spin_unlock(&port->lock);
298		return IRQ_NONE;
299	}
300
301	serial_out(port, SPRD_ICLR, ~0);
302
303	if (ims & (SPRD_IMSR_RX_FIFO_FULL |
304		SPRD_IMSR_BREAK_DETECT | SPRD_IMSR_TIMEOUT))
305		sprd_rx(port);
306
307	if (ims & SPRD_IMSR_TX_FIFO_EMPTY)
308		sprd_tx(port);
309
310	spin_unlock(&port->lock);
311
312	return IRQ_HANDLED;
313}
314
315static int sprd_startup(struct uart_port *port)
316{
317	int ret = 0;
318	unsigned int ien, fc;
319	unsigned int timeout;
320	struct sprd_uart_port *sp;
321	unsigned long flags;
322
323	serial_out(port, SPRD_CTL2, ((THLD_TX_EMPTY << 8) | THLD_RX_FULL));
324
325	/* clear rx fifo */
326	timeout = SPRD_TIMEOUT;
327	while (timeout-- && serial_in(port, SPRD_STS1) & 0x00ff)
328		serial_in(port, SPRD_RXD);
329
330	/* clear tx fifo */
331	timeout = SPRD_TIMEOUT;
332	while (timeout-- && serial_in(port, SPRD_STS1) & 0xff00)
333		cpu_relax();
334
335	/* clear interrupt */
336	serial_out(port, SPRD_IEN, 0);
337	serial_out(port, SPRD_ICLR, ~0);
338
339	/* allocate irq */
340	sp = container_of(port, struct sprd_uart_port, port);
341	snprintf(sp->name, sizeof(sp->name), "sprd_serial%d", port->line);
342	ret = devm_request_irq(port->dev, port->irq, sprd_handle_irq,
343				IRQF_SHARED, sp->name, port);
344	if (ret) {
345		dev_err(port->dev, "fail to request serial irq %d, ret=%d\n",
346			port->irq, ret);
347		return ret;
348	}
349	fc = serial_in(port, SPRD_CTL1);
350	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
351	serial_out(port, SPRD_CTL1, fc);
352
353	/* enable interrupt */
354	spin_lock_irqsave(&port->lock, flags);
355	ien = serial_in(port, SPRD_IEN);
356	ien |= SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT | SPRD_IEN_TIMEOUT;
357	serial_out(port, SPRD_IEN, ien);
358	spin_unlock_irqrestore(&port->lock, flags);
359
360	return 0;
361}
362
363static void sprd_shutdown(struct uart_port *port)
364{
365	serial_out(port, SPRD_IEN, 0);
366	serial_out(port, SPRD_ICLR, ~0);
367	devm_free_irq(port->dev, port->irq, port);
368}
369
370static void sprd_set_termios(struct uart_port *port,
371				    struct ktermios *termios,
372				    struct ktermios *old)
373{
374	unsigned int baud, quot;
375	unsigned int lcr = 0, fc;
376	unsigned long flags;
377
378	/* ask the core to calculate the divisor for us */
379	baud = uart_get_baud_rate(port, termios, old, 0, SPRD_BAUD_IO_LIMIT);
380
381	quot = (unsigned int)((port->uartclk + baud / 2) / baud);
382
383	/* set data length */
384	switch (termios->c_cflag & CSIZE) {
385	case CS5:
386		lcr |= SPRD_LCR_DATA_LEN5;
387		break;
388	case CS6:
389		lcr |= SPRD_LCR_DATA_LEN6;
390		break;
391	case CS7:
392		lcr |= SPRD_LCR_DATA_LEN7;
393		break;
394	case CS8:
395	default:
396		lcr |= SPRD_LCR_DATA_LEN8;
397		break;
398	}
399
400	/* calculate stop bits */
401	lcr &= ~(SPRD_LCR_STOP_1BIT | SPRD_LCR_STOP_2BIT);
402	if (termios->c_cflag & CSTOPB)
403		lcr |= SPRD_LCR_STOP_2BIT;
404	else
405		lcr |= SPRD_LCR_STOP_1BIT;
406
407	/* calculate parity */
408	lcr &= ~SPRD_LCR_PARITY;
409	termios->c_cflag &= ~CMSPAR;	/* no support mark/space */
410	if (termios->c_cflag & PARENB) {
411		lcr |= SPRD_LCR_PARITY_EN;
412		if (termios->c_cflag & PARODD)
413			lcr |= SPRD_LCR_ODD_PAR;
414		else
415			lcr |= SPRD_LCR_EVEN_PAR;
416	}
417
418	spin_lock_irqsave(&port->lock, flags);
419
420	/* update the per-port timeout */
421	uart_update_timeout(port, termios->c_cflag, baud);
422
423	port->read_status_mask = SPRD_LSR_OE;
424	if (termios->c_iflag & INPCK)
425		port->read_status_mask |= SPRD_LSR_FE | SPRD_LSR_PE;
426	if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
427		port->read_status_mask |= SPRD_LSR_BI;
428
429	/* characters to ignore */
430	port->ignore_status_mask = 0;
431	if (termios->c_iflag & IGNPAR)
432		port->ignore_status_mask |= SPRD_LSR_PE | SPRD_LSR_FE;
433	if (termios->c_iflag & IGNBRK) {
434		port->ignore_status_mask |= SPRD_LSR_BI;
435		/*
436		 * If we're ignoring parity and break indicators,
437		 * ignore overruns too (for real raw support).
438		 */
439		if (termios->c_iflag & IGNPAR)
440			port->ignore_status_mask |= SPRD_LSR_OE;
441	}
442
443	/* flow control */
444	fc = serial_in(port, SPRD_CTL1);
445	fc &= ~(RX_HW_FLOW_CTL_THLD | RX_HW_FLOW_CTL_EN | TX_HW_FLOW_CTL_EN);
446	if (termios->c_cflag & CRTSCTS) {
447		fc |= RX_HW_FLOW_CTL_THLD;
448		fc |= RX_HW_FLOW_CTL_EN;
449		fc |= TX_HW_FLOW_CTL_EN;
450	}
451
452	/* clock divider bit0~bit15 */
453	serial_out(port, SPRD_CLKD0, quot & 0xffff);
454
455	/* clock divider bit16~bit20 */
456	serial_out(port, SPRD_CLKD1, (quot & 0x1f0000) >> 16);
457	serial_out(port, SPRD_LCR, lcr);
458	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
459	serial_out(port, SPRD_CTL1, fc);
460
461	spin_unlock_irqrestore(&port->lock, flags);
462
463	/* Don't rewrite B0 */
464	if (tty_termios_baud_rate(termios))
465		tty_termios_encode_baud_rate(termios, baud, baud);
466}
467
468static const char *sprd_type(struct uart_port *port)
469{
470	return "SPX";
471}
472
473static void sprd_release_port(struct uart_port *port)
474{
475	/* nothing to do */
476}
477
478static int sprd_request_port(struct uart_port *port)
479{
480	return 0;
481}
482
483static void sprd_config_port(struct uart_port *port, int flags)
484{
485	if (flags & UART_CONFIG_TYPE)
486		port->type = PORT_SPRD;
487}
488
489static int sprd_verify_port(struct uart_port *port,
490				   struct serial_struct *ser)
491{
492	if (ser->type != PORT_SPRD)
493		return -EINVAL;
494	if (port->irq != ser->irq)
495		return -EINVAL;
496	if (port->iotype != ser->io_type)
497		return -EINVAL;
498	return 0;
499}
500
501static struct uart_ops serial_sprd_ops = {
502	.tx_empty = sprd_tx_empty,
503	.get_mctrl = sprd_get_mctrl,
504	.set_mctrl = sprd_set_mctrl,
505	.stop_tx = sprd_stop_tx,
506	.start_tx = sprd_start_tx,
507	.stop_rx = sprd_stop_rx,
508	.break_ctl = sprd_break_ctl,
509	.startup = sprd_startup,
510	.shutdown = sprd_shutdown,
511	.set_termios = sprd_set_termios,
512	.type = sprd_type,
513	.release_port = sprd_release_port,
514	.request_port = sprd_request_port,
515	.config_port = sprd_config_port,
516	.verify_port = sprd_verify_port,
517};
518
519#ifdef CONFIG_SERIAL_SPRD_CONSOLE
520static inline void wait_for_xmitr(struct uart_port *port)
521{
522	unsigned int status, tmout = 10000;
523
524	/* wait up to 10ms for the character(s) to be sent */
525	do {
526		status = serial_in(port, SPRD_STS1);
527		if (--tmout == 0)
528			break;
529		udelay(1);
530	} while (status & 0xff00);
531}
532
533static void sprd_console_putchar(struct uart_port *port, int ch)
534{
535	wait_for_xmitr(port);
536	serial_out(port, SPRD_TXD, ch);
537}
538
539static void sprd_console_write(struct console *co, const char *s,
540				      unsigned int count)
541{
542	struct uart_port *port = &sprd_port[co->index]->port;
543	int locked = 1;
544	unsigned long flags;
545
546	if (port->sysrq)
547		locked = 0;
548	else if (oops_in_progress)
549		locked = spin_trylock_irqsave(&port->lock, flags);
550	else
551		spin_lock_irqsave(&port->lock, flags);
552
553	uart_console_write(port, s, count, sprd_console_putchar);
554
555	/* wait for transmitter to become empty */
556	wait_for_xmitr(port);
557
558	if (locked)
559		spin_unlock_irqrestore(&port->lock, flags);
560}
561
562static int __init sprd_console_setup(struct console *co, char *options)
563{
564	struct uart_port *port;
565	int baud = 115200;
566	int bits = 8;
567	int parity = 'n';
568	int flow = 'n';
569
570	if (co->index >= UART_NR_MAX || co->index < 0)
571		co->index = 0;
572
573	port = &sprd_port[co->index]->port;
574	if (port == NULL) {
575		pr_info("serial port %d not yet initialized\n", co->index);
576		return -ENODEV;
577	}
578	if (options)
579		uart_parse_options(options, &baud, &parity, &bits, &flow);
580
581	return uart_set_options(port, co, baud, parity, bits, flow);
582}
583
584static struct uart_driver sprd_uart_driver;
585static struct console sprd_console = {
586	.name = SPRD_TTY_NAME,
587	.write = sprd_console_write,
588	.device = uart_console_device,
589	.setup = sprd_console_setup,
590	.flags = CON_PRINTBUFFER,
591	.index = -1,
592	.data = &sprd_uart_driver,
593};
594
595#define SPRD_CONSOLE	(&sprd_console)
596
597/* Support for earlycon */
598static void sprd_putc(struct uart_port *port, int c)
599{
600	unsigned int timeout = SPRD_TIMEOUT;
601
602	while (timeout-- &&
603		   !(readl(port->membase + SPRD_LSR) & SPRD_LSR_TX_OVER))
604		cpu_relax();
605
606	writeb(c, port->membase + SPRD_TXD);
607}
608
609static void sprd_early_write(struct console *con, const char *s,
610				    unsigned n)
611{
612	struct earlycon_device *dev = con->data;
613
614	uart_console_write(&dev->port, s, n, sprd_putc);
615}
616
617static int __init sprd_early_console_setup(
618				struct earlycon_device *device,
619				const char *opt)
620{
621	if (!device->port.membase)
622		return -ENODEV;
623
624	device->con->write = sprd_early_write;
625	return 0;
626}
627
628EARLYCON_DECLARE(sprd_serial, sprd_early_console_setup);
629OF_EARLYCON_DECLARE(sprd_serial, "sprd,sc9836-uart",
630		    sprd_early_console_setup);
631
632#else /* !CONFIG_SERIAL_SPRD_CONSOLE */
633#define SPRD_CONSOLE		NULL
634#endif
635
636static struct uart_driver sprd_uart_driver = {
637	.owner = THIS_MODULE,
638	.driver_name = "sprd_serial",
639	.dev_name = SPRD_TTY_NAME,
640	.major = 0,
641	.minor = 0,
642	.nr = UART_NR_MAX,
643	.cons = SPRD_CONSOLE,
644};
645
646static int sprd_probe_dt_alias(int index, struct device *dev)
647{
648	struct device_node *np;
649	int ret = index;
650
651	if (!IS_ENABLED(CONFIG_OF))
652		return ret;
653
654	np = dev->of_node;
655	if (!np)
656		return ret;
657
658	ret = of_alias_get_id(np, "serial");
659	if (IS_ERR_VALUE(ret))
660		ret = index;
661	else if (ret >= ARRAY_SIZE(sprd_port) || sprd_port[ret] != NULL) {
662		dev_warn(dev, "requested serial port %d not available.\n", ret);
663		ret = index;
664	}
665
666	return ret;
667}
668
669static int sprd_remove(struct platform_device *dev)
670{
671	struct sprd_uart_port *sup = platform_get_drvdata(dev);
672
673	if (sup) {
674		uart_remove_one_port(&sprd_uart_driver, &sup->port);
675		sprd_port[sup->port.line] = NULL;
676		sprd_ports_num--;
677	}
678
679	if (!sprd_ports_num)
680		uart_unregister_driver(&sprd_uart_driver);
681
682	return 0;
683}
684
685static int sprd_probe(struct platform_device *pdev)
686{
687	struct resource *res;
688	struct uart_port *up;
689	struct clk *clk;
690	int irq;
691	int index;
692	int ret;
693
694	for (index = 0; index < ARRAY_SIZE(sprd_port); index++)
695		if (sprd_port[index] == NULL)
696			break;
697
698	if (index == ARRAY_SIZE(sprd_port))
699		return -EBUSY;
700
701	index = sprd_probe_dt_alias(index, &pdev->dev);
702
703	sprd_port[index] = devm_kzalloc(&pdev->dev,
704		sizeof(*sprd_port[index]), GFP_KERNEL);
705	if (!sprd_port[index])
706		return -ENOMEM;
707
708	up = &sprd_port[index]->port;
709	up->dev = &pdev->dev;
710	up->line = index;
711	up->type = PORT_SPRD;
712	up->iotype = UPIO_MEM;
713	up->uartclk = SPRD_DEF_RATE;
714	up->fifosize = SPRD_FIFO_SIZE;
715	up->ops = &serial_sprd_ops;
716	up->flags = UPF_BOOT_AUTOCONF;
717
718	clk = devm_clk_get(&pdev->dev, NULL);
719	if (!IS_ERR(clk))
720		up->uartclk = clk_get_rate(clk);
721
722	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
723	if (!res) {
724		dev_err(&pdev->dev, "not provide mem resource\n");
725		return -ENODEV;
726	}
727	up->mapbase = res->start;
728	up->membase = devm_ioremap_resource(&pdev->dev, res);
729	if (IS_ERR(up->membase))
730		return PTR_ERR(up->membase);
731
732	irq = platform_get_irq(pdev, 0);
733	if (irq < 0) {
734		dev_err(&pdev->dev, "not provide irq resource\n");
735		return -ENODEV;
736	}
737	up->irq = irq;
738
739	if (!sprd_ports_num) {
740		ret = uart_register_driver(&sprd_uart_driver);
741		if (ret < 0) {
742			pr_err("Failed to register SPRD-UART driver\n");
743			return ret;
744		}
745	}
746	sprd_ports_num++;
747
748	ret = uart_add_one_port(&sprd_uart_driver, up);
749	if (ret) {
750		sprd_port[index] = NULL;
751		sprd_remove(pdev);
752	}
753
754	platform_set_drvdata(pdev, up);
755
756	return ret;
757}
758
759#ifdef CONFIG_PM_SLEEP
760static int sprd_suspend(struct device *dev)
761{
762	struct sprd_uart_port *sup = dev_get_drvdata(dev);
763
764	uart_suspend_port(&sprd_uart_driver, &sup->port);
765
766	return 0;
767}
768
769static int sprd_resume(struct device *dev)
770{
771	struct sprd_uart_port *sup = dev_get_drvdata(dev);
772
773	uart_resume_port(&sprd_uart_driver, &sup->port);
774
775	return 0;
776}
777#endif
778
779static SIMPLE_DEV_PM_OPS(sprd_pm_ops, sprd_suspend, sprd_resume);
780
781static const struct of_device_id serial_ids[] = {
782	{.compatible = "sprd,sc9836-uart",},
783	{}
784};
785
786static struct platform_driver sprd_platform_driver = {
787	.probe		= sprd_probe,
788	.remove		= sprd_remove,
789	.driver		= {
790		.name	= "sprd_serial",
791		.of_match_table = of_match_ptr(serial_ids),
792		.pm	= &sprd_pm_ops,
793	},
794};
795
796module_platform_driver(sprd_platform_driver);
797
798MODULE_LICENSE("GPL v2");
799MODULE_DESCRIPTION("Spreadtrum SoC serial driver series");
800