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