xref: /openbmc/linux/drivers/tty/serial/sprd_serial.c (revision 83b975b5) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2012-2015 Spreadtrum Communications Inc.
4  */
5 
6 #include <linux/clk.h>
7 #include <linux/console.h>
8 #include <linux/delay.h>
9 #include <linux/dmaengine.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/dma/sprd-dma.h>
12 #include <linux/io.h>
13 #include <linux/ioport.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/serial_core.h>
19 #include <linux/serial.h>
20 #include <linux/slab.h>
21 #include <linux/tty.h>
22 #include <linux/tty_flip.h>
23 
24 /* device name */
25 #define UART_NR_MAX		8
26 #define SPRD_TTY_NAME		"ttyS"
27 #define SPRD_FIFO_SIZE		128
28 #define SPRD_DEF_RATE		26000000
29 #define SPRD_BAUD_IO_LIMIT	3000000
30 #define SPRD_TIMEOUT		256000
31 
32 /* the offset of serial registers and BITs for them */
33 /* data registers */
34 #define SPRD_TXD		0x0000
35 #define SPRD_RXD		0x0004
36 
37 /* line status register and its BITs  */
38 #define SPRD_LSR		0x0008
39 #define SPRD_LSR_OE		BIT(4)
40 #define SPRD_LSR_FE		BIT(3)
41 #define SPRD_LSR_PE		BIT(2)
42 #define SPRD_LSR_BI		BIT(7)
43 #define SPRD_LSR_TX_OVER	BIT(15)
44 
45 /* data number in TX and RX fifo */
46 #define SPRD_STS1		0x000C
47 #define SPRD_RX_FIFO_CNT_MASK	GENMASK(7, 0)
48 #define SPRD_TX_FIFO_CNT_MASK	GENMASK(15, 8)
49 
50 /* interrupt enable register and its BITs */
51 #define SPRD_IEN		0x0010
52 #define SPRD_IEN_RX_FULL	BIT(0)
53 #define SPRD_IEN_TX_EMPTY	BIT(1)
54 #define SPRD_IEN_BREAK_DETECT	BIT(7)
55 #define SPRD_IEN_TIMEOUT	BIT(13)
56 
57 /* interrupt clear register */
58 #define SPRD_ICLR		0x0014
59 #define SPRD_ICLR_TIMEOUT	BIT(13)
60 
61 /* line control register */
62 #define SPRD_LCR		0x0018
63 #define SPRD_LCR_STOP_1BIT	0x10
64 #define SPRD_LCR_STOP_2BIT	0x30
65 #define SPRD_LCR_DATA_LEN	(BIT(2) | BIT(3))
66 #define SPRD_LCR_DATA_LEN5	0x0
67 #define SPRD_LCR_DATA_LEN6	0x4
68 #define SPRD_LCR_DATA_LEN7	0x8
69 #define SPRD_LCR_DATA_LEN8	0xc
70 #define SPRD_LCR_PARITY		(BIT(0) | BIT(1))
71 #define SPRD_LCR_PARITY_EN	0x2
72 #define SPRD_LCR_EVEN_PAR	0x0
73 #define SPRD_LCR_ODD_PAR	0x1
74 
75 /* control register 1 */
76 #define SPRD_CTL1		0x001C
77 #define SPRD_DMA_EN		BIT(15)
78 #define SPRD_LOOPBACK_EN	BIT(14)
79 #define RX_HW_FLOW_CTL_THLD	BIT(6)
80 #define RX_HW_FLOW_CTL_EN	BIT(7)
81 #define TX_HW_FLOW_CTL_EN	BIT(8)
82 #define RX_TOUT_THLD_DEF	0x3E00
83 #define RX_HFC_THLD_DEF		0x40
84 
85 /* fifo threshold register */
86 #define SPRD_CTL2		0x0020
87 #define THLD_TX_EMPTY		0x40
88 #define THLD_TX_EMPTY_SHIFT	8
89 #define THLD_RX_FULL		0x40
90 #define THLD_RX_FULL_MASK	GENMASK(6, 0)
91 
92 /* config baud rate register */
93 #define SPRD_CLKD0		0x0024
94 #define SPRD_CLKD0_MASK		GENMASK(15, 0)
95 #define SPRD_CLKD1		0x0028
96 #define SPRD_CLKD1_MASK		GENMASK(20, 16)
97 #define SPRD_CLKD1_SHIFT	16
98 
99 /* interrupt mask status register */
100 #define SPRD_IMSR		0x002C
101 #define SPRD_IMSR_RX_FIFO_FULL	BIT(0)
102 #define SPRD_IMSR_TX_FIFO_EMPTY	BIT(1)
103 #define SPRD_IMSR_BREAK_DETECT	BIT(7)
104 #define SPRD_IMSR_TIMEOUT	BIT(13)
105 #define SPRD_DEFAULT_SOURCE_CLK	26000000
106 
107 #define SPRD_RX_DMA_STEP	1
108 #define SPRD_RX_FIFO_FULL	1
109 #define SPRD_TX_FIFO_FULL	0x20
110 #define SPRD_UART_RX_SIZE	(UART_XMIT_SIZE / 4)
111 
112 struct sprd_uart_dma {
113 	struct dma_chan *chn;
114 	unsigned char *virt;
115 	dma_addr_t phys_addr;
116 	dma_cookie_t cookie;
117 	u32 trans_len;
118 	bool enable;
119 };
120 
121 struct sprd_uart_port {
122 	struct uart_port port;
123 	char name[16];
124 	struct clk *clk;
125 	struct sprd_uart_dma tx_dma;
126 	struct sprd_uart_dma rx_dma;
127 	dma_addr_t pos;
128 	unsigned char *rx_buf_tail;
129 };
130 
131 static struct sprd_uart_port *sprd_port[UART_NR_MAX];
132 static int sprd_ports_num;
133 
134 static int sprd_start_dma_rx(struct uart_port *port);
135 static int sprd_tx_dma_config(struct uart_port *port);
136 
137 static inline unsigned int serial_in(struct uart_port *port,
138 				     unsigned int offset)
139 {
140 	return readl_relaxed(port->membase + offset);
141 }
142 
143 static inline void serial_out(struct uart_port *port, unsigned int offset,
144 			      int value)
145 {
146 	writel_relaxed(value, port->membase + offset);
147 }
148 
149 static unsigned int sprd_tx_empty(struct uart_port *port)
150 {
151 	if (serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
152 		return 0;
153 	else
154 		return TIOCSER_TEMT;
155 }
156 
157 static unsigned int sprd_get_mctrl(struct uart_port *port)
158 {
159 	return TIOCM_DSR | TIOCM_CTS;
160 }
161 
162 static void sprd_set_mctrl(struct uart_port *port, unsigned int mctrl)
163 {
164 	u32 val = serial_in(port, SPRD_CTL1);
165 
166 	if (mctrl & TIOCM_LOOP)
167 		val |= SPRD_LOOPBACK_EN;
168 	else
169 		val &= ~SPRD_LOOPBACK_EN;
170 
171 	serial_out(port, SPRD_CTL1, val);
172 }
173 
174 static void sprd_stop_rx(struct uart_port *port)
175 {
176 	struct sprd_uart_port *sp =
177 		container_of(port, struct sprd_uart_port, port);
178 	unsigned int ien, iclr;
179 
180 	if (sp->rx_dma.enable)
181 		dmaengine_terminate_all(sp->rx_dma.chn);
182 
183 	iclr = serial_in(port, SPRD_ICLR);
184 	ien = serial_in(port, SPRD_IEN);
185 
186 	ien &= ~(SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT);
187 	iclr |= SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT;
188 
189 	serial_out(port, SPRD_IEN, ien);
190 	serial_out(port, SPRD_ICLR, iclr);
191 }
192 
193 static void sprd_uart_dma_enable(struct uart_port *port, bool enable)
194 {
195 	u32 val = serial_in(port, SPRD_CTL1);
196 
197 	if (enable)
198 		val |= SPRD_DMA_EN;
199 	else
200 		val &= ~SPRD_DMA_EN;
201 
202 	serial_out(port, SPRD_CTL1, val);
203 }
204 
205 static void sprd_stop_tx_dma(struct uart_port *port)
206 {
207 	struct sprd_uart_port *sp =
208 		container_of(port, struct sprd_uart_port, port);
209 	struct circ_buf *xmit = &port->state->xmit;
210 	struct dma_tx_state state;
211 	u32 trans_len;
212 
213 	dmaengine_pause(sp->tx_dma.chn);
214 
215 	dmaengine_tx_status(sp->tx_dma.chn, sp->tx_dma.cookie, &state);
216 	if (state.residue) {
217 		trans_len = state.residue - sp->tx_dma.phys_addr;
218 		xmit->tail = (xmit->tail + trans_len) & (UART_XMIT_SIZE - 1);
219 		port->icount.tx += trans_len;
220 		dma_unmap_single(port->dev, sp->tx_dma.phys_addr,
221 				 sp->tx_dma.trans_len, DMA_TO_DEVICE);
222 	}
223 
224 	dmaengine_terminate_all(sp->tx_dma.chn);
225 	sp->tx_dma.trans_len = 0;
226 }
227 
228 static int sprd_tx_buf_remap(struct uart_port *port)
229 {
230 	struct sprd_uart_port *sp =
231 		container_of(port, struct sprd_uart_port, port);
232 	struct circ_buf *xmit = &port->state->xmit;
233 
234 	sp->tx_dma.trans_len =
235 		CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
236 
237 	sp->tx_dma.phys_addr = dma_map_single(port->dev,
238 					      (void *)&(xmit->buf[xmit->tail]),
239 					      sp->tx_dma.trans_len,
240 					      DMA_TO_DEVICE);
241 	return dma_mapping_error(port->dev, sp->tx_dma.phys_addr);
242 }
243 
244 static void sprd_complete_tx_dma(void *data)
245 {
246 	struct uart_port *port = (struct uart_port *)data;
247 	struct sprd_uart_port *sp =
248 		container_of(port, struct sprd_uart_port, port);
249 	struct circ_buf *xmit = &port->state->xmit;
250 	unsigned long flags;
251 
252 	spin_lock_irqsave(&port->lock, flags);
253 	dma_unmap_single(port->dev, sp->tx_dma.phys_addr,
254 			 sp->tx_dma.trans_len, DMA_TO_DEVICE);
255 
256 	xmit->tail = (xmit->tail + sp->tx_dma.trans_len) & (UART_XMIT_SIZE - 1);
257 	port->icount.tx += sp->tx_dma.trans_len;
258 
259 	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
260 		uart_write_wakeup(port);
261 
262 	if (uart_circ_empty(xmit) || sprd_tx_buf_remap(port) ||
263 	    sprd_tx_dma_config(port))
264 		sp->tx_dma.trans_len = 0;
265 
266 	spin_unlock_irqrestore(&port->lock, flags);
267 }
268 
269 static int sprd_uart_dma_submit(struct uart_port *port,
270 				struct sprd_uart_dma *ud, u32 trans_len,
271 				enum dma_transfer_direction direction,
272 				dma_async_tx_callback callback)
273 {
274 	struct dma_async_tx_descriptor *dma_des;
275 	unsigned long flags;
276 
277 	flags = SPRD_DMA_FLAGS(SPRD_DMA_CHN_MODE_NONE,
278 			       SPRD_DMA_NO_TRG,
279 			       SPRD_DMA_FRAG_REQ,
280 			       SPRD_DMA_TRANS_INT);
281 
282 	dma_des = dmaengine_prep_slave_single(ud->chn, ud->phys_addr, trans_len,
283 					      direction, flags);
284 	if (!dma_des)
285 		return -ENODEV;
286 
287 	dma_des->callback = callback;
288 	dma_des->callback_param = port;
289 
290 	ud->cookie = dmaengine_submit(dma_des);
291 	if (dma_submit_error(ud->cookie))
292 		return dma_submit_error(ud->cookie);
293 
294 	dma_async_issue_pending(ud->chn);
295 
296 	return 0;
297 }
298 
299 static int sprd_tx_dma_config(struct uart_port *port)
300 {
301 	struct sprd_uart_port *sp =
302 		container_of(port, struct sprd_uart_port, port);
303 	u32 burst = sp->tx_dma.trans_len > SPRD_TX_FIFO_FULL ?
304 		SPRD_TX_FIFO_FULL : sp->tx_dma.trans_len;
305 	int ret;
306 	struct dma_slave_config cfg = {
307 		.dst_addr = port->mapbase + SPRD_TXD,
308 		.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
309 		.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
310 		.src_maxburst = burst,
311 	};
312 
313 	ret = dmaengine_slave_config(sp->tx_dma.chn, &cfg);
314 	if (ret < 0)
315 		return ret;
316 
317 	return sprd_uart_dma_submit(port, &sp->tx_dma, sp->tx_dma.trans_len,
318 				    DMA_MEM_TO_DEV, sprd_complete_tx_dma);
319 }
320 
321 static void sprd_start_tx_dma(struct uart_port *port)
322 {
323 	struct sprd_uart_port *sp =
324 		container_of(port, struct sprd_uart_port, port);
325 	struct circ_buf *xmit = &port->state->xmit;
326 
327 	if (port->x_char) {
328 		serial_out(port, SPRD_TXD, port->x_char);
329 		port->icount.tx++;
330 		port->x_char = 0;
331 		return;
332 	}
333 
334 	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
335 		sprd_stop_tx_dma(port);
336 		return;
337 	}
338 
339 	if (sp->tx_dma.trans_len)
340 		return;
341 
342 	if (sprd_tx_buf_remap(port) || sprd_tx_dma_config(port))
343 		sp->tx_dma.trans_len = 0;
344 }
345 
346 static void sprd_rx_full_thld(struct uart_port *port, u32 thld)
347 {
348 	u32 val = serial_in(port, SPRD_CTL2);
349 
350 	val &= ~THLD_RX_FULL_MASK;
351 	val |= thld & THLD_RX_FULL_MASK;
352 	serial_out(port, SPRD_CTL2, val);
353 }
354 
355 static int sprd_rx_alloc_buf(struct sprd_uart_port *sp)
356 {
357 	sp->rx_dma.virt = dma_alloc_coherent(sp->port.dev, SPRD_UART_RX_SIZE,
358 					     &sp->rx_dma.phys_addr, GFP_KERNEL);
359 	if (!sp->rx_dma.virt)
360 		return -ENOMEM;
361 
362 	return 0;
363 }
364 
365 static void sprd_rx_free_buf(struct sprd_uart_port *sp)
366 {
367 	if (sp->rx_dma.virt)
368 		dma_free_coherent(sp->port.dev, SPRD_UART_RX_SIZE,
369 				  sp->rx_dma.virt, sp->rx_dma.phys_addr);
370 
371 }
372 
373 static int sprd_rx_dma_config(struct uart_port *port, u32 burst)
374 {
375 	struct sprd_uart_port *sp =
376 		container_of(port, struct sprd_uart_port, port);
377 	struct dma_slave_config cfg = {
378 		.src_addr = port->mapbase + SPRD_RXD,
379 		.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
380 		.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
381 		.src_maxburst = burst,
382 	};
383 
384 	return dmaengine_slave_config(sp->rx_dma.chn, &cfg);
385 }
386 
387 static void sprd_uart_dma_rx(struct uart_port *port)
388 {
389 	struct sprd_uart_port *sp =
390 		container_of(port, struct sprd_uart_port, port);
391 	struct tty_port *tty = &port->state->port;
392 
393 	port->icount.rx += sp->rx_dma.trans_len;
394 	tty_insert_flip_string(tty, sp->rx_buf_tail, sp->rx_dma.trans_len);
395 	tty_flip_buffer_push(tty);
396 }
397 
398 static void sprd_uart_dma_irq(struct uart_port *port)
399 {
400 	struct sprd_uart_port *sp =
401 		container_of(port, struct sprd_uart_port, port);
402 	struct dma_tx_state state;
403 	enum dma_status status;
404 
405 	status = dmaengine_tx_status(sp->rx_dma.chn,
406 				     sp->rx_dma.cookie, &state);
407 	if (status == DMA_ERROR)
408 		sprd_stop_rx(port);
409 
410 	if (!state.residue && sp->pos == sp->rx_dma.phys_addr)
411 		return;
412 
413 	if (!state.residue) {
414 		sp->rx_dma.trans_len = SPRD_UART_RX_SIZE +
415 			sp->rx_dma.phys_addr - sp->pos;
416 		sp->pos = sp->rx_dma.phys_addr;
417 	} else {
418 		sp->rx_dma.trans_len = state.residue - sp->pos;
419 		sp->pos = state.residue;
420 	}
421 
422 	sprd_uart_dma_rx(port);
423 	sp->rx_buf_tail += sp->rx_dma.trans_len;
424 }
425 
426 static void sprd_complete_rx_dma(void *data)
427 {
428 	struct uart_port *port = (struct uart_port *)data;
429 	struct sprd_uart_port *sp =
430 		container_of(port, struct sprd_uart_port, port);
431 	struct dma_tx_state state;
432 	enum dma_status status;
433 	unsigned long flags;
434 
435 	spin_lock_irqsave(&port->lock, flags);
436 
437 	status = dmaengine_tx_status(sp->rx_dma.chn,
438 				     sp->rx_dma.cookie, &state);
439 	if (status != DMA_COMPLETE) {
440 		sprd_stop_rx(port);
441 		spin_unlock_irqrestore(&port->lock, flags);
442 		return;
443 	}
444 
445 	if (sp->pos != sp->rx_dma.phys_addr) {
446 		sp->rx_dma.trans_len =  SPRD_UART_RX_SIZE +
447 			sp->rx_dma.phys_addr - sp->pos;
448 		sprd_uart_dma_rx(port);
449 		sp->rx_buf_tail += sp->rx_dma.trans_len;
450 	}
451 
452 	if (sprd_start_dma_rx(port))
453 		sprd_stop_rx(port);
454 
455 	spin_unlock_irqrestore(&port->lock, flags);
456 }
457 
458 static int sprd_start_dma_rx(struct uart_port *port)
459 {
460 	struct sprd_uart_port *sp =
461 		container_of(port, struct sprd_uart_port, port);
462 	int ret;
463 
464 	if (!sp->rx_dma.enable)
465 		return 0;
466 
467 	sp->pos = sp->rx_dma.phys_addr;
468 	sp->rx_buf_tail = sp->rx_dma.virt;
469 	sprd_rx_full_thld(port, SPRD_RX_FIFO_FULL);
470 	ret = sprd_rx_dma_config(port, SPRD_RX_DMA_STEP);
471 	if (ret)
472 		return ret;
473 
474 	return sprd_uart_dma_submit(port, &sp->rx_dma, SPRD_UART_RX_SIZE,
475 				    DMA_DEV_TO_MEM, sprd_complete_rx_dma);
476 }
477 
478 static void sprd_release_dma(struct uart_port *port)
479 {
480 	struct sprd_uart_port *sp =
481 		container_of(port, struct sprd_uart_port, port);
482 
483 	sprd_uart_dma_enable(port, false);
484 
485 	if (sp->rx_dma.enable)
486 		dma_release_channel(sp->rx_dma.chn);
487 
488 	if (sp->tx_dma.enable)
489 		dma_release_channel(sp->tx_dma.chn);
490 
491 	sp->tx_dma.enable = false;
492 	sp->rx_dma.enable = false;
493 }
494 
495 static void sprd_request_dma(struct uart_port *port)
496 {
497 	struct sprd_uart_port *sp =
498 		container_of(port, struct sprd_uart_port, port);
499 
500 	sp->tx_dma.enable = true;
501 	sp->rx_dma.enable = true;
502 
503 	sp->tx_dma.chn = dma_request_chan(port->dev, "tx");
504 	if (IS_ERR(sp->tx_dma.chn)) {
505 		dev_err(port->dev, "request TX DMA channel failed, ret = %ld\n",
506 			PTR_ERR(sp->tx_dma.chn));
507 		sp->tx_dma.enable = false;
508 	}
509 
510 	sp->rx_dma.chn = dma_request_chan(port->dev, "rx");
511 	if (IS_ERR(sp->rx_dma.chn)) {
512 		dev_err(port->dev, "request RX DMA channel failed, ret = %ld\n",
513 			PTR_ERR(sp->rx_dma.chn));
514 		sp->rx_dma.enable = false;
515 	}
516 }
517 
518 static void sprd_stop_tx(struct uart_port *port)
519 {
520 	struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
521 						 port);
522 	unsigned int ien, iclr;
523 
524 	if (sp->tx_dma.enable) {
525 		sprd_stop_tx_dma(port);
526 		return;
527 	}
528 
529 	iclr = serial_in(port, SPRD_ICLR);
530 	ien = serial_in(port, SPRD_IEN);
531 
532 	iclr |= SPRD_IEN_TX_EMPTY;
533 	ien &= ~SPRD_IEN_TX_EMPTY;
534 
535 	serial_out(port, SPRD_IEN, ien);
536 	serial_out(port, SPRD_ICLR, iclr);
537 }
538 
539 static void sprd_start_tx(struct uart_port *port)
540 {
541 	struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
542 						 port);
543 	unsigned int ien;
544 
545 	if (sp->tx_dma.enable) {
546 		sprd_start_tx_dma(port);
547 		return;
548 	}
549 
550 	ien = serial_in(port, SPRD_IEN);
551 	if (!(ien & SPRD_IEN_TX_EMPTY)) {
552 		ien |= SPRD_IEN_TX_EMPTY;
553 		serial_out(port, SPRD_IEN, ien);
554 	}
555 }
556 
557 /* The Sprd serial does not support this function. */
558 static void sprd_break_ctl(struct uart_port *port, int break_state)
559 {
560 	/* nothing to do */
561 }
562 
563 static int handle_lsr_errors(struct uart_port *port,
564 			     unsigned int *flag,
565 			     unsigned int *lsr)
566 {
567 	int ret = 0;
568 
569 	/* statistics */
570 	if (*lsr & SPRD_LSR_BI) {
571 		*lsr &= ~(SPRD_LSR_FE | SPRD_LSR_PE);
572 		port->icount.brk++;
573 		ret = uart_handle_break(port);
574 		if (ret)
575 			return ret;
576 	} else if (*lsr & SPRD_LSR_PE)
577 		port->icount.parity++;
578 	else if (*lsr & SPRD_LSR_FE)
579 		port->icount.frame++;
580 	if (*lsr & SPRD_LSR_OE)
581 		port->icount.overrun++;
582 
583 	/* mask off conditions which should be ignored */
584 	*lsr &= port->read_status_mask;
585 	if (*lsr & SPRD_LSR_BI)
586 		*flag = TTY_BREAK;
587 	else if (*lsr & SPRD_LSR_PE)
588 		*flag = TTY_PARITY;
589 	else if (*lsr & SPRD_LSR_FE)
590 		*flag = TTY_FRAME;
591 
592 	return ret;
593 }
594 
595 static inline void sprd_rx(struct uart_port *port)
596 {
597 	struct sprd_uart_port *sp = container_of(port, struct sprd_uart_port,
598 						 port);
599 	struct tty_port *tty = &port->state->port;
600 	unsigned int ch, flag, lsr, max_count = SPRD_TIMEOUT;
601 
602 	if (sp->rx_dma.enable) {
603 		sprd_uart_dma_irq(port);
604 		return;
605 	}
606 
607 	while ((serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK) &&
608 	       max_count--) {
609 		lsr = serial_in(port, SPRD_LSR);
610 		ch = serial_in(port, SPRD_RXD);
611 		flag = TTY_NORMAL;
612 		port->icount.rx++;
613 
614 		if (lsr & (SPRD_LSR_BI | SPRD_LSR_PE |
615 			   SPRD_LSR_FE | SPRD_LSR_OE))
616 			if (handle_lsr_errors(port, &flag, &lsr))
617 				continue;
618 		if (uart_handle_sysrq_char(port, ch))
619 			continue;
620 
621 		uart_insert_char(port, lsr, SPRD_LSR_OE, ch, flag);
622 	}
623 
624 	tty_flip_buffer_push(tty);
625 }
626 
627 static inline void sprd_tx(struct uart_port *port)
628 {
629 	struct circ_buf *xmit = &port->state->xmit;
630 	int count;
631 
632 	if (port->x_char) {
633 		serial_out(port, SPRD_TXD, port->x_char);
634 		port->icount.tx++;
635 		port->x_char = 0;
636 		return;
637 	}
638 
639 	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
640 		sprd_stop_tx(port);
641 		return;
642 	}
643 
644 	count = THLD_TX_EMPTY;
645 	do {
646 		serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]);
647 		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
648 		port->icount.tx++;
649 		if (uart_circ_empty(xmit))
650 			break;
651 	} while (--count > 0);
652 
653 	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
654 		uart_write_wakeup(port);
655 
656 	if (uart_circ_empty(xmit))
657 		sprd_stop_tx(port);
658 }
659 
660 /* this handles the interrupt from one port */
661 static irqreturn_t sprd_handle_irq(int irq, void *dev_id)
662 {
663 	struct uart_port *port = dev_id;
664 	unsigned int ims;
665 
666 	spin_lock(&port->lock);
667 
668 	ims = serial_in(port, SPRD_IMSR);
669 
670 	if (!ims) {
671 		spin_unlock(&port->lock);
672 		return IRQ_NONE;
673 	}
674 
675 	if (ims & SPRD_IMSR_TIMEOUT)
676 		serial_out(port, SPRD_ICLR, SPRD_ICLR_TIMEOUT);
677 
678 	if (ims & SPRD_IMSR_BREAK_DETECT)
679 		serial_out(port, SPRD_ICLR, SPRD_IMSR_BREAK_DETECT);
680 
681 	if (ims & (SPRD_IMSR_RX_FIFO_FULL | SPRD_IMSR_BREAK_DETECT |
682 		   SPRD_IMSR_TIMEOUT))
683 		sprd_rx(port);
684 
685 	if (ims & SPRD_IMSR_TX_FIFO_EMPTY)
686 		sprd_tx(port);
687 
688 	spin_unlock(&port->lock);
689 
690 	return IRQ_HANDLED;
691 }
692 
693 static void sprd_uart_dma_startup(struct uart_port *port,
694 				  struct sprd_uart_port *sp)
695 {
696 	int ret;
697 
698 	sprd_request_dma(port);
699 	if (!(sp->rx_dma.enable || sp->tx_dma.enable))
700 		return;
701 
702 	ret = sprd_start_dma_rx(port);
703 	if (ret) {
704 		sp->rx_dma.enable = false;
705 		dma_release_channel(sp->rx_dma.chn);
706 		dev_warn(port->dev, "fail to start RX dma mode\n");
707 	}
708 
709 	sprd_uart_dma_enable(port, true);
710 }
711 
712 static int sprd_startup(struct uart_port *port)
713 {
714 	int ret = 0;
715 	unsigned int ien, fc;
716 	unsigned int timeout;
717 	struct sprd_uart_port *sp;
718 	unsigned long flags;
719 
720 	serial_out(port, SPRD_CTL2,
721 		   THLD_TX_EMPTY << THLD_TX_EMPTY_SHIFT | THLD_RX_FULL);
722 
723 	/* clear rx fifo */
724 	timeout = SPRD_TIMEOUT;
725 	while (timeout-- && serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK)
726 		serial_in(port, SPRD_RXD);
727 
728 	/* clear tx fifo */
729 	timeout = SPRD_TIMEOUT;
730 	while (timeout-- && serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
731 		cpu_relax();
732 
733 	/* clear interrupt */
734 	serial_out(port, SPRD_IEN, 0);
735 	serial_out(port, SPRD_ICLR, ~0);
736 
737 	/* allocate irq */
738 	sp = container_of(port, struct sprd_uart_port, port);
739 	snprintf(sp->name, sizeof(sp->name), "sprd_serial%d", port->line);
740 
741 	sprd_uart_dma_startup(port, sp);
742 
743 	ret = devm_request_irq(port->dev, port->irq, sprd_handle_irq,
744 			       IRQF_SHARED, sp->name, port);
745 	if (ret) {
746 		dev_err(port->dev, "fail to request serial irq %d, ret=%d\n",
747 			port->irq, ret);
748 		return ret;
749 	}
750 	fc = serial_in(port, SPRD_CTL1);
751 	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
752 	serial_out(port, SPRD_CTL1, fc);
753 
754 	/* enable interrupt */
755 	spin_lock_irqsave(&port->lock, flags);
756 	ien = serial_in(port, SPRD_IEN);
757 	ien |= SPRD_IEN_BREAK_DETECT | SPRD_IEN_TIMEOUT;
758 	if (!sp->rx_dma.enable)
759 		ien |= SPRD_IEN_RX_FULL;
760 	serial_out(port, SPRD_IEN, ien);
761 	spin_unlock_irqrestore(&port->lock, flags);
762 
763 	return 0;
764 }
765 
766 static void sprd_shutdown(struct uart_port *port)
767 {
768 	sprd_release_dma(port);
769 	serial_out(port, SPRD_IEN, 0);
770 	serial_out(port, SPRD_ICLR, ~0);
771 	devm_free_irq(port->dev, port->irq, port);
772 }
773 
774 static void sprd_set_termios(struct uart_port *port, struct ktermios *termios,
775 		             const struct ktermios *old)
776 {
777 	unsigned int baud, quot;
778 	unsigned int lcr = 0, fc;
779 	unsigned long flags;
780 
781 	/* ask the core to calculate the divisor for us */
782 	baud = uart_get_baud_rate(port, termios, old, 0, SPRD_BAUD_IO_LIMIT);
783 
784 	quot = port->uartclk / baud;
785 
786 	/* set data length */
787 	switch (termios->c_cflag & CSIZE) {
788 	case CS5:
789 		lcr |= SPRD_LCR_DATA_LEN5;
790 		break;
791 	case CS6:
792 		lcr |= SPRD_LCR_DATA_LEN6;
793 		break;
794 	case CS7:
795 		lcr |= SPRD_LCR_DATA_LEN7;
796 		break;
797 	case CS8:
798 	default:
799 		lcr |= SPRD_LCR_DATA_LEN8;
800 		break;
801 	}
802 
803 	/* calculate stop bits */
804 	lcr &= ~(SPRD_LCR_STOP_1BIT | SPRD_LCR_STOP_2BIT);
805 	if (termios->c_cflag & CSTOPB)
806 		lcr |= SPRD_LCR_STOP_2BIT;
807 	else
808 		lcr |= SPRD_LCR_STOP_1BIT;
809 
810 	/* calculate parity */
811 	lcr &= ~SPRD_LCR_PARITY;
812 	termios->c_cflag &= ~CMSPAR;	/* no support mark/space */
813 	if (termios->c_cflag & PARENB) {
814 		lcr |= SPRD_LCR_PARITY_EN;
815 		if (termios->c_cflag & PARODD)
816 			lcr |= SPRD_LCR_ODD_PAR;
817 		else
818 			lcr |= SPRD_LCR_EVEN_PAR;
819 	}
820 
821 	spin_lock_irqsave(&port->lock, flags);
822 
823 	/* update the per-port timeout */
824 	uart_update_timeout(port, termios->c_cflag, baud);
825 
826 	port->read_status_mask = SPRD_LSR_OE;
827 	if (termios->c_iflag & INPCK)
828 		port->read_status_mask |= SPRD_LSR_FE | SPRD_LSR_PE;
829 	if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
830 		port->read_status_mask |= SPRD_LSR_BI;
831 
832 	/* characters to ignore */
833 	port->ignore_status_mask = 0;
834 	if (termios->c_iflag & IGNPAR)
835 		port->ignore_status_mask |= SPRD_LSR_PE | SPRD_LSR_FE;
836 	if (termios->c_iflag & IGNBRK) {
837 		port->ignore_status_mask |= SPRD_LSR_BI;
838 		/*
839 		 * If we're ignoring parity and break indicators,
840 		 * ignore overruns too (for real raw support).
841 		 */
842 		if (termios->c_iflag & IGNPAR)
843 			port->ignore_status_mask |= SPRD_LSR_OE;
844 	}
845 
846 	/* flow control */
847 	fc = serial_in(port, SPRD_CTL1);
848 	fc &= ~(RX_HW_FLOW_CTL_THLD | RX_HW_FLOW_CTL_EN | TX_HW_FLOW_CTL_EN);
849 	if (termios->c_cflag & CRTSCTS) {
850 		fc |= RX_HW_FLOW_CTL_THLD;
851 		fc |= RX_HW_FLOW_CTL_EN;
852 		fc |= TX_HW_FLOW_CTL_EN;
853 	}
854 
855 	/* clock divider bit0~bit15 */
856 	serial_out(port, SPRD_CLKD0, quot & SPRD_CLKD0_MASK);
857 
858 	/* clock divider bit16~bit20 */
859 	serial_out(port, SPRD_CLKD1,
860 		   (quot & SPRD_CLKD1_MASK) >> SPRD_CLKD1_SHIFT);
861 	serial_out(port, SPRD_LCR, lcr);
862 	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
863 	serial_out(port, SPRD_CTL1, fc);
864 
865 	spin_unlock_irqrestore(&port->lock, flags);
866 
867 	/* Don't rewrite B0 */
868 	if (tty_termios_baud_rate(termios))
869 		tty_termios_encode_baud_rate(termios, baud, baud);
870 }
871 
872 static const char *sprd_type(struct uart_port *port)
873 {
874 	return "SPX";
875 }
876 
877 static void sprd_release_port(struct uart_port *port)
878 {
879 	/* nothing to do */
880 }
881 
882 static int sprd_request_port(struct uart_port *port)
883 {
884 	return 0;
885 }
886 
887 static void sprd_config_port(struct uart_port *port, int flags)
888 {
889 	if (flags & UART_CONFIG_TYPE)
890 		port->type = PORT_SPRD;
891 }
892 
893 static int sprd_verify_port(struct uart_port *port, struct serial_struct *ser)
894 {
895 	if (ser->type != PORT_SPRD)
896 		return -EINVAL;
897 	if (port->irq != ser->irq)
898 		return -EINVAL;
899 	if (port->iotype != ser->io_type)
900 		return -EINVAL;
901 	return 0;
902 }
903 
904 static void sprd_pm(struct uart_port *port, unsigned int state,
905 		unsigned int oldstate)
906 {
907 	struct sprd_uart_port *sup =
908 		container_of(port, struct sprd_uart_port, port);
909 
910 	switch (state) {
911 	case UART_PM_STATE_ON:
912 		clk_prepare_enable(sup->clk);
913 		break;
914 	case UART_PM_STATE_OFF:
915 		clk_disable_unprepare(sup->clk);
916 		break;
917 	}
918 }
919 
920 #ifdef CONFIG_CONSOLE_POLL
921 static int sprd_poll_init(struct uart_port *port)
922 {
923 	if (port->state->pm_state != UART_PM_STATE_ON) {
924 		sprd_pm(port, UART_PM_STATE_ON, 0);
925 		port->state->pm_state = UART_PM_STATE_ON;
926 	}
927 
928 	return 0;
929 }
930 
931 static int sprd_poll_get_char(struct uart_port *port)
932 {
933 	while (!(serial_in(port, SPRD_STS1) & SPRD_RX_FIFO_CNT_MASK))
934 		cpu_relax();
935 
936 	return serial_in(port, SPRD_RXD);
937 }
938 
939 static void sprd_poll_put_char(struct uart_port *port, unsigned char ch)
940 {
941 	while (serial_in(port, SPRD_STS1) & SPRD_TX_FIFO_CNT_MASK)
942 		cpu_relax();
943 
944 	serial_out(port, SPRD_TXD, ch);
945 }
946 #endif
947 
948 static const struct uart_ops serial_sprd_ops = {
949 	.tx_empty = sprd_tx_empty,
950 	.get_mctrl = sprd_get_mctrl,
951 	.set_mctrl = sprd_set_mctrl,
952 	.stop_tx = sprd_stop_tx,
953 	.start_tx = sprd_start_tx,
954 	.stop_rx = sprd_stop_rx,
955 	.break_ctl = sprd_break_ctl,
956 	.startup = sprd_startup,
957 	.shutdown = sprd_shutdown,
958 	.set_termios = sprd_set_termios,
959 	.type = sprd_type,
960 	.release_port = sprd_release_port,
961 	.request_port = sprd_request_port,
962 	.config_port = sprd_config_port,
963 	.verify_port = sprd_verify_port,
964 	.pm = sprd_pm,
965 #ifdef CONFIG_CONSOLE_POLL
966 	.poll_init	= sprd_poll_init,
967 	.poll_get_char	= sprd_poll_get_char,
968 	.poll_put_char	= sprd_poll_put_char,
969 #endif
970 };
971 
972 #ifdef CONFIG_SERIAL_SPRD_CONSOLE
973 static void wait_for_xmitr(struct uart_port *port)
974 {
975 	unsigned int status, tmout = 10000;
976 
977 	/* wait up to 10ms for the character(s) to be sent */
978 	do {
979 		status = serial_in(port, SPRD_STS1);
980 		if (--tmout == 0)
981 			break;
982 		udelay(1);
983 	} while (status & SPRD_TX_FIFO_CNT_MASK);
984 }
985 
986 static void sprd_console_putchar(struct uart_port *port, unsigned char ch)
987 {
988 	wait_for_xmitr(port);
989 	serial_out(port, SPRD_TXD, ch);
990 }
991 
992 static void sprd_console_write(struct console *co, const char *s,
993 			       unsigned int count)
994 {
995 	struct uart_port *port = &sprd_port[co->index]->port;
996 	int locked = 1;
997 	unsigned long flags;
998 
999 	if (port->sysrq)
1000 		locked = 0;
1001 	else if (oops_in_progress)
1002 		locked = spin_trylock_irqsave(&port->lock, flags);
1003 	else
1004 		spin_lock_irqsave(&port->lock, flags);
1005 
1006 	uart_console_write(port, s, count, sprd_console_putchar);
1007 
1008 	/* wait for transmitter to become empty */
1009 	wait_for_xmitr(port);
1010 
1011 	if (locked)
1012 		spin_unlock_irqrestore(&port->lock, flags);
1013 }
1014 
1015 static int sprd_console_setup(struct console *co, char *options)
1016 {
1017 	struct sprd_uart_port *sprd_uart_port;
1018 	int baud = 115200;
1019 	int bits = 8;
1020 	int parity = 'n';
1021 	int flow = 'n';
1022 
1023 	if (co->index >= UART_NR_MAX || co->index < 0)
1024 		co->index = 0;
1025 
1026 	sprd_uart_port = sprd_port[co->index];
1027 	if (!sprd_uart_port || !sprd_uart_port->port.membase) {
1028 		pr_info("serial port %d not yet initialized\n", co->index);
1029 		return -ENODEV;
1030 	}
1031 
1032 	if (options)
1033 		uart_parse_options(options, &baud, &parity, &bits, &flow);
1034 
1035 	return uart_set_options(&sprd_uart_port->port, co, baud,
1036 				parity, bits, flow);
1037 }
1038 
1039 static struct uart_driver sprd_uart_driver;
1040 static struct console sprd_console = {
1041 	.name = SPRD_TTY_NAME,
1042 	.write = sprd_console_write,
1043 	.device = uart_console_device,
1044 	.setup = sprd_console_setup,
1045 	.flags = CON_PRINTBUFFER,
1046 	.index = -1,
1047 	.data = &sprd_uart_driver,
1048 };
1049 
1050 static int __init sprd_serial_console_init(void)
1051 {
1052 	register_console(&sprd_console);
1053 	return 0;
1054 }
1055 console_initcall(sprd_serial_console_init);
1056 
1057 #define SPRD_CONSOLE	(&sprd_console)
1058 
1059 /* Support for earlycon */
1060 static void sprd_putc(struct uart_port *port, unsigned char c)
1061 {
1062 	unsigned int timeout = SPRD_TIMEOUT;
1063 
1064 	while (timeout-- &&
1065 	       !(readl(port->membase + SPRD_LSR) & SPRD_LSR_TX_OVER))
1066 		cpu_relax();
1067 
1068 	writeb(c, port->membase + SPRD_TXD);
1069 }
1070 
1071 static void sprd_early_write(struct console *con, const char *s, unsigned int n)
1072 {
1073 	struct earlycon_device *dev = con->data;
1074 
1075 	uart_console_write(&dev->port, s, n, sprd_putc);
1076 }
1077 
1078 static int __init sprd_early_console_setup(struct earlycon_device *device,
1079 					   const char *opt)
1080 {
1081 	if (!device->port.membase)
1082 		return -ENODEV;
1083 
1084 	device->con->write = sprd_early_write;
1085 	return 0;
1086 }
1087 OF_EARLYCON_DECLARE(sprd_serial, "sprd,sc9836-uart",
1088 		    sprd_early_console_setup);
1089 
1090 #else /* !CONFIG_SERIAL_SPRD_CONSOLE */
1091 #define SPRD_CONSOLE		NULL
1092 #endif
1093 
1094 static struct uart_driver sprd_uart_driver = {
1095 	.owner = THIS_MODULE,
1096 	.driver_name = "sprd_serial",
1097 	.dev_name = SPRD_TTY_NAME,
1098 	.major = 0,
1099 	.minor = 0,
1100 	.nr = UART_NR_MAX,
1101 	.cons = SPRD_CONSOLE,
1102 };
1103 
1104 static int sprd_remove(struct platform_device *dev)
1105 {
1106 	struct sprd_uart_port *sup = platform_get_drvdata(dev);
1107 
1108 	if (sup) {
1109 		uart_remove_one_port(&sprd_uart_driver, &sup->port);
1110 		sprd_port[sup->port.line] = NULL;
1111 		sprd_rx_free_buf(sup);
1112 		sprd_ports_num--;
1113 	}
1114 
1115 	if (!sprd_ports_num)
1116 		uart_unregister_driver(&sprd_uart_driver);
1117 
1118 	return 0;
1119 }
1120 
1121 static bool sprd_uart_is_console(struct uart_port *uport)
1122 {
1123 	struct console *cons = sprd_uart_driver.cons;
1124 
1125 	if ((cons && cons->index >= 0 && cons->index == uport->line) ||
1126 	    of_console_check(uport->dev->of_node, SPRD_TTY_NAME, uport->line))
1127 		return true;
1128 
1129 	return false;
1130 }
1131 
1132 static int sprd_clk_init(struct uart_port *uport)
1133 {
1134 	struct clk *clk_uart, *clk_parent;
1135 	struct sprd_uart_port *u = sprd_port[uport->line];
1136 
1137 	clk_uart = devm_clk_get(uport->dev, "uart");
1138 	if (IS_ERR(clk_uart)) {
1139 		dev_warn(uport->dev, "uart%d can't get uart clock\n",
1140 			 uport->line);
1141 		clk_uart = NULL;
1142 	}
1143 
1144 	clk_parent = devm_clk_get(uport->dev, "source");
1145 	if (IS_ERR(clk_parent)) {
1146 		dev_warn(uport->dev, "uart%d can't get source clock\n",
1147 			 uport->line);
1148 		clk_parent = NULL;
1149 	}
1150 
1151 	if (!clk_uart || clk_set_parent(clk_uart, clk_parent))
1152 		uport->uartclk = SPRD_DEFAULT_SOURCE_CLK;
1153 	else
1154 		uport->uartclk = clk_get_rate(clk_uart);
1155 
1156 	u->clk = devm_clk_get(uport->dev, "enable");
1157 	if (IS_ERR(u->clk)) {
1158 		if (PTR_ERR(u->clk) == -EPROBE_DEFER)
1159 			return -EPROBE_DEFER;
1160 
1161 		dev_warn(uport->dev, "uart%d can't get enable clock\n",
1162 			uport->line);
1163 
1164 		/* To keep console alive even if the error occurred */
1165 		if (!sprd_uart_is_console(uport))
1166 			return PTR_ERR(u->clk);
1167 
1168 		u->clk = NULL;
1169 	}
1170 
1171 	return 0;
1172 }
1173 
1174 static int sprd_probe(struct platform_device *pdev)
1175 {
1176 	struct resource *res;
1177 	struct uart_port *up;
1178 	int irq;
1179 	int index;
1180 	int ret;
1181 
1182 	index = of_alias_get_id(pdev->dev.of_node, "serial");
1183 	if (index < 0 || index >= ARRAY_SIZE(sprd_port)) {
1184 		dev_err(&pdev->dev, "got a wrong serial alias id %d\n", index);
1185 		return -EINVAL;
1186 	}
1187 
1188 	sprd_port[index] = devm_kzalloc(&pdev->dev, sizeof(*sprd_port[index]),
1189 					GFP_KERNEL);
1190 	if (!sprd_port[index])
1191 		return -ENOMEM;
1192 
1193 	up = &sprd_port[index]->port;
1194 	up->dev = &pdev->dev;
1195 	up->line = index;
1196 	up->type = PORT_SPRD;
1197 	up->iotype = UPIO_MEM;
1198 	up->uartclk = SPRD_DEF_RATE;
1199 	up->fifosize = SPRD_FIFO_SIZE;
1200 	up->ops = &serial_sprd_ops;
1201 	up->flags = UPF_BOOT_AUTOCONF;
1202 	up->has_sysrq = IS_ENABLED(CONFIG_SERIAL_SPRD_CONSOLE);
1203 
1204 	ret = sprd_clk_init(up);
1205 	if (ret)
1206 		return ret;
1207 
1208 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1209 	up->membase = devm_ioremap_resource(&pdev->dev, res);
1210 	if (IS_ERR(up->membase))
1211 		return PTR_ERR(up->membase);
1212 
1213 	up->mapbase = res->start;
1214 
1215 	irq = platform_get_irq(pdev, 0);
1216 	if (irq < 0)
1217 		return irq;
1218 	up->irq = irq;
1219 
1220 	/*
1221 	 * Allocate one dma buffer to prepare for receive transfer, in case
1222 	 * memory allocation failure at runtime.
1223 	 */
1224 	ret = sprd_rx_alloc_buf(sprd_port[index]);
1225 	if (ret)
1226 		return ret;
1227 
1228 	if (!sprd_ports_num) {
1229 		ret = uart_register_driver(&sprd_uart_driver);
1230 		if (ret < 0) {
1231 			pr_err("Failed to register SPRD-UART driver\n");
1232 			return ret;
1233 		}
1234 	}
1235 	sprd_ports_num++;
1236 
1237 	ret = uart_add_one_port(&sprd_uart_driver, up);
1238 	if (ret)
1239 		sprd_remove(pdev);
1240 
1241 	platform_set_drvdata(pdev, up);
1242 
1243 	return ret;
1244 }
1245 
1246 #ifdef CONFIG_PM_SLEEP
1247 static int sprd_suspend(struct device *dev)
1248 {
1249 	struct sprd_uart_port *sup = dev_get_drvdata(dev);
1250 
1251 	uart_suspend_port(&sprd_uart_driver, &sup->port);
1252 
1253 	return 0;
1254 }
1255 
1256 static int sprd_resume(struct device *dev)
1257 {
1258 	struct sprd_uart_port *sup = dev_get_drvdata(dev);
1259 
1260 	uart_resume_port(&sprd_uart_driver, &sup->port);
1261 
1262 	return 0;
1263 }
1264 #endif
1265 
1266 static SIMPLE_DEV_PM_OPS(sprd_pm_ops, sprd_suspend, sprd_resume);
1267 
1268 static const struct of_device_id serial_ids[] = {
1269 	{.compatible = "sprd,sc9836-uart",},
1270 	{}
1271 };
1272 MODULE_DEVICE_TABLE(of, serial_ids);
1273 
1274 static struct platform_driver sprd_platform_driver = {
1275 	.probe		= sprd_probe,
1276 	.remove		= sprd_remove,
1277 	.driver		= {
1278 		.name	= "sprd_serial",
1279 		.of_match_table = of_match_ptr(serial_ids),
1280 		.pm	= &sprd_pm_ops,
1281 	},
1282 };
1283 
1284 module_platform_driver(sprd_platform_driver);
1285 
1286 MODULE_LICENSE("GPL v2");
1287 MODULE_DESCRIPTION("Spreadtrum SoC serial driver series");
1288