projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
serial: ioc4_serial: Staticize ioc4_serial_attach_one()
[linux-2.6-block.git] / drivers / tty / serial / msm_serial.c
CommitLineData
04896a77 1/*
99edb3d1 2 * Driver for msm7k serial device and console
04896a77
RL		 3 *
4 * Copyright (C) 2007 Google, Inc.
5 * Author: Robert Love <rlove@google.com>
ec8f29e7 6 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
04896a77
RL		 7 *
8 * This software is licensed under the terms of the GNU General Public
9 * License version 2, as published by the Free Software Foundation, and
10 * may be copied, distributed, and modified under those terms.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18#if defined(CONFIG_SERIAL_MSM_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
19# define SUPPORT_SYSRQ
20#endif
21
cfdad2ab 22#include <linux/atomic.h>
04896a77
RL		 23#include <linux/hrtimer.h>
24#include <linux/module.h>
25#include <linux/io.h>
26#include <linux/ioport.h>
27#include <linux/irq.h>
28#include <linux/init.h>
29#include <linux/console.h>
30#include <linux/tty.h>
31#include <linux/tty_flip.h>
32#include <linux/serial_core.h>
33#include <linux/serial.h>
34#include <linux/clk.h>
35#include <linux/platform_device.h>
ec8f29e7 36#include <linux/delay.h>
cfdad2ab
DB		 37#include <linux/of.h>
38#include <linux/of_device.h>
04896a77
RL		 39
40#include "msm_serial.h"
41
42struct msm_port {
43 struct uart_port uart;
44 char name[16];
45 struct clk *clk;
ec8f29e7 46 struct clk *pclk;
04896a77 47 unsigned int imr;
f8fb952f 48 void __iomem *gsbi_base;
ec8f29e7
SM		 49 int is_uartdm;
50 unsigned int old_snap_state;
04896a77
RL		 51};
52
4a5662d6 53static inline void wait_for_xmitr(struct uart_port *port)
ec8f29e7 54{
4a5662d6
SB		 55 while (!(msm_read(port, UART_SR) & UART_SR_TX_EMPTY)) {
56 if (msm_read(port, UART_ISR) & UART_ISR_TX_READY)
57 break;
58 udelay(1);
59 }
60 msm_write(port, UART_CR_CMD_RESET_TX_READY, UART_CR);
ec8f29e7
SM		 61}
62
04896a77
RL		 63static void msm_stop_tx(struct uart_port *port)
64{
65 struct msm_port *msm_port = UART_TO_MSM(port);
66
67 msm_port->imr &= ~UART_IMR_TXLEV;
68 msm_write(port, msm_port->imr, UART_IMR);
69}
70
71static void msm_start_tx(struct uart_port *port)
72{
73 struct msm_port *msm_port = UART_TO_MSM(port);
74
75 msm_port->imr |= UART_IMR_TXLEV;
76 msm_write(port, msm_port->imr, UART_IMR);
77}
78
79static void msm_stop_rx(struct uart_port *port)
80{
81 struct msm_port *msm_port = UART_TO_MSM(port);
82
83 msm_port->imr &= ~(UART_IMR_RXLEV | UART_IMR_RXSTALE);
84 msm_write(port, msm_port->imr, UART_IMR);
85}
86
87static void msm_enable_ms(struct uart_port *port)
88{
89 struct msm_port *msm_port = UART_TO_MSM(port);
90
91 msm_port->imr |= UART_IMR_DELTA_CTS;
92 msm_write(port, msm_port->imr, UART_IMR);
93}
94
ec8f29e7
SM		 95static void handle_rx_dm(struct uart_port *port, unsigned int misr)
96{
92a19f9c 97 struct tty_port *tport = &port->state->port;
ec8f29e7
SM		 98 unsigned int sr;
99 int count = 0;
100 struct msm_port *msm_port = UART_TO_MSM(port);
101
102 if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
103 port->icount.overrun++;
92a19f9c 104 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
ec8f29e7
SM		 105 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
106 }
107
108 if (misr & UART_IMR_RXSTALE) {
109 count = msm_read(port, UARTDM_RX_TOTAL_SNAP) -
110 msm_port->old_snap_state;
111 msm_port->old_snap_state = 0;
112 } else {
113 count = 4 * (msm_read(port, UART_RFWR));
114 msm_port->old_snap_state += count;
115 }
116
117 /* TODO: Precise error reporting */
118
119 port->icount.rx += count;
120
121 while (count > 0) {
122 unsigned int c;
123
124 sr = msm_read(port, UART_SR);
125 if ((sr & UART_SR_RX_READY) == 0) {
126 msm_port->old_snap_state -= count;
127 break;
128 }
129 c = msm_read(port, UARTDM_RF);
130 if (sr & UART_SR_RX_BREAK) {
131 port->icount.brk++;
132 if (uart_handle_break(port))
133 continue;
134 } else if (sr & UART_SR_PAR_FRAME_ERR)
135 port->icount.frame++;
136
137 /* TODO: handle sysrq */
05c7cd39 138 tty_insert_flip_string(tport, (char *)&c,
ec8f29e7
SM		 139 (count > 4) ? 4 : count);
140 count -= 4;
141 }
142
2e124b4a 143 tty_flip_buffer_push(tport);
ec8f29e7
SM		 144 if (misr & (UART_IMR_RXSTALE))
145 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
146 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
147 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
148}
149
04896a77
RL		 150static void handle_rx(struct uart_port *port)
151{
92a19f9c 152 struct tty_port *tport = &port->state->port;
04896a77
RL		 153 unsigned int sr;
154
155 /*
156 * Handle overrun. My understanding of the hardware is that overrun
157 * is not tied to the RX buffer, so we handle the case out of band.
158 */
159 if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
160 port->icount.overrun++;
92a19f9c 161 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
04896a77
RL		 162 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
163 }
164
165 /* and now the main RX loop */
166 while ((sr = msm_read(port, UART_SR)) & UART_SR_RX_READY) {
167 unsigned int c;
168 char flag = TTY_NORMAL;
169
170 c = msm_read(port, UART_RF);
171
172 if (sr & UART_SR_RX_BREAK) {
173 port->icount.brk++;
174 if (uart_handle_break(port))
175 continue;
176 } else if (sr & UART_SR_PAR_FRAME_ERR) {
177 port->icount.frame++;
178 } else {
179 port->icount.rx++;
180 }
181
182 /* Mask conditions we're ignorning. */
183 sr &= port->read_status_mask;
184
185 if (sr & UART_SR_RX_BREAK) {
186 flag = TTY_BREAK;
187 } else if (sr & UART_SR_PAR_FRAME_ERR) {
188 flag = TTY_FRAME;
189 }
190
191 if (!uart_handle_sysrq_char(port, c))
92a19f9c 192 tty_insert_flip_char(tport, c, flag);
04896a77
RL		 193 }
194
2e124b4a 195 tty_flip_buffer_push(tport);
04896a77
RL		 196}
197
17fae28e 198static void reset_dm_count(struct uart_port *port, int count)
ec8f29e7 199{
4a5662d6 200 wait_for_xmitr(port);
17fae28e 201 msm_write(port, count, UARTDM_NCF_TX);
4a5662d6 202 msm_read(port, UARTDM_NCF_TX);
ec8f29e7
SM		 203}
204
04896a77
RL		 205static void handle_tx(struct uart_port *port)
206{
ebd2c8f6 207 struct circ_buf *xmit = &port->state->xmit;
04896a77 208 struct msm_port *msm_port = UART_TO_MSM(port);
17fae28e
SB		 209 unsigned int tx_count, num_chars;
210 unsigned int tf_pointer = 0;
211
212 tx_count = uart_circ_chars_pending(xmit);
213 tx_count = min3(tx_count, (unsigned int)UART_XMIT_SIZE - xmit->tail,
214 port->fifosize);
04896a77
RL		 215
216 if (port->x_char) {
ec8f29e7 217 if (msm_port->is_uartdm)
17fae28e 218 reset_dm_count(port, tx_count + 1);
ec8f29e7
SM		 219
220 msm_write(port, port->x_char,
221 msm_port->is_uartdm ? UARTDM_TF : UART_TF);
04896a77
RL		 222 port->icount.tx++;
223 port->x_char = 0;
17fae28e
SB		 224 } else if (tx_count && msm_port->is_uartdm) {
225 reset_dm_count(port, tx_count);
04896a77
RL		 226 }
227
17fae28e
SB		 228 while (tf_pointer < tx_count) {
229 int i;
230 char buf[4] = { 0 };
231 unsigned int *bf = (unsigned int *)&buf;
ec8f29e7 232
17fae28e 233 if (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
04896a77 234 break;
04896a77 235
ec8f29e7 236 if (msm_port->is_uartdm)
17fae28e
SB		 237 num_chars = min(tx_count - tf_pointer, sizeof(buf));
238 else
239 num_chars = 1;
04896a77 240
17fae28e
SB		 241 for (i = 0; i < num_chars; i++) {
242 buf[i] = xmit->buf[xmit->tail + i];
243 port->icount.tx++;
244 }
245
246 msm_write(port, *bf, msm_port->is_uartdm ? UARTDM_TF : UART_TF);
247 xmit->tail = (xmit->tail + num_chars) & (UART_XMIT_SIZE - 1);
248 tf_pointer += num_chars;
04896a77
RL		 249 }
250
17fae28e
SB		 251 /* disable tx interrupts if nothing more to send */
252 if (uart_circ_empty(xmit))
253 msm_stop_tx(port);
254
04896a77
RL		 255 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
256 uart_write_wakeup(port);
257}
258
259static void handle_delta_cts(struct uart_port *port)
260{
261 msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
262 port->icount.cts++;
bdc04e31 263 wake_up_interruptible(&port->state->port.delta_msr_wait);
04896a77
RL		 264}
265
266static irqreturn_t msm_irq(int irq, void *dev_id)
267{
268 struct uart_port *port = dev_id;
269 struct msm_port *msm_port = UART_TO_MSM(port);
270 unsigned int misr;
271
272 spin_lock(&port->lock);
273 misr = msm_read(port, UART_MISR);
274 msm_write(port, 0, UART_IMR); /* disable interrupt */
275
ec8f29e7
SM		 276 if (misr & (UART_IMR_RXLEV | UART_IMR_RXSTALE)) {
277 if (msm_port->is_uartdm)
278 handle_rx_dm(port, misr);
279 else
280 handle_rx(port);
281 }
04896a77
RL		 282 if (misr & UART_IMR_TXLEV)
283 handle_tx(port);
284 if (misr & UART_IMR_DELTA_CTS)
285 handle_delta_cts(port);
286
287 msm_write(port, msm_port->imr, UART_IMR); /* restore interrupt */
288 spin_unlock(&port->lock);
289
290 return IRQ_HANDLED;
291}
292
293static unsigned int msm_tx_empty(struct uart_port *port)
294{
295 return (msm_read(port, UART_SR) & UART_SR_TX_EMPTY) ? TIOCSER_TEMT : 0;
296}
297
298static unsigned int msm_get_mctrl(struct uart_port *port)
299{
300 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
301}
302
ec8f29e7
SM		 303
304static void msm_reset(struct uart_port *port)
04896a77 305{
ec8f29e7
SM		 306 /* reset everything */
307 msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
308 msm_write(port, UART_CR_CMD_RESET_TX, UART_CR);
309 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
310 msm_write(port, UART_CR_CMD_RESET_BREAK_INT, UART_CR);
311 msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
312 msm_write(port, UART_CR_CMD_SET_RFR, UART_CR);
313}
04896a77 314
f8fb952f 315static void msm_set_mctrl(struct uart_port *port, unsigned int mctrl)
ec8f29e7
SM		 316{
317 unsigned int mr;
04896a77
RL		 318 mr = msm_read(port, UART_MR1);
319
320 if (!(mctrl & TIOCM_RTS)) {
321 mr &= ~UART_MR1_RX_RDY_CTL;
322 msm_write(port, mr, UART_MR1);
323 msm_write(port, UART_CR_CMD_RESET_RFR, UART_CR);
324 } else {
325 mr |= UART_MR1_RX_RDY_CTL;
326 msm_write(port, mr, UART_MR1);
327 }
328}
329
330static void msm_break_ctl(struct uart_port *port, int break_ctl)
331{
332 if (break_ctl)
333 msm_write(port, UART_CR_CMD_START_BREAK, UART_CR);
334 else
335 msm_write(port, UART_CR_CMD_STOP_BREAK, UART_CR);
336}
337
6909dadd
SB		 338struct msm_baud_map {
339 u16 divisor;
340 u8 code;
341 u8 rxstale;
342};
343
344static const struct msm_baud_map *
345msm_find_best_baud(struct uart_port *port, unsigned int baud)
346{
347 unsigned int i, divisor;
348 const struct msm_baud_map *entry;
349 static const struct msm_baud_map table[] = {
350 { 1536, 0x00, 1 },
351 { 768, 0x11, 1 },
352 { 384, 0x22, 1 },
353 { 192, 0x33, 1 },
354 { 96, 0x44, 1 },
355 { 48, 0x55, 1 },
356 { 32, 0x66, 1 },
357 { 24, 0x77, 1 },
358 { 16, 0x88, 1 },
359 { 12, 0x99, 6 },
360 { 8, 0xaa, 6 },
361 { 6, 0xbb, 6 },
362 { 4, 0xcc, 6 },
363 { 3, 0xdd, 8 },
364 { 2, 0xee, 16 },
365 { 1, 0xff, 31 },
366 };
367
368 divisor = uart_get_divisor(port, baud);
369
370 for (i = 0, entry = table; i < ARRAY_SIZE(table); i++, entry++)
371 if (entry->divisor <= divisor)
372 break;
373
374 return entry; /* Default to smallest divider */
375}
376
44da59e4 377static int msm_set_baud_rate(struct uart_port *port, unsigned int baud)
04896a77 378{
6909dadd 379 unsigned int rxstale, watermark;
ec8f29e7 380 struct msm_port *msm_port = UART_TO_MSM(port);
6909dadd 381 const struct msm_baud_map *entry;
04896a77 382
6909dadd 383 entry = msm_find_best_baud(port, baud);
04896a77 384
ec8f29e7
SM		 385 if (msm_port->is_uartdm)
386 msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
387
6909dadd 388 msm_write(port, entry->code, UART_CSR);
04896a77
RL		 389
390 /* RX stale watermark */
6909dadd 391 rxstale = entry->rxstale;
04896a77
RL		 392 watermark = UART_IPR_STALE_LSB & rxstale;
393 watermark |= UART_IPR_RXSTALE_LAST;
394 watermark |= UART_IPR_STALE_TIMEOUT_MSB & (rxstale << 2);
395 msm_write(port, watermark, UART_IPR);
396
397 /* set RX watermark */
398 watermark = (port->fifosize * 3) / 4;
399 msm_write(port, watermark, UART_RFWR);
400
401 /* set TX watermark */
402 msm_write(port, 10, UART_TFWR);
44da59e4 403
ec8f29e7
SM		 404 if (msm_port->is_uartdm) {
405 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
406 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
407 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
408 }
409
44da59e4 410 return baud;
04896a77
RL		 411}
412
04896a77
RL		 413
414static void msm_init_clock(struct uart_port *port)
415{
416 struct msm_port *msm_port = UART_TO_MSM(port);
417
f98cf83d 418 clk_prepare_enable(msm_port->clk);
ec8f29e7 419 if (!IS_ERR(msm_port->pclk))
f98cf83d 420 clk_prepare_enable(msm_port->pclk);
18c79d76 421 msm_serial_set_mnd_regs(port);
04896a77
RL		 422}
423
424static int msm_startup(struct uart_port *port)
425{
426 struct msm_port *msm_port = UART_TO_MSM(port);
427 unsigned int data, rfr_level;
428 int ret;
429
430 snprintf(msm_port->name, sizeof(msm_port->name),
431 "msm_serial%d", port->line);
432
433 ret = request_irq(port->irq, msm_irq, IRQF_TRIGGER_HIGH,
434 msm_port->name, port);
435 if (unlikely(ret))
436 return ret;
437
438 msm_init_clock(port);
439
440 if (likely(port->fifosize > 12))
441 rfr_level = port->fifosize - 12;
442 else
443 rfr_level = port->fifosize;
444
445 /* set automatic RFR level */
446 data = msm_read(port, UART_MR1);
447 data &= ~UART_MR1_AUTO_RFR_LEVEL1;
448 data &= ~UART_MR1_AUTO_RFR_LEVEL0;
449 data |= UART_MR1_AUTO_RFR_LEVEL1 & (rfr_level << 2);
450 data |= UART_MR1_AUTO_RFR_LEVEL0 & rfr_level;
451 msm_write(port, data, UART_MR1);
452
453 /* make sure that RXSTALE count is non-zero */
454 data = msm_read(port, UART_IPR);
455 if (unlikely(!data)) {
456 data |= UART_IPR_RXSTALE_LAST;
457 data |= UART_IPR_STALE_LSB;
458 msm_write(port, data, UART_IPR);
459 }
460
ec8f29e7
SM		 461 data = 0;
462 if (!port->cons || (port->cons && !(port->cons->flags & CON_ENABLED))) {
463 msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
464 msm_reset(port);
465 data = UART_CR_TX_ENABLE;
466 }
467
468 data |= UART_CR_RX_ENABLE;
469 msm_write(port, data, UART_CR); /* enable TX & RX */
04896a77 470
ec8f29e7
SM		 471 /* Make sure IPR is not 0 to start with*/
472 if (msm_port->is_uartdm)
473 msm_write(port, UART_IPR_STALE_LSB, UART_IPR);
04896a77
RL		 474
475 /* turn on RX and CTS interrupts */
476 msm_port->imr = UART_IMR_RXLEV | UART_IMR_RXSTALE |
477 UART_IMR_CURRENT_CTS;
04896a77 478
ec8f29e7
SM		 479 if (msm_port->is_uartdm) {
480 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
481 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
482 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
483 }
484
485 msm_write(port, msm_port->imr, UART_IMR);
04896a77
RL		 486 return 0;
487}
488
489static void msm_shutdown(struct uart_port *port)
490{
491 struct msm_port *msm_port = UART_TO_MSM(port);
492
493 msm_port->imr = 0;
494 msm_write(port, 0, UART_IMR); /* disable interrupts */
495
f98cf83d 496 clk_disable_unprepare(msm_port->clk);
04896a77
RL		 497
498 free_irq(port->irq, port);
499}
500
501static void msm_set_termios(struct uart_port *port, struct ktermios *termios,
502 struct ktermios *old)
503{
504 unsigned long flags;
505 unsigned int baud, mr;
506
507 spin_lock_irqsave(&port->lock, flags);
508
509 /* calculate and set baud rate */
510 baud = uart_get_baud_rate(port, termios, old, 300, 115200);
44da59e4
AC		 511 baud = msm_set_baud_rate(port, baud);
512 if (tty_termios_baud_rate(termios))
513 tty_termios_encode_baud_rate(termios, baud, baud);
ec8f29e7 514
04896a77
RL		 515 /* calculate parity */
516 mr = msm_read(port, UART_MR2);
517 mr &= ~UART_MR2_PARITY_MODE;
518 if (termios->c_cflag & PARENB) {
519 if (termios->c_cflag & PARODD)
520 mr |= UART_MR2_PARITY_MODE_ODD;
521 else if (termios->c_cflag & CMSPAR)
522 mr |= UART_MR2_PARITY_MODE_SPACE;
523 else
524 mr |= UART_MR2_PARITY_MODE_EVEN;
525 }
526
527 /* calculate bits per char */
528 mr &= ~UART_MR2_BITS_PER_CHAR;
529 switch (termios->c_cflag & CSIZE) {
530 case CS5:
531 mr |= UART_MR2_BITS_PER_CHAR_5;
532 break;
533 case CS6:
534 mr |= UART_MR2_BITS_PER_CHAR_6;
535 break;
536 case CS7:
537 mr |= UART_MR2_BITS_PER_CHAR_7;
538 break;
539 case CS8:
540 default:
541 mr |= UART_MR2_BITS_PER_CHAR_8;
542 break;
543 }
544
545 /* calculate stop bits */
546 mr &= ~(UART_MR2_STOP_BIT_LEN_ONE | UART_MR2_STOP_BIT_LEN_TWO);
547 if (termios->c_cflag & CSTOPB)
548 mr |= UART_MR2_STOP_BIT_LEN_TWO;
549 else
550 mr |= UART_MR2_STOP_BIT_LEN_ONE;
551
552 /* set parity, bits per char, and stop bit */
553 msm_write(port, mr, UART_MR2);
554
555 /* calculate and set hardware flow control */
556 mr = msm_read(port, UART_MR1);
557 mr &= ~(UART_MR1_CTS_CTL | UART_MR1_RX_RDY_CTL);
558 if (termios->c_cflag & CRTSCTS) {
559 mr |= UART_MR1_CTS_CTL;
560 mr |= UART_MR1_RX_RDY_CTL;
561 }
562 msm_write(port, mr, UART_MR1);
563
564 /* Configure status bits to ignore based on termio flags. */
565 port->read_status_mask = 0;
566 if (termios->c_iflag & INPCK)
567 port->read_status_mask |= UART_SR_PAR_FRAME_ERR;
568 if (termios->c_iflag & (BRKINT | PARMRK))
569 port->read_status_mask |= UART_SR_RX_BREAK;
570
571 uart_update_timeout(port, termios->c_cflag, baud);
572
573 spin_unlock_irqrestore(&port->lock, flags);
574}
575
576static const char *msm_type(struct uart_port *port)
577{
578 return "MSM";
579}
580
581static void msm_release_port(struct uart_port *port)
582{
583 struct platform_device *pdev = to_platform_device(port->dev);
ec8f29e7
SM		 584 struct msm_port *msm_port = UART_TO_MSM(port);
585 struct resource *uart_resource;
586 struct resource *gsbi_resource;
04896a77
RL		 587 resource_size_t size;
588
ec8f29e7
SM		 589 uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
590 if (unlikely(!uart_resource))
04896a77 591 return;
ec8f29e7 592 size = resource_size(uart_resource);
04896a77
RL		 593
594 release_mem_region(port->mapbase, size);
595 iounmap(port->membase);
596 port->membase = NULL;
ec8f29e7
SM		 597
598 if (msm_port->gsbi_base) {
f8fb952f
SB		 599 writel_relaxed(GSBI_PROTOCOL_IDLE,
600 msm_port->gsbi_base + GSBI_CONTROL);
ec8f29e7 601
f8fb952f 602 gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
ec8f29e7
SM		 603 if (unlikely(!gsbi_resource))
604 return;
605
606 size = resource_size(gsbi_resource);
607 release_mem_region(gsbi_resource->start, size);
608 iounmap(msm_port->gsbi_base);
609 msm_port->gsbi_base = NULL;
610 }
04896a77
RL		 611}
612
613static int msm_request_port(struct uart_port *port)
614{
ec8f29e7 615 struct msm_port *msm_port = UART_TO_MSM(port);
04896a77 616 struct platform_device *pdev = to_platform_device(port->dev);
ec8f29e7
SM		 617 struct resource *uart_resource;
618 struct resource *gsbi_resource;
04896a77 619 resource_size_t size;
ec8f29e7 620 int ret;
04896a77 621
886a451b 622 uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
ec8f29e7 623 if (unlikely(!uart_resource))
04896a77 624 return -ENXIO;
04896a77 625
ec8f29e7
SM		 626 size = resource_size(uart_resource);
627
628 if (!request_mem_region(port->mapbase, size, "msm_serial"))
04896a77
RL		 629 return -EBUSY;
630
631 port->membase = ioremap(port->mapbase, size);
632 if (!port->membase) {
ec8f29e7
SM		 633 ret = -EBUSY;
634 goto fail_release_port;
635 }
636
886a451b 637 gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
ec8f29e7
SM		 638 /* Is this a GSBI-based port? */
639 if (gsbi_resource) {
640 size = resource_size(gsbi_resource);
641
642 if (!request_mem_region(gsbi_resource->start, size,
643 "msm_serial")) {
644 ret = -EBUSY;
195be84a 645 goto fail_release_port_membase;
ec8f29e7
SM		 646 }
647
648 msm_port->gsbi_base = ioremap(gsbi_resource->start, size);
649 if (!msm_port->gsbi_base) {
650 ret = -EBUSY;
651 goto fail_release_gsbi;
652 }
04896a77
RL		 653 }
654
655 return 0;
ec8f29e7
SM		 656
657fail_release_gsbi:
658 release_mem_region(gsbi_resource->start, size);
195be84a
WY		 659fail_release_port_membase:
660 iounmap(port->membase);
ec8f29e7
SM		 661fail_release_port:
662 release_mem_region(port->mapbase, size);
663 return ret;
04896a77
RL		 664}
665
666static void msm_config_port(struct uart_port *port, int flags)
667{
ec8f29e7
SM		 668 struct msm_port *msm_port = UART_TO_MSM(port);
669 int ret;
04896a77
RL		 670 if (flags & UART_CONFIG_TYPE) {
671 port->type = PORT_MSM;
ec8f29e7
SM		 672 ret = msm_request_port(port);
673 if (ret)
674 return;
04896a77 675 }
ec8f29e7 676 if (msm_port->is_uartdm)
f8fb952f
SB		 677 writel_relaxed(GSBI_PROTOCOL_UART,
678 msm_port->gsbi_base + GSBI_CONTROL);
04896a77
RL		 679}
680
681static int msm_verify_port(struct uart_port *port, struct serial_struct *ser)
682{
683 if (unlikely(ser->type != PORT_UNKNOWN && ser->type != PORT_MSM))
684 return -EINVAL;
685 if (unlikely(port->irq != ser->irq))
686 return -EINVAL;
687 return 0;
688}
689
690static void msm_power(struct uart_port *port, unsigned int state,
691 unsigned int oldstate)
692{
693 struct msm_port *msm_port = UART_TO_MSM(port);
694
695 switch (state) {
696 case 0:
f98cf83d 697 clk_prepare_enable(msm_port->clk);
ec8f29e7 698 if (!IS_ERR(msm_port->pclk))
f98cf83d 699 clk_prepare_enable(msm_port->pclk);
04896a77
RL		 700 break;
701 case 3:
f98cf83d 702 clk_disable_unprepare(msm_port->clk);
ec8f29e7 703 if (!IS_ERR(msm_port->pclk))
f98cf83d 704 clk_disable_unprepare(msm_port->pclk);
04896a77
RL		 705 break;
706 default:
707 printk(KERN_ERR "msm_serial: Unknown PM state %d\n", state);
708 }
709}
710
711static struct uart_ops msm_uart_pops = {
712 .tx_empty = msm_tx_empty,
713 .set_mctrl = msm_set_mctrl,
714 .get_mctrl = msm_get_mctrl,
715 .stop_tx = msm_stop_tx,
716 .start_tx = msm_start_tx,
717 .stop_rx = msm_stop_rx,
718 .enable_ms = msm_enable_ms,
719 .break_ctl = msm_break_ctl,
720 .startup = msm_startup,
721 .shutdown = msm_shutdown,
722 .set_termios = msm_set_termios,
723 .type = msm_type,
724 .release_port = msm_release_port,
725 .request_port = msm_request_port,
726 .config_port = msm_config_port,
727 .verify_port = msm_verify_port,
728 .pm = msm_power,
729};
730
731static struct msm_port msm_uart_ports[] = {
732 {
733 .uart = {
734 .iotype = UPIO_MEM,
735 .ops = &msm_uart_pops,
736 .flags = UPF_BOOT_AUTOCONF,
ec8f29e7 737 .fifosize = 64,
04896a77
RL		 738 .line = 0,
739 },
740 },
741 {
742 .uart = {
743 .iotype = UPIO_MEM,
744 .ops = &msm_uart_pops,
745 .flags = UPF_BOOT_AUTOCONF,
ec8f29e7 746 .fifosize = 64,
04896a77
RL		 747 .line = 1,
748 },
749 },
750 {
751 .uart = {
752 .iotype = UPIO_MEM,
753 .ops = &msm_uart_pops,
754 .flags = UPF_BOOT_AUTOCONF,
755 .fifosize = 64,
756 .line = 2,
757 },
758 },
759};
760
761#define UART_NR ARRAY_SIZE(msm_uart_ports)
762
763static inline struct uart_port *get_port_from_line(unsigned int line)
764{
765 return &msm_uart_ports[line].uart;
766}
767
768#ifdef CONFIG_SERIAL_MSM_CONSOLE
769
770static void msm_console_putchar(struct uart_port *port, int c)
771{
ec8f29e7
SM		 772 struct msm_port *msm_port = UART_TO_MSM(port);
773
774 if (msm_port->is_uartdm)
17fae28e 775 reset_dm_count(port, 1);
ec8f29e7 776
04896a77
RL		 777 while (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
778 ;
ec8f29e7 779 msm_write(port, c, msm_port->is_uartdm ? UARTDM_TF : UART_TF);
04896a77
RL		 780}
781
782static void msm_console_write(struct console *co, const char *s,
783 unsigned int count)
784{
785 struct uart_port *port;
786 struct msm_port *msm_port;
787
788 BUG_ON(co->index < 0 || co->index >= UART_NR);
789
790 port = get_port_from_line(co->index);
791 msm_port = UART_TO_MSM(port);
792
793 spin_lock(&port->lock);
794 uart_console_write(port, s, count, msm_console_putchar);
795 spin_unlock(&port->lock);
796}
797
798static int __init msm_console_setup(struct console *co, char *options)
799{
800 struct uart_port *port;
ec8f29e7 801 struct msm_port *msm_port;
04896a77
RL		 802 int baud, flow, bits, parity;
803
804 if (unlikely(co->index >= UART_NR || co->index < 0))
805 return -ENXIO;
806
807 port = get_port_from_line(co->index);
ec8f29e7 808 msm_port = UART_TO_MSM(port);
04896a77
RL		 809
810 if (unlikely(!port->membase))
811 return -ENXIO;
812
04896a77
RL		 813 msm_init_clock(port);
814
815 if (options)
816 uart_parse_options(options, &baud, &parity, &bits, &flow);
817
818 bits = 8;
819 parity = 'n';
820 flow = 'n';
821 msm_write(port, UART_MR2_BITS_PER_CHAR_8 | UART_MR2_STOP_BIT_LEN_ONE,
822 UART_MR2); /* 8N1 */
823
824 if (baud < 300 || baud > 115200)
825 baud = 115200;
826 msm_set_baud_rate(port, baud);
827
828 msm_reset(port);
829
ec8f29e7
SM		 830 if (msm_port->is_uartdm) {
831 msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
832 msm_write(port, UART_CR_TX_ENABLE, UART_CR);
833 }
834
04896a77
RL		 835 printk(KERN_INFO "msm_serial: console setup on port #%d\n", port->line);
836
837 return uart_set_options(port, co, baud, parity, bits, flow);
838}
839
840static struct uart_driver msm_uart_driver;
841
842static struct console msm_console = {
843 .name = "ttyMSM",
844 .write = msm_console_write,
845 .device = uart_console_device,
846 .setup = msm_console_setup,
847 .flags = CON_PRINTBUFFER,
848 .index = -1,
849 .data = &msm_uart_driver,
850};
851
852#define MSM_CONSOLE (&msm_console)
853
854#else
855#define MSM_CONSOLE NULL
856#endif
857
858static struct uart_driver msm_uart_driver = {
859 .owner = THIS_MODULE,
860 .driver_name = "msm_serial",
861 .dev_name = "ttyMSM",
862 .nr = UART_NR,
863 .cons = MSM_CONSOLE,
864};
865
cfdad2ab
DB		 866static atomic_t msm_uart_next_id = ATOMIC_INIT(0);
867
04896a77
RL		 868static int __init msm_serial_probe(struct platform_device *pdev)
869{
870 struct msm_port *msm_port;
871 struct resource *resource;
872 struct uart_port *port;
1e091751 873 int irq;
04896a77 874
cfdad2ab
DB		 875 if (pdev->id == -1)
876 pdev->id = atomic_inc_return(&msm_uart_next_id) - 1;
877
04896a77
RL		 878 if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
879 return -ENXIO;
880
881 printk(KERN_INFO "msm_serial: detected port #%d\n", pdev->id);
882
883 port = get_port_from_line(pdev->id);
884 port->dev = &pdev->dev;
885 msm_port = UART_TO_MSM(port);
886
886a451b 887 if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
ec8f29e7
SM		 888 msm_port->is_uartdm = 1;
889 else
890 msm_port->is_uartdm = 0;
891
892 if (msm_port->is_uartdm) {
519b371d
SB		 893 msm_port->clk = devm_clk_get(&pdev->dev, "gsbi_uart_clk");
894 msm_port->pclk = devm_clk_get(&pdev->dev, "gsbi_pclk");
ec8f29e7 895 } else {
519b371d 896 msm_port->clk = devm_clk_get(&pdev->dev, "uart_clk");
ec8f29e7
SM		 897 msm_port->pclk = ERR_PTR(-ENOENT);
898 }
899
519b371d
SB		 900 if (IS_ERR(msm_port->clk))
901 return PTR_ERR(msm_port->clk);
902
903 if (msm_port->is_uartdm) {
904 if (IS_ERR(msm_port->pclk))
905 return PTR_ERR(msm_port->pclk);
ec8f29e7 906
7b6031a7 907 clk_set_rate(msm_port->clk, 1843200);
519b371d 908 }
ec8f29e7 909
04896a77 910 port->uartclk = clk_get_rate(msm_port->clk);
18c79d76
AD		 911 printk(KERN_INFO "uartclk = %d\n", port->uartclk);
912
04896a77 913
886a451b 914 resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
04896a77
RL		 915 if (unlikely(!resource))
916 return -ENXIO;
917 port->mapbase = resource->start;
918
1e091751
RK		 919 irq = platform_get_irq(pdev, 0);
920 if (unlikely(irq < 0))
04896a77 921 return -ENXIO;
1e091751 922 port->irq = irq;
04896a77
RL		 923
924 platform_set_drvdata(pdev, port);
925
926 return uart_add_one_port(&msm_uart_driver, port);
927}
928
ae8d8a14 929static int msm_serial_remove(struct platform_device *pdev)
04896a77 930{
519b371d 931 struct uart_port *port = platform_get_drvdata(pdev);
04896a77 932
519b371d 933 uart_remove_one_port(&msm_uart_driver, port);
04896a77
RL		 934
935 return 0;
936}
937
cfdad2ab
DB		 938static struct of_device_id msm_match_table[] = {
939 { .compatible = "qcom,msm-uart" },
940 {}
941};
942
04896a77 943static struct platform_driver msm_platform_driver = {
04896a77
RL		 944 .remove = msm_serial_remove,
945 .driver = {
946 .name = "msm_serial",
947 .owner = THIS_MODULE,
cfdad2ab 948 .of_match_table = msm_match_table,
04896a77
RL		 949 },
950};
951
952static int __init msm_serial_init(void)
953{
954 int ret;
955
956 ret = uart_register_driver(&msm_uart_driver);
957 if (unlikely(ret))
958 return ret;
959
960 ret = platform_driver_probe(&msm_platform_driver, msm_serial_probe);
961 if (unlikely(ret))
962 uart_unregister_driver(&msm_uart_driver);
963
964 printk(KERN_INFO "msm_serial: driver initialized\n");
965
966 return ret;
967}
968
969static void __exit msm_serial_exit(void)
970{
971#ifdef CONFIG_SERIAL_MSM_CONSOLE
972 unregister_console(&msm_console);
973#endif
974 platform_driver_unregister(&msm_platform_driver);
975 uart_unregister_driver(&msm_uart_driver);
976}
977
978module_init(msm_serial_init);
979module_exit(msm_serial_exit);
980
981MODULE_AUTHOR("Robert Love <rlove@google.com>");
982MODULE_DESCRIPTION("Driver for msm7x serial device");
983MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)