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