aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/tty
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2014-06-08 14:31:16 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2014-06-08 14:31:16 -0400
commit3f17ea6dea8ba5668873afa54628a91aaa3fb1c0 (patch)
treeafbeb2accd4c2199ddd705ae943995b143a0af02 /drivers/tty
parent1860e379875dfe7271c649058aeddffe5afd9d0d (diff)
parent1a5700bc2d10cd379a795fd2bb377a190af5acd4 (diff)
Merge branch 'next' (accumulated 3.16 merge window patches) into master
Now that 3.15 is released, this merges the 'next' branch into 'master', bringing us to the normal situation where my 'master' branch is the merge window. * accumulated work in next: (6809 commits) ufs: sb mutex merge + mutex_destroy powerpc: update comments for generic idle conversion cris: update comments for generic idle conversion idle: remove cpu_idle() forward declarations nbd: zero from and len fields in NBD_CMD_DISCONNECT. mm: convert some level-less printks to pr_* MAINTAINERS: adi-buildroot-devel is moderated MAINTAINERS: add linux-api for review of API/ABI changes mm/kmemleak-test.c: use pr_fmt for logging fs/dlm/debug_fs.c: replace seq_printf by seq_puts fs/dlm/lockspace.c: convert simple_str to kstr fs/dlm/config.c: convert simple_str to kstr mm: mark remap_file_pages() syscall as deprecated mm: memcontrol: remove unnecessary memcg argument from soft limit functions mm: memcontrol: clean up memcg zoneinfo lookup mm/memblock.c: call kmemleak directly from memblock_(alloc|free) mm/mempool.c: update the kmemleak stack trace for mempool allocations lib/radix-tree.c: update the kmemleak stack trace for radix tree allocations mm: introduce kmemleak_update_trace() mm/kmemleak.c: use %u to print ->checksum ...
Diffstat (limited to 'drivers/tty')
-rw-r--r--drivers/tty/goldfish.c68
-rw-r--r--drivers/tty/hvc/hvc_console.c9
-rw-r--r--drivers/tty/hvc/hvc_dcc.c42
-rw-r--r--drivers/tty/hvc/hvc_tile.c8
-rw-r--r--drivers/tty/n_hdlc.c8
-rw-r--r--drivers/tty/n_tty.c2
-rw-r--r--drivers/tty/serial/8250/8250_core.c11
-rw-r--r--drivers/tty/serial/8250/8250_dma.c17
-rw-r--r--drivers/tty/serial/8250/8250_dw.c81
-rw-r--r--drivers/tty/serial/8250/8250_early.c138
-rw-r--r--drivers/tty/serial/8250/8250_pci.c19
-rw-r--r--drivers/tty/serial/8250/Kconfig6
-rw-r--r--drivers/tty/serial/Kconfig57
-rw-r--r--drivers/tty/serial/Makefile8
-rw-r--r--drivers/tty/serial/amba-pl011.c31
-rw-r--r--drivers/tty/serial/atmel_serial.c230
-rw-r--r--drivers/tty/serial/cpm_uart/cpm_uart_core.c8
-rw-r--r--drivers/tty/serial/earlycon-arm-semihost.c61
-rw-r--r--drivers/tty/serial/earlycon.c172
-rw-r--r--drivers/tty/serial/efm32-uart.c1
-rw-r--r--drivers/tty/serial/imx.c39
-rw-r--r--drivers/tty/serial/kgdb_nmi.c59
-rw-r--r--drivers/tty/serial/men_z135_uart.c867
-rw-r--r--drivers/tty/serial/msm_serial.c48
-rw-r--r--drivers/tty/serial/msm_serial.h5
-rw-r--r--drivers/tty/serial/mux.c4
-rw-r--r--drivers/tty/serial/mxs-auart.c4
-rw-r--r--drivers/tty/serial/of_serial.c5
-rw-r--r--drivers/tty/serial/omap-serial.c94
-rw-r--r--drivers/tty/serial/pch_uart.c13
-rw-r--r--drivers/tty/serial/pxa.c5
-rw-r--r--drivers/tty/serial/samsung.c35
-rw-r--r--drivers/tty/serial/samsung.h23
-rw-r--r--drivers/tty/serial/sc16is7xx.c1277
-rw-r--r--drivers/tty/serial/sccnxp.c6
-rw-r--r--drivers/tty/serial/serial_core.c15
-rw-r--r--drivers/tty/serial/serial_mctrl_gpio.c143
-rw-r--r--drivers/tty/serial/serial_mctrl_gpio.h110
-rw-r--r--drivers/tty/serial/serial_txx9.c5
-rw-r--r--drivers/tty/serial/sirfsoc_uart.c51
-rw-r--r--drivers/tty/serial/sirfsoc_uart.h4
-rw-r--r--drivers/tty/serial/st-asc.c8
-rw-r--r--drivers/tty/serial/tilegx.c8
-rw-r--r--drivers/tty/serial/uartlite.c17
-rw-r--r--drivers/tty/serial/xilinx_uartps.c1129
-rw-r--r--drivers/tty/sysrq.c29
-rw-r--r--drivers/tty/vt/consolemap.c54
-rw-r--r--drivers/tty/vt/vt.c89
48 files changed, 3934 insertions, 1189 deletions
diff --git a/drivers/tty/goldfish.c b/drivers/tty/goldfish.c
index 75dc9d25f326..09495f515fa9 100644
--- a/drivers/tty/goldfish.c
+++ b/drivers/tty/goldfish.c
@@ -21,6 +21,7 @@
21#include <linux/slab.h> 21#include <linux/slab.h>
22#include <linux/io.h> 22#include <linux/io.h>
23#include <linux/module.h> 23#include <linux/module.h>
24#include <linux/goldfish.h>
24 25
25enum { 26enum {
26 GOLDFISH_TTY_PUT_CHAR = 0x00, 27 GOLDFISH_TTY_PUT_CHAR = 0x00,
@@ -29,6 +30,7 @@ enum {
29 30
30 GOLDFISH_TTY_DATA_PTR = 0x10, 31 GOLDFISH_TTY_DATA_PTR = 0x10,
31 GOLDFISH_TTY_DATA_LEN = 0x14, 32 GOLDFISH_TTY_DATA_LEN = 0x14,
33 GOLDFISH_TTY_DATA_PTR_HIGH = 0x18,
32 34
33 GOLDFISH_TTY_CMD_INT_DISABLE = 0, 35 GOLDFISH_TTY_CMD_INT_DISABLE = 0,
34 GOLDFISH_TTY_CMD_INT_ENABLE = 1, 36 GOLDFISH_TTY_CMD_INT_ENABLE = 1,
@@ -57,7 +59,8 @@ static void goldfish_tty_do_write(int line, const char *buf, unsigned count)
57 struct goldfish_tty *qtty = &goldfish_ttys[line]; 59 struct goldfish_tty *qtty = &goldfish_ttys[line];
58 void __iomem *base = qtty->base; 60 void __iomem *base = qtty->base;
59 spin_lock_irqsave(&qtty->lock, irq_flags); 61 spin_lock_irqsave(&qtty->lock, irq_flags);
60 writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR); 62 gf_write64((u64)buf, base + GOLDFISH_TTY_DATA_PTR,
63 base + GOLDFISH_TTY_DATA_PTR_HIGH);
61 writel(count, base + GOLDFISH_TTY_DATA_LEN); 64 writel(count, base + GOLDFISH_TTY_DATA_LEN);
62 writel(GOLDFISH_TTY_CMD_WRITE_BUFFER, base + GOLDFISH_TTY_CMD); 65 writel(GOLDFISH_TTY_CMD_WRITE_BUFFER, base + GOLDFISH_TTY_CMD);
63 spin_unlock_irqrestore(&qtty->lock, irq_flags); 66 spin_unlock_irqrestore(&qtty->lock, irq_flags);
@@ -73,12 +76,13 @@ static irqreturn_t goldfish_tty_interrupt(int irq, void *dev_id)
73 u32 count; 76 u32 count;
74 77
75 count = readl(base + GOLDFISH_TTY_BYTES_READY); 78 count = readl(base + GOLDFISH_TTY_BYTES_READY);
76 if(count == 0) 79 if (count == 0)
77 return IRQ_NONE; 80 return IRQ_NONE;
78 81
79 count = tty_prepare_flip_string(&qtty->port, &buf, count); 82 count = tty_prepare_flip_string(&qtty->port, &buf, count);
80 spin_lock_irqsave(&qtty->lock, irq_flags); 83 spin_lock_irqsave(&qtty->lock, irq_flags);
81 writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR); 84 gf_write64((u64)buf, base + GOLDFISH_TTY_DATA_PTR,
85 base + GOLDFISH_TTY_DATA_PTR_HIGH);
82 writel(count, base + GOLDFISH_TTY_DATA_LEN); 86 writel(count, base + GOLDFISH_TTY_DATA_LEN);
83 writel(GOLDFISH_TTY_CMD_READ_BUFFER, base + GOLDFISH_TTY_CMD); 87 writel(GOLDFISH_TTY_CMD_READ_BUFFER, base + GOLDFISH_TTY_CMD);
84 spin_unlock_irqrestore(&qtty->lock, irq_flags); 88 spin_unlock_irqrestore(&qtty->lock, irq_flags);
@@ -88,24 +92,26 @@ static irqreturn_t goldfish_tty_interrupt(int irq, void *dev_id)
88 92
89static int goldfish_tty_activate(struct tty_port *port, struct tty_struct *tty) 93static int goldfish_tty_activate(struct tty_port *port, struct tty_struct *tty)
90{ 94{
91 struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port); 95 struct goldfish_tty *qtty = container_of(port, struct goldfish_tty,
96 port);
92 writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_CMD); 97 writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_CMD);
93 return 0; 98 return 0;
94} 99}
95 100
96static void goldfish_tty_shutdown(struct tty_port *port) 101static void goldfish_tty_shutdown(struct tty_port *port)
97{ 102{
98 struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port); 103 struct goldfish_tty *qtty = container_of(port, struct goldfish_tty,
104 port);
99 writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_CMD); 105 writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_CMD);
100} 106}
101 107
102static int goldfish_tty_open(struct tty_struct * tty, struct file * filp) 108static int goldfish_tty_open(struct tty_struct *tty, struct file *filp)
103{ 109{
104 struct goldfish_tty *qtty = &goldfish_ttys[tty->index]; 110 struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
105 return tty_port_open(&qtty->port, tty, filp); 111 return tty_port_open(&qtty->port, tty, filp);
106} 112}
107 113
108static void goldfish_tty_close(struct tty_struct * tty, struct file * filp) 114static void goldfish_tty_close(struct tty_struct *tty, struct file *filp)
109{ 115{
110 tty_port_close(tty->port, tty, filp); 116 tty_port_close(tty->port, tty, filp);
111} 117}
@@ -115,7 +121,8 @@ static void goldfish_tty_hangup(struct tty_struct *tty)
115 tty_port_hangup(tty->port); 121 tty_port_hangup(tty->port);
116} 122}
117 123
118static int goldfish_tty_write(struct tty_struct * tty, const unsigned char *buf, int count) 124static int goldfish_tty_write(struct tty_struct *tty, const unsigned char *buf,
125 int count)
119{ 126{
120 goldfish_tty_do_write(tty->index, buf, count); 127 goldfish_tty_do_write(tty->index, buf, count);
121 return count; 128 return count;
@@ -133,12 +140,14 @@ static int goldfish_tty_chars_in_buffer(struct tty_struct *tty)
133 return readl(base + GOLDFISH_TTY_BYTES_READY); 140 return readl(base + GOLDFISH_TTY_BYTES_READY);
134} 141}
135 142
136static void goldfish_tty_console_write(struct console *co, const char *b, unsigned count) 143static void goldfish_tty_console_write(struct console *co, const char *b,
144 unsigned count)
137{ 145{
138 goldfish_tty_do_write(co->index, b, count); 146 goldfish_tty_do_write(co->index, b, count);
139} 147}
140 148
141static struct tty_driver *goldfish_tty_console_device(struct console *c, int *index) 149static struct tty_driver *goldfish_tty_console_device(struct console *c,
150 int *index)
142{ 151{
143 *index = c->index; 152 *index = c->index;
144 return goldfish_tty_driver; 153 return goldfish_tty_driver;
@@ -146,9 +155,9 @@ static struct tty_driver *goldfish_tty_console_device(struct console *c, int *in
146 155
147static int goldfish_tty_console_setup(struct console *co, char *options) 156static int goldfish_tty_console_setup(struct console *co, char *options)
148{ 157{
149 if((unsigned)co->index > goldfish_tty_line_count) 158 if ((unsigned)co->index > goldfish_tty_line_count)
150 return -ENODEV; 159 return -ENODEV;
151 if(goldfish_ttys[co->index].base == 0) 160 if (goldfish_ttys[co->index].base == 0)
152 return -ENODEV; 161 return -ENODEV;
153 return 0; 162 return 0;
154} 163}
@@ -158,7 +167,7 @@ static struct tty_port_operations goldfish_port_ops = {
158 .shutdown = goldfish_tty_shutdown 167 .shutdown = goldfish_tty_shutdown
159}; 168};
160 169
161static struct tty_operations goldfish_tty_ops = { 170static const struct tty_operations goldfish_tty_ops = {
162 .open = goldfish_tty_open, 171 .open = goldfish_tty_open,
163 .close = goldfish_tty_close, 172 .close = goldfish_tty_close,
164 .hangup = goldfish_tty_hangup, 173 .hangup = goldfish_tty_hangup,
@@ -172,13 +181,14 @@ static int goldfish_tty_create_driver(void)
172 int ret; 181 int ret;
173 struct tty_driver *tty; 182 struct tty_driver *tty;
174 183
175 goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) * goldfish_tty_line_count, GFP_KERNEL); 184 goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) *
176 if(goldfish_ttys == NULL) { 185 goldfish_tty_line_count, GFP_KERNEL);
186 if (goldfish_ttys == NULL) {
177 ret = -ENOMEM; 187 ret = -ENOMEM;
178 goto err_alloc_goldfish_ttys_failed; 188 goto err_alloc_goldfish_ttys_failed;
179 } 189 }
180 tty = alloc_tty_driver(goldfish_tty_line_count); 190 tty = alloc_tty_driver(goldfish_tty_line_count);
181 if(tty == NULL) { 191 if (tty == NULL) {
182 ret = -ENOMEM; 192 ret = -ENOMEM;
183 goto err_alloc_tty_driver_failed; 193 goto err_alloc_tty_driver_failed;
184 } 194 }
@@ -187,10 +197,11 @@ static int goldfish_tty_create_driver(void)
187 tty->type = TTY_DRIVER_TYPE_SERIAL; 197 tty->type = TTY_DRIVER_TYPE_SERIAL;
188 tty->subtype = SERIAL_TYPE_NORMAL; 198 tty->subtype = SERIAL_TYPE_NORMAL;
189 tty->init_termios = tty_std_termios; 199 tty->init_termios = tty_std_termios;
190 tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 200 tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
201 TTY_DRIVER_DYNAMIC_DEV;
191 tty_set_operations(tty, &goldfish_tty_ops); 202 tty_set_operations(tty, &goldfish_tty_ops);
192 ret = tty_register_driver(tty); 203 ret = tty_register_driver(tty);
193 if(ret) 204 if (ret)
194 goto err_tty_register_driver_failed; 205 goto err_tty_register_driver_failed;
195 206
196 goldfish_tty_driver = tty; 207 goldfish_tty_driver = tty;
@@ -225,7 +236,7 @@ static int goldfish_tty_probe(struct platform_device *pdev)
225 u32 irq; 236 u32 irq;
226 237
227 r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 238 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
228 if(r == NULL) 239 if (r == NULL)
229 return -EINVAL; 240 return -EINVAL;
230 241
231 base = ioremap(r->start, 0x1000); 242 base = ioremap(r->start, 0x1000);
@@ -233,18 +244,18 @@ static int goldfish_tty_probe(struct platform_device *pdev)
233 pr_err("goldfish_tty: unable to remap base\n"); 244 pr_err("goldfish_tty: unable to remap base\n");
234 245
235 r = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 246 r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
236 if(r == NULL) 247 if (r == NULL)
237 goto err_unmap; 248 goto err_unmap;
238 249
239 irq = r->start; 250 irq = r->start;
240 251
241 if(pdev->id >= goldfish_tty_line_count) 252 if (pdev->id >= goldfish_tty_line_count)
242 goto err_unmap; 253 goto err_unmap;
243 254
244 mutex_lock(&goldfish_tty_lock); 255 mutex_lock(&goldfish_tty_lock);
245 if(goldfish_tty_current_line_count == 0) { 256 if (goldfish_tty_current_line_count == 0) {
246 ret = goldfish_tty_create_driver(); 257 ret = goldfish_tty_create_driver();
247 if(ret) 258 if (ret)
248 goto err_create_driver_failed; 259 goto err_create_driver_failed;
249 } 260 }
250 goldfish_tty_current_line_count++; 261 goldfish_tty_current_line_count++;
@@ -258,14 +269,15 @@ static int goldfish_tty_probe(struct platform_device *pdev)
258 269
259 writel(GOLDFISH_TTY_CMD_INT_DISABLE, base + GOLDFISH_TTY_CMD); 270 writel(GOLDFISH_TTY_CMD_INT_DISABLE, base + GOLDFISH_TTY_CMD);
260 271
261 ret = request_irq(irq, goldfish_tty_interrupt, IRQF_SHARED, "goldfish_tty", pdev); 272 ret = request_irq(irq, goldfish_tty_interrupt, IRQF_SHARED,
262 if(ret) 273 "goldfish_tty", pdev);
274 if (ret)
263 goto err_request_irq_failed; 275 goto err_request_irq_failed;
264 276
265 277
266 ttydev = tty_port_register_device(&qtty->port, goldfish_tty_driver, 278 ttydev = tty_port_register_device(&qtty->port, goldfish_tty_driver,
267 pdev->id, &pdev->dev); 279 pdev->id, &pdev->dev);
268 if(IS_ERR(ttydev)) { 280 if (IS_ERR(ttydev)) {
269 ret = PTR_ERR(ttydev); 281 ret = PTR_ERR(ttydev);
270 goto err_tty_register_device_failed; 282 goto err_tty_register_device_failed;
271 } 283 }
@@ -286,7 +298,7 @@ err_tty_register_device_failed:
286 free_irq(irq, pdev); 298 free_irq(irq, pdev);
287err_request_irq_failed: 299err_request_irq_failed:
288 goldfish_tty_current_line_count--; 300 goldfish_tty_current_line_count--;
289 if(goldfish_tty_current_line_count == 0) 301 if (goldfish_tty_current_line_count == 0)
290 goldfish_tty_delete_driver(); 302 goldfish_tty_delete_driver();
291err_create_driver_failed: 303err_create_driver_failed:
292 mutex_unlock(&goldfish_tty_lock); 304 mutex_unlock(&goldfish_tty_lock);
@@ -308,7 +320,7 @@ static int goldfish_tty_remove(struct platform_device *pdev)
308 qtty->base = 0; 320 qtty->base = 0;
309 free_irq(qtty->irq, pdev); 321 free_irq(qtty->irq, pdev);
310 goldfish_tty_current_line_count--; 322 goldfish_tty_current_line_count--;
311 if(goldfish_tty_current_line_count == 0) 323 if (goldfish_tty_current_line_count == 0)
312 goldfish_tty_delete_driver(); 324 goldfish_tty_delete_driver();
313 mutex_unlock(&goldfish_tty_lock); 325 mutex_unlock(&goldfish_tty_lock);
314 return 0; 326 return 0;
diff --git a/drivers/tty/hvc/hvc_console.c b/drivers/tty/hvc/hvc_console.c
index 0ff7fda0742f..4fcec1d793a7 100644
--- a/drivers/tty/hvc/hvc_console.c
+++ b/drivers/tty/hvc/hvc_console.c
@@ -760,10 +760,17 @@ static int khvcd(void *unused)
760 if (poll_mask == 0) 760 if (poll_mask == 0)
761 schedule(); 761 schedule();
762 else { 762 else {
763 unsigned long j_timeout;
764
763 if (timeout < MAX_TIMEOUT) 765 if (timeout < MAX_TIMEOUT)
764 timeout += (timeout >> 6) + 1; 766 timeout += (timeout >> 6) + 1;
765 767
766 msleep_interruptible(timeout); 768 /*
769 * We don't use msleep_interruptible otherwise
770 * "kick" will fail to wake us up
771 */
772 j_timeout = msecs_to_jiffies(timeout) + 1;
773 schedule_timeout_interruptible(j_timeout);
767 } 774 }
768 } 775 }
769 __set_current_state(TASK_RUNNING); 776 __set_current_state(TASK_RUNNING);
diff --git a/drivers/tty/hvc/hvc_dcc.c b/drivers/tty/hvc/hvc_dcc.c
index 3502a7bbb69e..809920d80a66 100644
--- a/drivers/tty/hvc/hvc_dcc.c
+++ b/drivers/tty/hvc/hvc_dcc.c
@@ -1,4 +1,4 @@
1/* Copyright (c) 2010, Code Aurora Forum. All rights reserved. 1/* Copyright (c) 2010, 2014 The Linux Foundation. All rights reserved.
2 * 2 *
3 * This program is free software; you can redistribute it and/or modify 3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and 4 * it under the terms of the GNU General Public License version 2 and
@@ -8,20 +8,11 @@
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details. 10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15 * 02110-1301, USA.
16 */ 11 */
17 12
18#include <linux/console.h>
19#include <linux/delay.h>
20#include <linux/err.h>
21#include <linux/init.h> 13#include <linux/init.h>
22#include <linux/moduleparam.h>
23#include <linux/types.h>
24 14
15#include <asm/dcc.h>
25#include <asm/processor.h> 16#include <asm/processor.h>
26 17
27#include "hvc_console.h" 18#include "hvc_console.h"
@@ -30,35 +21,6 @@
30#define DCC_STATUS_RX (1 << 30) 21#define DCC_STATUS_RX (1 << 30)
31#define DCC_STATUS_TX (1 << 29) 22#define DCC_STATUS_TX (1 << 29)
32 23
33static inline u32 __dcc_getstatus(void)
34{
35 u32 __ret;
36 asm volatile("mrc p14, 0, %0, c0, c1, 0 @ read comms ctrl reg"
37 : "=r" (__ret) : : "cc");
38
39 return __ret;
40}
41
42
43static inline char __dcc_getchar(void)
44{
45 char __c;
46
47 asm volatile("mrc p14, 0, %0, c0, c5, 0 @ read comms data reg"
48 : "=r" (__c));
49 isb();
50
51 return __c;
52}
53
54static inline void __dcc_putchar(char c)
55{
56 asm volatile("mcr p14, 0, %0, c0, c5, 0 @ write a char"
57 : /* no output register */
58 : "r" (c));
59 isb();
60}
61
62static int hvc_dcc_put_chars(uint32_t vt, const char *buf, int count) 24static int hvc_dcc_put_chars(uint32_t vt, const char *buf, int count)
63{ 25{
64 int i; 26 int i;
diff --git a/drivers/tty/hvc/hvc_tile.c b/drivers/tty/hvc/hvc_tile.c
index af8cdaa1dcb9..147d49e95db2 100644
--- a/drivers/tty/hvc/hvc_tile.c
+++ b/drivers/tty/hvc/hvc_tile.c
@@ -133,14 +133,14 @@ static int hvc_tile_probe(struct platform_device *pdev)
133 int tile_hvc_irq; 133 int tile_hvc_irq;
134 134
135 /* Create our IRQ and register it. */ 135 /* Create our IRQ and register it. */
136 tile_hvc_irq = create_irq(); 136 tile_hvc_irq = irq_alloc_hwirq(-1);
137 if (tile_hvc_irq < 0) 137 if (!tile_hvc_irq)
138 return -ENXIO; 138 return -ENXIO;
139 139
140 tile_irq_activate(tile_hvc_irq, TILE_IRQ_PERCPU); 140 tile_irq_activate(tile_hvc_irq, TILE_IRQ_PERCPU);
141 hp = hvc_alloc(0, tile_hvc_irq, &hvc_tile_get_put_ops, 128); 141 hp = hvc_alloc(0, tile_hvc_irq, &hvc_tile_get_put_ops, 128);
142 if (IS_ERR(hp)) { 142 if (IS_ERR(hp)) {
143 destroy_irq(tile_hvc_irq); 143 irq_free_hwirq(tile_hvc_irq);
144 return PTR_ERR(hp); 144 return PTR_ERR(hp);
145 } 145 }
146 dev_set_drvdata(&pdev->dev, hp); 146 dev_set_drvdata(&pdev->dev, hp);
@@ -155,7 +155,7 @@ static int hvc_tile_remove(struct platform_device *pdev)
155 155
156 rc = hvc_remove(hp); 156 rc = hvc_remove(hp);
157 if (rc == 0) 157 if (rc == 0)
158 destroy_irq(hp->data); 158 irq_free_hwirq(hp->data);
159 159
160 return rc; 160 return rc;
161} 161}
diff --git a/drivers/tty/n_hdlc.c b/drivers/tty/n_hdlc.c
index 1b2db9a3038c..644ddb841d9f 100644
--- a/drivers/tty/n_hdlc.c
+++ b/drivers/tty/n_hdlc.c
@@ -848,13 +848,11 @@ static struct n_hdlc *n_hdlc_alloc(void)
848{ 848{
849 struct n_hdlc_buf *buf; 849 struct n_hdlc_buf *buf;
850 int i; 850 int i;
851 struct n_hdlc *n_hdlc = kmalloc(sizeof(*n_hdlc), GFP_KERNEL); 851 struct n_hdlc *n_hdlc = kzalloc(sizeof(*n_hdlc), GFP_KERNEL);
852 852
853 if (!n_hdlc) 853 if (!n_hdlc)
854 return NULL; 854 return NULL;
855 855
856 memset(n_hdlc, 0, sizeof(*n_hdlc));
857
858 n_hdlc_buf_list_init(&n_hdlc->rx_free_buf_list); 856 n_hdlc_buf_list_init(&n_hdlc->rx_free_buf_list);
859 n_hdlc_buf_list_init(&n_hdlc->tx_free_buf_list); 857 n_hdlc_buf_list_init(&n_hdlc->tx_free_buf_list);
860 n_hdlc_buf_list_init(&n_hdlc->rx_buf_list); 858 n_hdlc_buf_list_init(&n_hdlc->rx_buf_list);
@@ -952,8 +950,6 @@ static char hdlc_register_ok[] __initdata =
952 KERN_INFO "N_HDLC line discipline registered.\n"; 950 KERN_INFO "N_HDLC line discipline registered.\n";
953static char hdlc_register_fail[] __initdata = 951static char hdlc_register_fail[] __initdata =
954 KERN_ERR "error registering line discipline: %d\n"; 952 KERN_ERR "error registering line discipline: %d\n";
955static char hdlc_init_fail[] __initdata =
956 KERN_INFO "N_HDLC: init failure %d\n";
957 953
958static int __init n_hdlc_init(void) 954static int __init n_hdlc_init(void)
959{ 955{
@@ -973,8 +969,6 @@ static int __init n_hdlc_init(void)
973 else 969 else
974 printk(hdlc_register_fail, status); 970 printk(hdlc_register_fail, status);
975 971
976 if (status)
977 printk(hdlc_init_fail, status);
978 return status; 972 return status;
979 973
980} /* end of init_module() */ 974} /* end of init_module() */
diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c
index fe9d129c8735..f95569dedc88 100644
--- a/drivers/tty/n_tty.c
+++ b/drivers/tty/n_tty.c
@@ -2041,7 +2041,7 @@ static int canon_copy_from_read_buf(struct tty_struct *tty,
2041 2041
2042 if (found) 2042 if (found)
2043 clear_bit(eol, ldata->read_flags); 2043 clear_bit(eol, ldata->read_flags);
2044 smp_mb__after_clear_bit(); 2044 smp_mb__after_atomic();
2045 ldata->read_tail += c; 2045 ldata->read_tail += c;
2046 2046
2047 if (found) { 2047 if (found) {
diff --git a/drivers/tty/serial/8250/8250_core.c b/drivers/tty/serial/8250/8250_core.c
index 2d4bd3929e50..27f7ad6b74c1 100644
--- a/drivers/tty/serial/8250/8250_core.c
+++ b/drivers/tty/serial/8250/8250_core.c
@@ -1926,13 +1926,8 @@ static void serial8250_put_poll_char(struct uart_port *port,
1926 wait_for_xmitr(up, BOTH_EMPTY); 1926 wait_for_xmitr(up, BOTH_EMPTY);
1927 /* 1927 /*
1928 * Send the character out. 1928 * Send the character out.
1929 * If a LF, also do CR...
1930 */ 1929 */
1931 serial_port_out(port, UART_TX, c); 1930 serial_port_out(port, UART_TX, c);
1932 if (c == 10) {
1933 wait_for_xmitr(up, BOTH_EMPTY);
1934 serial_port_out(port, UART_TX, 13);
1935 }
1936 1931
1937 /* 1932 /*
1938 * Finally, wait for transmitter to become empty 1933 * Finally, wait for transmitter to become empty
@@ -2338,9 +2333,11 @@ serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
2338 * the trigger, or the MCR RTS bit is cleared. In the case where 2333 * the trigger, or the MCR RTS bit is cleared. In the case where
2339 * the remote UART is not using CTS auto flow control, we must 2334 * the remote UART is not using CTS auto flow control, we must
2340 * have sufficient FIFO entries for the latency of the remote 2335 * have sufficient FIFO entries for the latency of the remote
2341 * UART to respond. IOW, at least 32 bytes of FIFO. 2336 * UART to respond. IOW, at least 32 bytes of FIFO. Also enable
2337 * AFE if hw flow control is supported
2342 */ 2338 */
2343 if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) { 2339 if ((up->capabilities & UART_CAP_AFE && (port->fifosize >= 32)) ||
2340 (port->flags & UPF_HARD_FLOW)) {
2344 up->mcr &= ~UART_MCR_AFE; 2341 up->mcr &= ~UART_MCR_AFE;
2345 if (termios->c_cflag & CRTSCTS) 2342 if (termios->c_cflag & CRTSCTS)
2346 up->mcr |= UART_MCR_AFE; 2343 up->mcr |= UART_MCR_AFE;
diff --git a/drivers/tty/serial/8250/8250_dma.c b/drivers/tty/serial/8250/8250_dma.c
index ab9096dc3849..148ffe4c232f 100644
--- a/drivers/tty/serial/8250/8250_dma.c
+++ b/drivers/tty/serial/8250/8250_dma.c
@@ -192,21 +192,28 @@ int serial8250_request_dma(struct uart_8250_port *p)
192 192
193 dma->rx_buf = dma_alloc_coherent(dma->rxchan->device->dev, dma->rx_size, 193 dma->rx_buf = dma_alloc_coherent(dma->rxchan->device->dev, dma->rx_size,
194 &dma->rx_addr, GFP_KERNEL); 194 &dma->rx_addr, GFP_KERNEL);
195 if (!dma->rx_buf) { 195 if (!dma->rx_buf)
196 dma_release_channel(dma->rxchan); 196 goto err;
197 dma_release_channel(dma->txchan);
198 return -ENOMEM;
199 }
200 197
201 /* TX buffer */ 198 /* TX buffer */
202 dma->tx_addr = dma_map_single(dma->txchan->device->dev, 199 dma->tx_addr = dma_map_single(dma->txchan->device->dev,
203 p->port.state->xmit.buf, 200 p->port.state->xmit.buf,
204 UART_XMIT_SIZE, 201 UART_XMIT_SIZE,
205 DMA_TO_DEVICE); 202 DMA_TO_DEVICE);
203 if (dma_mapping_error(dma->txchan->device->dev, dma->tx_addr)) {
204 dma_free_coherent(dma->rxchan->device->dev, dma->rx_size,
205 dma->rx_buf, dma->rx_addr);
206 goto err;
207 }
206 208
207 dev_dbg_ratelimited(p->port.dev, "got both dma channels\n"); 209 dev_dbg_ratelimited(p->port.dev, "got both dma channels\n");
208 210
209 return 0; 211 return 0;
212err:
213 dma_release_channel(dma->rxchan);
214 dma_release_channel(dma->txchan);
215
216 return -ENOMEM;
210} 217}
211EXPORT_SYMBOL_GPL(serial8250_request_dma); 218EXPORT_SYMBOL_GPL(serial8250_request_dma);
212 219
diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index ed3113576740..51b307aab75e 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -62,6 +62,70 @@ struct dw8250_data {
62 struct uart_8250_dma dma; 62 struct uart_8250_dma dma;
63}; 63};
64 64
65struct dw8250_acpi_desc {
66 void (*set_termios)(struct uart_port *p, struct ktermios *termios,
67 struct ktermios *old);
68};
69
70#define BYT_PRV_CLK 0x800
71#define BYT_PRV_CLK_EN (1 << 0)
72#define BYT_PRV_CLK_M_VAL_SHIFT 1
73#define BYT_PRV_CLK_N_VAL_SHIFT 16
74#define BYT_PRV_CLK_UPDATE (1 << 31)
75
76static void byt_set_termios(struct uart_port *p, struct ktermios *termios,
77 struct ktermios *old)
78{
79 unsigned int baud = tty_termios_baud_rate(termios);
80 unsigned int m, n;
81 u32 reg;
82
83 /*
84 * For baud rates 0.5M, 1M, 1.5M, 2M, 2.5M, 3M, 3.5M and 4M the
85 * dividers must be adjusted.
86 *
87 * uartclk = (m / n) * 100 MHz, where m <= n
88 */
89 switch (baud) {
90 case 500000:
91 case 1000000:
92 case 2000000:
93 case 4000000:
94 m = 64;
95 n = 100;
96 p->uartclk = 64000000;
97 break;
98 case 3500000:
99 m = 56;
100 n = 100;
101 p->uartclk = 56000000;
102 break;
103 case 1500000:
104 case 3000000:
105 m = 48;
106 n = 100;
107 p->uartclk = 48000000;
108 break;
109 case 2500000:
110 m = 40;
111 n = 100;
112 p->uartclk = 40000000;
113 break;
114 default:
115 m = 2304;
116 n = 3125;
117 p->uartclk = 73728000;
118 }
119
120 /* Reset the clock */
121 reg = (m << BYT_PRV_CLK_M_VAL_SHIFT) | (n << BYT_PRV_CLK_N_VAL_SHIFT);
122 writel(reg, p->membase + BYT_PRV_CLK);
123 reg |= BYT_PRV_CLK_EN | BYT_PRV_CLK_UPDATE;
124 writel(reg, p->membase + BYT_PRV_CLK);
125
126 serial8250_do_set_termios(p, termios, old);
127}
128
65static inline int dw8250_modify_msr(struct uart_port *p, int offset, int value) 129static inline int dw8250_modify_msr(struct uart_port *p, int offset, int value)
66{ 130{
67 struct dw8250_data *d = p->private_data; 131 struct dw8250_data *d = p->private_data;
@@ -278,6 +342,7 @@ static int dw8250_probe_acpi(struct uart_8250_port *up,
278{ 342{
279 const struct acpi_device_id *id; 343 const struct acpi_device_id *id;
280 struct uart_port *p = &up->port; 344 struct uart_port *p = &up->port;
345 struct dw8250_acpi_desc *acpi_desc;
281 346
282 dw8250_setup_port(up); 347 dw8250_setup_port(up);
283 348
@@ -290,14 +355,18 @@ static int dw8250_probe_acpi(struct uart_8250_port *up,
290 p->serial_out = dw8250_serial_out32; 355 p->serial_out = dw8250_serial_out32;
291 p->regshift = 2; 356 p->regshift = 2;
292 357
293 if (!p->uartclk)
294 p->uartclk = (unsigned int)id->driver_data;
295
296 up->dma = &data->dma; 358 up->dma = &data->dma;
297 359
298 up->dma->rxconf.src_maxburst = p->fifosize / 4; 360 up->dma->rxconf.src_maxburst = p->fifosize / 4;
299 up->dma->txconf.dst_maxburst = p->fifosize / 4; 361 up->dma->txconf.dst_maxburst = p->fifosize / 4;
300 362
363 acpi_desc = (struct dw8250_acpi_desc *)id->driver_data;
364 if (!acpi_desc)
365 return 0;
366
367 if (acpi_desc->set_termios)
368 p->set_termios = acpi_desc->set_termios;
369
301 return 0; 370 return 0;
302} 371}
303 372
@@ -445,12 +514,16 @@ static const struct of_device_id dw8250_of_match[] = {
445}; 514};
446MODULE_DEVICE_TABLE(of, dw8250_of_match); 515MODULE_DEVICE_TABLE(of, dw8250_of_match);
447 516
517static struct dw8250_acpi_desc byt_8250_desc = {
518 .set_termios = byt_set_termios,
519};
520
448static const struct acpi_device_id dw8250_acpi_match[] = { 521static const struct acpi_device_id dw8250_acpi_match[] = {
449 { "INT33C4", 0 }, 522 { "INT33C4", 0 },
450 { "INT33C5", 0 }, 523 { "INT33C5", 0 },
451 { "INT3434", 0 }, 524 { "INT3434", 0 },
452 { "INT3435", 0 }, 525 { "INT3435", 0 },
453 { "80860F0A", 0 }, 526 { "80860F0A", (kernel_ulong_t)&byt_8250_desc},
454 { }, 527 { },
455}; 528};
456MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match); 529MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match);
diff --git a/drivers/tty/serial/8250/8250_early.c b/drivers/tty/serial/8250/8250_early.c
index c100d6343d50..cfef801a49d4 100644
--- a/drivers/tty/serial/8250/8250_early.c
+++ b/drivers/tty/serial/8250/8250_early.c
@@ -35,18 +35,8 @@
35#include <linux/serial_8250.h> 35#include <linux/serial_8250.h>
36#include <asm/io.h> 36#include <asm/io.h>
37#include <asm/serial.h> 37#include <asm/serial.h>
38#ifdef CONFIG_FIX_EARLYCON_MEM
39#include <asm/pgtable.h>
40#include <asm/fixmap.h>
41#endif
42 38
43struct early_serial8250_device { 39static struct earlycon_device *early_device;
44 struct uart_port port;
45 char options[16]; /* e.g., 115200n8 */
46 unsigned int baud;
47};
48
49static struct early_serial8250_device early_device;
50 40
51unsigned int __weak __init serial8250_early_in(struct uart_port *port, int offset) 41unsigned int __weak __init serial8250_early_in(struct uart_port *port, int offset)
52{ 42{
@@ -100,7 +90,7 @@ static void __init serial_putc(struct uart_port *port, int c)
100static void __init early_serial8250_write(struct console *console, 90static void __init early_serial8250_write(struct console *console,
101 const char *s, unsigned int count) 91 const char *s, unsigned int count)
102{ 92{
103 struct uart_port *port = &early_device.port; 93 struct uart_port *port = &early_device->port;
104 unsigned int ier; 94 unsigned int ier;
105 95
106 /* Save the IER and disable interrupts */ 96 /* Save the IER and disable interrupts */
@@ -129,7 +119,7 @@ static unsigned int __init probe_baud(struct uart_port *port)
129 return (port->uartclk / 16) / quot; 119 return (port->uartclk / 16) / quot;
130} 120}
131 121
132static void __init init_port(struct early_serial8250_device *device) 122static void __init init_port(struct earlycon_device *device)
133{ 123{
134 struct uart_port *port = &device->port; 124 struct uart_port *port = &device->port;
135 unsigned int divisor; 125 unsigned int divisor;
@@ -148,128 +138,42 @@ static void __init init_port(struct early_serial8250_device *device)
148 serial8250_early_out(port, UART_LCR, c & ~UART_LCR_DLAB); 138 serial8250_early_out(port, UART_LCR, c & ~UART_LCR_DLAB);
149} 139}
150 140
151static int __init parse_options(struct early_serial8250_device *device, 141static int __init early_serial8250_setup(struct earlycon_device *device,
152 char *options) 142 const char *options)
153{ 143{
154 struct uart_port *port = &device->port; 144 if (!(device->port.membase || device->port.iobase))
155 int mmio, mmio32, length;
156
157 if (!options)
158 return -ENODEV;
159
160 port->uartclk = BASE_BAUD * 16;
161
162 mmio = !strncmp(options, "mmio,", 5);
163 mmio32 = !strncmp(options, "mmio32,", 7);
164 if (mmio || mmio32) {
165 port->iotype = (mmio ? UPIO_MEM : UPIO_MEM32);
166 port->mapbase = simple_strtoul(options + (mmio ? 5 : 7),
167 &options, 0);
168 if (mmio32)
169 port->regshift = 2;
170#ifdef CONFIG_FIX_EARLYCON_MEM
171 set_fixmap_nocache(FIX_EARLYCON_MEM_BASE,
172 port->mapbase & PAGE_MASK);
173 port->membase =
174 (void __iomem *)__fix_to_virt(FIX_EARLYCON_MEM_BASE);
175 port->membase += port->mapbase & ~PAGE_MASK;
176#else
177 port->membase = ioremap_nocache(port->mapbase, 64);
178 if (!port->membase) {
179 printk(KERN_ERR "%s: Couldn't ioremap 0x%llx\n",
180 __func__,
181 (unsigned long long) port->mapbase);
182 return -ENOMEM;
183 }
184#endif
185 } else if (!strncmp(options, "io,", 3)) {
186 port->iotype = UPIO_PORT;
187 port->iobase = simple_strtoul(options + 3, &options, 0);
188 mmio = 0;
189 } else
190 return -EINVAL;
191
192 options = strchr(options, ',');
193 if (options) {
194 options++;
195 device->baud = simple_strtoul(options, NULL, 0);
196 length = min(strcspn(options, " ") + 1,
197 (size_t)(sizeof(device->options)));
198 strlcpy(device->options, options, length);
199 } else {
200 device->baud = probe_baud(port);
201 snprintf(device->options, sizeof(device->options), "%u",
202 device->baud);
203 }
204
205 if (mmio || mmio32)
206 printk(KERN_INFO
207 "Early serial console at MMIO%s 0x%llx (options '%s')\n",
208 mmio32 ? "32" : "",
209 (unsigned long long)port->mapbase,
210 device->options);
211 else
212 printk(KERN_INFO
213 "Early serial console at I/O port 0x%lx (options '%s')\n",
214 port->iobase,
215 device->options);
216
217 return 0;
218}
219
220static struct console early_serial8250_console __initdata = {
221 .name = "uart",
222 .write = early_serial8250_write,
223 .flags = CON_PRINTBUFFER | CON_BOOT,
224 .index = -1,
225};
226
227static int __init early_serial8250_setup(char *options)
228{
229 struct early_serial8250_device *device = &early_device;
230 int err;
231
232 if (device->port.membase || device->port.iobase)
233 return 0; 145 return 0;
234 146
235 err = parse_options(device, options); 147 if (!device->baud)
236 if (err < 0) 148 device->baud = probe_baud(&device->port);
237 return err;
238 149
239 init_port(device); 150 init_port(device);
151
152 early_device = device;
153 device->con->write = early_serial8250_write;
240 return 0; 154 return 0;
241} 155}
156EARLYCON_DECLARE(uart8250, early_serial8250_setup);
157EARLYCON_DECLARE(uart, early_serial8250_setup);
242 158
243int __init setup_early_serial8250_console(char *cmdline) 159int __init setup_early_serial8250_console(char *cmdline)
244{ 160{
245 char *options; 161 char match[] = "uart8250";
246 int err;
247 162
248 options = strstr(cmdline, "uart8250,"); 163 if (cmdline && cmdline[4] == ',')
249 if (!options) { 164 match[4] = '\0';
250 options = strstr(cmdline, "uart,");
251 if (!options)
252 return 0;
253 }
254 165
255 options = strchr(cmdline, ',') + 1; 166 return setup_earlycon(cmdline, match, early_serial8250_setup);
256 err = early_serial8250_setup(options);
257 if (err < 0)
258 return err;
259
260 register_console(&early_serial8250_console);
261
262 return 0;
263} 167}
264 168
265int serial8250_find_port_for_earlycon(void) 169int serial8250_find_port_for_earlycon(void)
266{ 170{
267 struct early_serial8250_device *device = &early_device; 171 struct earlycon_device *device = early_device;
268 struct uart_port *port = &device->port; 172 struct uart_port *port = device ? &device->port : NULL;
269 int line; 173 int line;
270 int ret; 174 int ret;
271 175
272 if (!device->port.membase && !device->port.iobase) 176 if (!port || (!port->membase && !port->iobase))
273 return -ENODEV; 177 return -ENODEV;
274 178
275 line = serial8250_find_port(port); 179 line = serial8250_find_port(port);
@@ -284,5 +188,3 @@ int serial8250_find_port_for_earlycon(void)
284 188
285 return ret; 189 return ret;
286} 190}
287
288early_param("earlycon", setup_early_serial8250_console);
diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c
index b14bcba96c25..33137b3ba94d 100644
--- a/drivers/tty/serial/8250/8250_pci.c
+++ b/drivers/tty/serial/8250/8250_pci.c
@@ -1753,6 +1753,8 @@ pci_wch_ch353_setup(struct serial_private *priv,
1753#define PCI_VENDOR_ID_ADVANTECH 0x13fe 1753#define PCI_VENDOR_ID_ADVANTECH 0x13fe
1754#define PCI_DEVICE_ID_INTEL_CE4100_UART 0x2e66 1754#define PCI_DEVICE_ID_INTEL_CE4100_UART 0x2e66
1755#define PCI_DEVICE_ID_ADVANTECH_PCI3620 0x3620 1755#define PCI_DEVICE_ID_ADVANTECH_PCI3620 0x3620
1756#define PCI_DEVICE_ID_ADVANTECH_PCI3618 0x3618
1757#define PCI_DEVICE_ID_ADVANTECH_PCIf618 0xf618
1756#define PCI_DEVICE_ID_TITAN_200I 0x8028 1758#define PCI_DEVICE_ID_TITAN_200I 0x8028
1757#define PCI_DEVICE_ID_TITAN_400I 0x8048 1759#define PCI_DEVICE_ID_TITAN_400I 0x8048
1758#define PCI_DEVICE_ID_TITAN_800I 0x8088 1760#define PCI_DEVICE_ID_TITAN_800I 0x8088
@@ -1778,6 +1780,7 @@ pci_wch_ch353_setup(struct serial_private *priv,
1778#define PCI_DEVICE_ID_WCH_CH352_2S 0x3253 1780#define PCI_DEVICE_ID_WCH_CH352_2S 0x3253
1779#define PCI_DEVICE_ID_WCH_CH353_4S 0x3453 1781#define PCI_DEVICE_ID_WCH_CH353_4S 0x3453
1780#define PCI_DEVICE_ID_WCH_CH353_2S1PF 0x5046 1782#define PCI_DEVICE_ID_WCH_CH353_2S1PF 0x5046
1783#define PCI_DEVICE_ID_WCH_CH353_1S1P 0x5053
1781#define PCI_DEVICE_ID_WCH_CH353_2S1P 0x7053 1784#define PCI_DEVICE_ID_WCH_CH353_2S1P 0x7053
1782#define PCI_VENDOR_ID_AGESTAR 0x5372 1785#define PCI_VENDOR_ID_AGESTAR 0x5372
1783#define PCI_DEVICE_ID_AGESTAR_9375 0x6872 1786#define PCI_DEVICE_ID_AGESTAR_9375 0x6872
@@ -2410,6 +2413,14 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
2410 .subdevice = PCI_ANY_ID, 2413 .subdevice = PCI_ANY_ID,
2411 .setup = pci_omegapci_setup, 2414 .setup = pci_omegapci_setup,
2412 }, 2415 },
2416 /* WCH CH353 1S1P card (16550 clone) */
2417 {
2418 .vendor = PCI_VENDOR_ID_WCH,
2419 .device = PCI_DEVICE_ID_WCH_CH353_1S1P,
2420 .subvendor = PCI_ANY_ID,
2421 .subdevice = PCI_ANY_ID,
2422 .setup = pci_wch_ch353_setup,
2423 },
2413 /* WCH CH353 2S1P card (16550 clone) */ 2424 /* WCH CH353 2S1P card (16550 clone) */
2414 { 2425 {
2415 .vendor = PCI_VENDOR_ID_WCH, 2426 .vendor = PCI_VENDOR_ID_WCH,
@@ -3526,6 +3537,7 @@ static const struct pci_device_id blacklist[] = {
3526 3537
3527 /* multi-io cards handled by parport_serial */ 3538 /* multi-io cards handled by parport_serial */
3528 { PCI_DEVICE(0x4348, 0x7053), }, /* WCH CH353 2S1P */ 3539 { PCI_DEVICE(0x4348, 0x7053), }, /* WCH CH353 2S1P */
3540 { PCI_DEVICE(0x4348, 0x5053), }, /* WCH CH353 1S1P */
3529}; 3541};
3530 3542
3531/* 3543/*
@@ -3880,6 +3892,13 @@ static struct pci_device_id serial_pci_tbl[] = {
3880 { PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3620, 3892 { PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3620,
3881 PCI_DEVICE_ID_ADVANTECH_PCI3620, 0x0001, 0, 0, 3893 PCI_DEVICE_ID_ADVANTECH_PCI3620, 0x0001, 0, 0,
3882 pbn_b2_8_921600 }, 3894 pbn_b2_8_921600 },
3895 /* Advantech also use 0x3618 and 0xf618 */
3896 { PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3618,
3897 PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
3898 pbn_b0_4_921600 },
3899 { PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCIf618,
3900 PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
3901 pbn_b0_4_921600 },
3883 { PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960, 3902 { PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
3884 PCI_SUBVENDOR_ID_CONNECT_TECH, 3903 PCI_SUBVENDOR_ID_CONNECT_TECH,
3885 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0, 3904 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0,
diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig
index 23329918f229..349ee598b34c 100644
--- a/drivers/tty/serial/8250/Kconfig
+++ b/drivers/tty/serial/8250/Kconfig
@@ -61,6 +61,7 @@ config SERIAL_8250_CONSOLE
61 bool "Console on 8250/16550 and compatible serial port" 61 bool "Console on 8250/16550 and compatible serial port"
62 depends on SERIAL_8250=y 62 depends on SERIAL_8250=y
63 select SERIAL_CORE_CONSOLE 63 select SERIAL_CORE_CONSOLE
64 select SERIAL_EARLYCON
64 ---help--- 65 ---help---
65 If you say Y here, it will be possible to use a serial port as the 66 If you say Y here, it will be possible to use a serial port as the
66 system console (the system console is the device which receives all 67 system console (the system console is the device which receives all
@@ -90,11 +91,6 @@ config SERIAL_8250_CONSOLE
90 91
91 If unsure, say N. 92 If unsure, say N.
92 93
93config FIX_EARLYCON_MEM
94 bool
95 depends on X86
96 default y
97
98config SERIAL_8250_GSC 94config SERIAL_8250_GSC
99 tristate 95 tristate
100 depends on SERIAL_8250 && GSC 96 depends on SERIAL_8250 && GSC
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index 5d9b01aa54f4..fb57159bad3a 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -7,6 +7,13 @@ if TTY
7menu "Serial drivers" 7menu "Serial drivers"
8 depends on HAS_IOMEM 8 depends on HAS_IOMEM
9 9
10config SERIAL_EARLYCON
11 bool
12 help
13 Support for early consoles with the earlycon parameter. This enables
14 the console before standard serial driver is probed. The console is
15 enabled when early_param is processed.
16
10source "drivers/tty/serial/8250/Kconfig" 17source "drivers/tty/serial/8250/Kconfig"
11 18
12comment "Non-8250 serial port support" 19comment "Non-8250 serial port support"
@@ -53,6 +60,7 @@ config SERIAL_AMBA_PL011_CONSOLE
53 bool "Support for console on AMBA serial port" 60 bool "Support for console on AMBA serial port"
54 depends on SERIAL_AMBA_PL011=y 61 depends on SERIAL_AMBA_PL011=y
55 select SERIAL_CORE_CONSOLE 62 select SERIAL_CORE_CONSOLE
63 select SERIAL_EARLYCON
56 ---help--- 64 ---help---
57 Say Y here if you wish to use an AMBA PrimeCell UART as the system 65 Say Y here if you wish to use an AMBA PrimeCell UART as the system
58 console (the system console is the device which receives all kernel 66 console (the system console is the device which receives all kernel
@@ -65,6 +73,18 @@ config SERIAL_AMBA_PL011_CONSOLE
65 your boot loader (lilo or loadlin) about how to pass options to the 73 your boot loader (lilo or loadlin) about how to pass options to the
66 kernel at boot time.) 74 kernel at boot time.)
67 75
76config SERIAL_EARLYCON_ARM_SEMIHOST
77 bool "Early console using ARM semihosting"
78 depends on ARM64 || ARM
79 select SERIAL_CORE
80 select SERIAL_CORE_CONSOLE
81 select SERIAL_EARLYCON
82 help
83 Support for early debug console using ARM semihosting. This enables
84 the console before standard serial driver is probed. This is enabled
85 with "earlycon=smh" on the kernel command line. The console is
86 enabled when early_param is processed.
87
68config SERIAL_SB1250_DUART 88config SERIAL_SB1250_DUART
69 tristate "BCM1xxx on-chip DUART serial support" 89 tristate "BCM1xxx on-chip DUART serial support"
70 depends on SIBYTE_SB1xxx_SOC=y 90 depends on SIBYTE_SB1xxx_SOC=y
@@ -97,6 +117,7 @@ config SERIAL_ATMEL
97 bool "AT91 / AT32 on-chip serial port support" 117 bool "AT91 / AT32 on-chip serial port support"
98 depends on ARCH_AT91 || AVR32 118 depends on ARCH_AT91 || AVR32
99 select SERIAL_CORE 119 select SERIAL_CORE
120 select SERIAL_MCTRL_GPIO
100 help 121 help
101 This enables the driver for the on-chip UARTs of the Atmel 122 This enables the driver for the on-chip UARTs of the Atmel
102 AT91 and AT32 processors. 123 AT91 and AT32 processors.
@@ -1160,6 +1181,16 @@ config SERIAL_SCCNXP_CONSOLE
1160 help 1181 help
1161 Support for console on SCCNXP serial ports. 1182 Support for console on SCCNXP serial ports.
1162 1183
1184config SERIAL_SC16IS7XX
1185 tristate "SC16IS7xx serial support"
1186 depends on I2C
1187 select SERIAL_CORE
1188 select REGMAP_I2C if I2C
1189 help
1190 This selects support for SC16IS7xx serial ports.
1191 Supported ICs are SC16IS740, SC16IS741, SC16IS750, SC16IS752,
1192 SC16IS760 and SC16IS762.
1193
1163config SERIAL_BFIN_SPORT 1194config SERIAL_BFIN_SPORT
1164 tristate "Blackfin SPORT emulate UART" 1195 tristate "Blackfin SPORT emulate UART"
1165 depends on BLACKFIN 1196 depends on BLACKFIN
@@ -1323,7 +1354,7 @@ config SERIAL_IFX6X60
1323 1354
1324config SERIAL_PCH_UART 1355config SERIAL_PCH_UART
1325 tristate "Intel EG20T PCH/LAPIS Semicon IOH(ML7213/ML7223/ML7831) UART" 1356 tristate "Intel EG20T PCH/LAPIS Semicon IOH(ML7213/ML7223/ML7831) UART"
1326 depends on PCI 1357 depends on PCI && (X86_32 || COMPILE_TEST)
1327 select SERIAL_CORE 1358 select SERIAL_CORE
1328 help 1359 help
1329 This driver is for PCH(Platform controller Hub) UART of Intel EG20T 1360 This driver is for PCH(Platform controller Hub) UART of Intel EG20T
@@ -1369,18 +1400,19 @@ config SERIAL_MXS_AUART_CONSOLE
1369 Enable a MXS AUART port to be the system console. 1400 Enable a MXS AUART port to be the system console.
1370 1401
1371config SERIAL_XILINX_PS_UART 1402config SERIAL_XILINX_PS_UART
1372 tristate "Xilinx PS UART support" 1403 tristate "Cadence (Xilinx Zynq) UART support"
1373 depends on OF 1404 depends on OF
1374 select SERIAL_CORE 1405 select SERIAL_CORE
1375 help 1406 help
1376 This driver supports the Xilinx PS UART port. 1407 This driver supports the Cadence UART. It is found e.g. in Xilinx
1408 Zynq.
1377 1409
1378config SERIAL_XILINX_PS_UART_CONSOLE 1410config SERIAL_XILINX_PS_UART_CONSOLE
1379 bool "Xilinx PS UART console support" 1411 bool "Cadence UART console support"
1380 depends on SERIAL_XILINX_PS_UART=y 1412 depends on SERIAL_XILINX_PS_UART=y
1381 select SERIAL_CORE_CONSOLE 1413 select SERIAL_CORE_CONSOLE
1382 help 1414 help
1383 Enable a Xilinx PS UART port to be the system console. 1415 Enable a Cadence UART port to be the system console.
1384 1416
1385config SERIAL_AR933X 1417config SERIAL_AR933X
1386 tristate "AR933X serial port support" 1418 tristate "AR933X serial port support"
@@ -1479,6 +1511,7 @@ config SERIAL_RP2_NR_UARTS
1479 1511
1480config SERIAL_FSL_LPUART 1512config SERIAL_FSL_LPUART
1481 tristate "Freescale lpuart serial port support" 1513 tristate "Freescale lpuart serial port support"
1514 depends on HAS_DMA
1482 select SERIAL_CORE 1515 select SERIAL_CORE
1483 help 1516 help
1484 Support for the on-chip lpuart on some Freescale SOCs. 1517 Support for the on-chip lpuart on some Freescale SOCs.
@@ -1508,6 +1541,20 @@ config SERIAL_ST_ASC_CONSOLE
1508 depends on SERIAL_ST_ASC=y 1541 depends on SERIAL_ST_ASC=y
1509 select SERIAL_CORE_CONSOLE 1542 select SERIAL_CORE_CONSOLE
1510 1543
1544config SERIAL_MEN_Z135
1545 tristate "MEN 16z135 Support"
1546 select SERIAL_CORE
1547 depends on MCB
1548 help
1549 Say yes here to enable support for the MEN 16z135 High Speed UART IP-Core
1550 on a MCB carrier.
1551
1552 This driver can also be build as a module. If so, the module will be called
1553 men_z135_uart.ko
1554
1511endmenu 1555endmenu
1512 1556
1557config SERIAL_MCTRL_GPIO
1558 tristate
1559
1513endif # TTY 1560endif # TTY
diff --git a/drivers/tty/serial/Makefile b/drivers/tty/serial/Makefile
index 3680854fef41..0080cc362e09 100644
--- a/drivers/tty/serial/Makefile
+++ b/drivers/tty/serial/Makefile
@@ -5,6 +5,9 @@
5obj-$(CONFIG_SERIAL_CORE) += serial_core.o 5obj-$(CONFIG_SERIAL_CORE) += serial_core.o
6obj-$(CONFIG_SERIAL_21285) += 21285.o 6obj-$(CONFIG_SERIAL_21285) += 21285.o
7 7
8obj-$(CONFIG_SERIAL_EARLYCON) += earlycon.o
9obj-$(CONFIG_SERIAL_EARLYCON_ARM_SEMIHOST) += earlycon-arm-semihost.o
10
8# These Sparc drivers have to appear before others such as 8250 11# These Sparc drivers have to appear before others such as 8250
9# which share ttySx minor node space. Otherwise console device 12# which share ttySx minor node space. Otherwise console device
10# names change and other unplesantries. 13# names change and other unplesantries.
@@ -48,6 +51,7 @@ obj-$(CONFIG_SERIAL_MPSC) += mpsc.o
48obj-$(CONFIG_SERIAL_SB1250_DUART) += sb1250-duart.o 51obj-$(CONFIG_SERIAL_SB1250_DUART) += sb1250-duart.o
49obj-$(CONFIG_ETRAX_SERIAL) += crisv10.o 52obj-$(CONFIG_ETRAX_SERIAL) += crisv10.o
50obj-$(CONFIG_SERIAL_SCCNXP) += sccnxp.o 53obj-$(CONFIG_SERIAL_SCCNXP) += sccnxp.o
54obj-$(CONFIG_SERIAL_SC16IS7XX) += sc16is7xx.o
51obj-$(CONFIG_SERIAL_JSM) += jsm/ 55obj-$(CONFIG_SERIAL_JSM) += jsm/
52obj-$(CONFIG_SERIAL_TXX9) += serial_txx9.o 56obj-$(CONFIG_SERIAL_TXX9) += serial_txx9.o
53obj-$(CONFIG_SERIAL_VR41XX) += vr41xx_siu.o 57obj-$(CONFIG_SERIAL_VR41XX) += vr41xx_siu.o
@@ -87,3 +91,7 @@ obj-$(CONFIG_SERIAL_EFM32_UART) += efm32-uart.o
87obj-$(CONFIG_SERIAL_ARC) += arc_uart.o 91obj-$(CONFIG_SERIAL_ARC) += arc_uart.o
88obj-$(CONFIG_SERIAL_RP2) += rp2.o 92obj-$(CONFIG_SERIAL_RP2) += rp2.o
89obj-$(CONFIG_SERIAL_FSL_LPUART) += fsl_lpuart.o 93obj-$(CONFIG_SERIAL_FSL_LPUART) += fsl_lpuart.o
94obj-$(CONFIG_SERIAL_MEN_Z135) += men_z135_uart.o
95
96# GPIOLIB helpers for modem control lines
97obj-$(CONFIG_SERIAL_MCTRL_GPIO) += serial_mctrl_gpio.o
diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c
index dacf0a09ab24..908a6e3142a2 100644
--- a/drivers/tty/serial/amba-pl011.c
+++ b/drivers/tty/serial/amba-pl011.c
@@ -303,7 +303,7 @@ static void pl011_dma_probe_initcall(struct device *dev, struct uart_amba_port *
303 303
304 /* Optionally make use of an RX channel as well */ 304 /* Optionally make use of an RX channel as well */
305 chan = dma_request_slave_channel(dev, "rx"); 305 chan = dma_request_slave_channel(dev, "rx");
306 306
307 if (!chan && plat->dma_rx_param) { 307 if (!chan && plat->dma_rx_param) {
308 chan = dma_request_channel(mask, plat->dma_filter, plat->dma_rx_param); 308 chan = dma_request_channel(mask, plat->dma_filter, plat->dma_rx_param);
309 309
@@ -2045,6 +2045,35 @@ static struct console amba_console = {
2045}; 2045};
2046 2046
2047#define AMBA_CONSOLE (&amba_console) 2047#define AMBA_CONSOLE (&amba_console)
2048
2049static void pl011_putc(struct uart_port *port, int c)
2050{
2051 while (readl(port->membase + UART01x_FR) & UART01x_FR_TXFF)
2052 ;
2053 writeb(c, port->membase + UART01x_DR);
2054 while (readl(port->membase + UART01x_FR) & UART01x_FR_BUSY)
2055 ;
2056}
2057
2058static void pl011_early_write(struct console *con, const char *s, unsigned n)
2059{
2060 struct earlycon_device *dev = con->data;
2061
2062 uart_console_write(&dev->port, s, n, pl011_putc);
2063}
2064
2065static int __init pl011_early_console_setup(struct earlycon_device *device,
2066 const char *opt)
2067{
2068 if (!device->port.membase)
2069 return -ENODEV;
2070
2071 device->con->write = pl011_early_write;
2072 return 0;
2073}
2074EARLYCON_DECLARE(pl011, pl011_early_console_setup);
2075OF_EARLYCON_DECLARE(pl011, "arm,pl011", pl011_early_console_setup);
2076
2048#else 2077#else
2049#define AMBA_CONSOLE NULL 2078#define AMBA_CONSOLE NULL
2050#endif 2079#endif
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index 53eeea13ff16..3fceae099c44 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -43,6 +43,9 @@
43#include <linux/platform_data/atmel.h> 43#include <linux/platform_data/atmel.h>
44#include <linux/timer.h> 44#include <linux/timer.h>
45#include <linux/gpio.h> 45#include <linux/gpio.h>
46#include <linux/gpio/consumer.h>
47#include <linux/err.h>
48#include <linux/irq.h>
46 49
47#include <asm/io.h> 50#include <asm/io.h>
48#include <asm/ioctls.h> 51#include <asm/ioctls.h>
@@ -57,6 +60,8 @@
57 60
58#include <linux/serial_core.h> 61#include <linux/serial_core.h>
59 62
63#include "serial_mctrl_gpio.h"
64
60static void atmel_start_rx(struct uart_port *port); 65static void atmel_start_rx(struct uart_port *port);
61static void atmel_stop_rx(struct uart_port *port); 66static void atmel_stop_rx(struct uart_port *port);
62 67
@@ -162,8 +167,10 @@ struct atmel_uart_port {
162 struct circ_buf rx_ring; 167 struct circ_buf rx_ring;
163 168
164 struct serial_rs485 rs485; /* rs485 settings */ 169 struct serial_rs485 rs485; /* rs485 settings */
165 int rts_gpio; /* optional RTS GPIO */ 170 struct mctrl_gpios *gpios;
171 int gpio_irq[UART_GPIO_MAX];
166 unsigned int tx_done_mask; 172 unsigned int tx_done_mask;
173 bool ms_irq_enabled;
167 bool is_usart; /* usart or uart */ 174 bool is_usart; /* usart or uart */
168 struct timer_list uart_timer; /* uart timer */ 175 struct timer_list uart_timer; /* uart timer */
169 int (*prepare_rx)(struct uart_port *port); 176 int (*prepare_rx)(struct uart_port *port);
@@ -237,6 +244,50 @@ static bool atmel_use_dma_rx(struct uart_port *port)
237 return atmel_port->use_dma_rx; 244 return atmel_port->use_dma_rx;
238} 245}
239 246
247static unsigned int atmel_get_lines_status(struct uart_port *port)
248{
249 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
250 unsigned int status, ret = 0;
251
252 status = UART_GET_CSR(port);
253
254 mctrl_gpio_get(atmel_port->gpios, &ret);
255
256 if (!IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(atmel_port->gpios,
257 UART_GPIO_CTS))) {
258 if (ret & TIOCM_CTS)
259 status &= ~ATMEL_US_CTS;
260 else
261 status |= ATMEL_US_CTS;
262 }
263
264 if (!IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(atmel_port->gpios,
265 UART_GPIO_DSR))) {
266 if (ret & TIOCM_DSR)
267 status &= ~ATMEL_US_DSR;
268 else
269 status |= ATMEL_US_DSR;
270 }
271
272 if (!IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(atmel_port->gpios,
273 UART_GPIO_RI))) {
274 if (ret & TIOCM_RI)
275 status &= ~ATMEL_US_RI;
276 else
277 status |= ATMEL_US_RI;
278 }
279
280 if (!IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(atmel_port->gpios,
281 UART_GPIO_DCD))) {
282 if (ret & TIOCM_CD)
283 status &= ~ATMEL_US_DCD;
284 else
285 status |= ATMEL_US_DCD;
286 }
287
288 return status;
289}
290
240/* Enable or disable the rs485 support */ 291/* Enable or disable the rs485 support */
241void atmel_config_rs485(struct uart_port *port, struct serial_rs485 *rs485conf) 292void atmel_config_rs485(struct uart_port *port, struct serial_rs485 *rs485conf)
242{ 293{
@@ -296,17 +347,6 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
296 unsigned int mode; 347 unsigned int mode;
297 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); 348 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
298 349
299 /*
300 * AT91RM9200 Errata #39: RTS0 is not internally connected
301 * to PA21. We need to drive the pin as a GPIO.
302 */
303 if (gpio_is_valid(atmel_port->rts_gpio)) {
304 if (mctrl & TIOCM_RTS)
305 gpio_set_value(atmel_port->rts_gpio, 0);
306 else
307 gpio_set_value(atmel_port->rts_gpio, 1);
308 }
309
310 if (mctrl & TIOCM_RTS) 350 if (mctrl & TIOCM_RTS)
311 control |= ATMEL_US_RTSEN; 351 control |= ATMEL_US_RTSEN;
312 else 352 else
@@ -319,6 +359,8 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
319 359
320 UART_PUT_CR(port, control); 360 UART_PUT_CR(port, control);
321 361
362 mctrl_gpio_set(atmel_port->gpios, mctrl);
363
322 /* Local loopback mode? */ 364 /* Local loopback mode? */
323 mode = UART_GET_MR(port) & ~ATMEL_US_CHMODE; 365 mode = UART_GET_MR(port) & ~ATMEL_US_CHMODE;
324 if (mctrl & TIOCM_LOOP) 366 if (mctrl & TIOCM_LOOP)
@@ -346,7 +388,8 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl)
346 */ 388 */
347static u_int atmel_get_mctrl(struct uart_port *port) 389static u_int atmel_get_mctrl(struct uart_port *port)
348{ 390{
349 unsigned int status, ret = 0; 391 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
392 unsigned int ret = 0, status;
350 393
351 status = UART_GET_CSR(port); 394 status = UART_GET_CSR(port);
352 395
@@ -362,7 +405,7 @@ static u_int atmel_get_mctrl(struct uart_port *port)
362 if (!(status & ATMEL_US_RI)) 405 if (!(status & ATMEL_US_RI))
363 ret |= TIOCM_RI; 406 ret |= TIOCM_RI;
364 407
365 return ret; 408 return mctrl_gpio_get(atmel_port->gpios, &ret);
366} 409}
367 410
368/* 411/*
@@ -449,8 +492,38 @@ static void atmel_stop_rx(struct uart_port *port)
449 */ 492 */
450static void atmel_enable_ms(struct uart_port *port) 493static void atmel_enable_ms(struct uart_port *port)
451{ 494{
452 UART_PUT_IER(port, ATMEL_US_RIIC | ATMEL_US_DSRIC 495 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
453 | ATMEL_US_DCDIC | ATMEL_US_CTSIC); 496 uint32_t ier = 0;
497
498 /*
499 * Interrupt should not be enabled twice
500 */
501 if (atmel_port->ms_irq_enabled)
502 return;
503
504 atmel_port->ms_irq_enabled = true;
505
506 if (atmel_port->gpio_irq[UART_GPIO_CTS] >= 0)
507 enable_irq(atmel_port->gpio_irq[UART_GPIO_CTS]);
508 else
509 ier |= ATMEL_US_CTSIC;
510
511 if (atmel_port->gpio_irq[UART_GPIO_DSR] >= 0)
512 enable_irq(atmel_port->gpio_irq[UART_GPIO_DSR]);
513 else
514 ier |= ATMEL_US_DSRIC;
515
516 if (atmel_port->gpio_irq[UART_GPIO_RI] >= 0)
517 enable_irq(atmel_port->gpio_irq[UART_GPIO_RI]);
518 else
519 ier |= ATMEL_US_RIIC;
520
521 if (atmel_port->gpio_irq[UART_GPIO_DCD] >= 0)
522 enable_irq(atmel_port->gpio_irq[UART_GPIO_DCD]);
523 else
524 ier |= ATMEL_US_DCDIC;
525
526 UART_PUT_IER(port, ier);
454} 527}
455 528
456/* 529/*
@@ -1039,11 +1112,31 @@ atmel_handle_status(struct uart_port *port, unsigned int pending,
1039static irqreturn_t atmel_interrupt(int irq, void *dev_id) 1112static irqreturn_t atmel_interrupt(int irq, void *dev_id)
1040{ 1113{
1041 struct uart_port *port = dev_id; 1114 struct uart_port *port = dev_id;
1115 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
1042 unsigned int status, pending, pass_counter = 0; 1116 unsigned int status, pending, pass_counter = 0;
1117 bool gpio_handled = false;
1043 1118
1044 do { 1119 do {
1045 status = UART_GET_CSR(port); 1120 status = atmel_get_lines_status(port);
1046 pending = status & UART_GET_IMR(port); 1121 pending = status & UART_GET_IMR(port);
1122 if (!gpio_handled) {
1123 /*
1124 * Dealing with GPIO interrupt
1125 */
1126 if (irq == atmel_port->gpio_irq[UART_GPIO_CTS])
1127 pending |= ATMEL_US_CTSIC;
1128
1129 if (irq == atmel_port->gpio_irq[UART_GPIO_DSR])
1130 pending |= ATMEL_US_DSRIC;
1131
1132 if (irq == atmel_port->gpio_irq[UART_GPIO_RI])
1133 pending |= ATMEL_US_RIIC;
1134
1135 if (irq == atmel_port->gpio_irq[UART_GPIO_DCD])
1136 pending |= ATMEL_US_DCDIC;
1137
1138 gpio_handled = true;
1139 }
1047 if (!pending) 1140 if (!pending)
1048 break; 1141 break;
1049 1142
@@ -1523,6 +1616,45 @@ static void atmel_get_ip_name(struct uart_port *port)
1523 } 1616 }
1524} 1617}
1525 1618
1619static void atmel_free_gpio_irq(struct uart_port *port)
1620{
1621 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
1622 enum mctrl_gpio_idx i;
1623
1624 for (i = 0; i < UART_GPIO_MAX; i++)
1625 if (atmel_port->gpio_irq[i] >= 0)
1626 free_irq(atmel_port->gpio_irq[i], port);
1627}
1628
1629static int atmel_request_gpio_irq(struct uart_port *port)
1630{
1631 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
1632 int *irq = atmel_port->gpio_irq;
1633 enum mctrl_gpio_idx i;
1634 int err = 0;
1635
1636 for (i = 0; (i < UART_GPIO_MAX) && !err; i++) {
1637 if (irq[i] < 0)
1638 continue;
1639
1640 irq_set_status_flags(irq[i], IRQ_NOAUTOEN);
1641 err = request_irq(irq[i], atmel_interrupt, IRQ_TYPE_EDGE_BOTH,
1642 "atmel_serial", port);
1643 if (err)
1644 dev_err(port->dev, "atmel_startup - Can't get %d irq\n",
1645 irq[i]);
1646 }
1647
1648 /*
1649 * If something went wrong, rollback.
1650 */
1651 while (err && (--i >= 0))
1652 if (irq[i] >= 0)
1653 free_irq(irq[i], port);
1654
1655 return err;
1656}
1657
1526/* 1658/*
1527 * Perform initialization and enable port for reception 1659 * Perform initialization and enable port for reception
1528 */ 1660 */
@@ -1539,6 +1671,7 @@ static int atmel_startup(struct uart_port *port)
1539 * handle an unexpected interrupt 1671 * handle an unexpected interrupt
1540 */ 1672 */
1541 UART_PUT_IDR(port, -1); 1673 UART_PUT_IDR(port, -1);
1674 atmel_port->ms_irq_enabled = false;
1542 1675
1543 /* 1676 /*
1544 * Allocate the IRQ 1677 * Allocate the IRQ
@@ -1551,6 +1684,13 @@ static int atmel_startup(struct uart_port *port)
1551 } 1684 }
1552 1685
1553 /* 1686 /*
1687 * Get the GPIO lines IRQ
1688 */
1689 retval = atmel_request_gpio_irq(port);
1690 if (retval)
1691 goto free_irq;
1692
1693 /*
1554 * Initialize DMA (if necessary) 1694 * Initialize DMA (if necessary)
1555 */ 1695 */
1556 atmel_init_property(atmel_port, pdev); 1696 atmel_init_property(atmel_port, pdev);
@@ -1568,7 +1708,7 @@ static int atmel_startup(struct uart_port *port)
1568 } 1708 }
1569 1709
1570 /* Save current CSR for comparison in atmel_tasklet_func() */ 1710 /* Save current CSR for comparison in atmel_tasklet_func() */
1571 atmel_port->irq_status_prev = UART_GET_CSR(port); 1711 atmel_port->irq_status_prev = atmel_get_lines_status(port);
1572 atmel_port->irq_status = atmel_port->irq_status_prev; 1712 atmel_port->irq_status = atmel_port->irq_status_prev;
1573 1713
1574 /* 1714 /*
@@ -1614,6 +1754,11 @@ static int atmel_startup(struct uart_port *port)
1614 } 1754 }
1615 1755
1616 return 0; 1756 return 0;
1757
1758free_irq:
1759 free_irq(port->irq, port);
1760
1761 return retval;
1617} 1762}
1618 1763
1619/* 1764/*
@@ -1661,9 +1806,12 @@ static void atmel_shutdown(struct uart_port *port)
1661 atmel_port->rx_ring.tail = 0; 1806 atmel_port->rx_ring.tail = 0;
1662 1807
1663 /* 1808 /*
1664 * Free the interrupt 1809 * Free the interrupts
1665 */ 1810 */
1666 free_irq(port->irq, port); 1811 free_irq(port->irq, port);
1812 atmel_free_gpio_irq(port);
1813
1814 atmel_port->ms_irq_enabled = false;
1667} 1815}
1668 1816
1669/* 1817/*
@@ -2324,6 +2472,26 @@ static int atmel_serial_resume(struct platform_device *pdev)
2324#define atmel_serial_resume NULL 2472#define atmel_serial_resume NULL
2325#endif 2473#endif
2326 2474
2475static int atmel_init_gpios(struct atmel_uart_port *p, struct device *dev)
2476{
2477 enum mctrl_gpio_idx i;
2478 struct gpio_desc *gpiod;
2479
2480 p->gpios = mctrl_gpio_init(dev, 0);
2481 if (IS_ERR_OR_NULL(p->gpios))
2482 return -1;
2483
2484 for (i = 0; i < UART_GPIO_MAX; i++) {
2485 gpiod = mctrl_gpio_to_gpiod(p->gpios, i);
2486 if (gpiod && (gpiod_get_direction(gpiod) == GPIOF_DIR_IN))
2487 p->gpio_irq[i] = gpiod_to_irq(gpiod);
2488 else
2489 p->gpio_irq[i] = -EINVAL;
2490 }
2491
2492 return 0;
2493}
2494
2327static int atmel_serial_probe(struct platform_device *pdev) 2495static int atmel_serial_probe(struct platform_device *pdev)
2328{ 2496{
2329 struct atmel_uart_port *port; 2497 struct atmel_uart_port *port;
@@ -2359,25 +2527,11 @@ static int atmel_serial_probe(struct platform_device *pdev)
2359 port = &atmel_ports[ret]; 2527 port = &atmel_ports[ret];
2360 port->backup_imr = 0; 2528 port->backup_imr = 0;
2361 port->uart.line = ret; 2529 port->uart.line = ret;
2362 port->rts_gpio = -EINVAL; /* Invalid, zero could be valid */ 2530
2363 if (pdata) 2531 ret = atmel_init_gpios(port, &pdev->dev);
2364 port->rts_gpio = pdata->rts_gpio; 2532 if (ret < 0)
2365 else if (np) 2533 dev_err(&pdev->dev, "%s",
2366 port->rts_gpio = of_get_named_gpio(np, "rts-gpios", 0); 2534 "Failed to initialize GPIOs. The serial port may not work as expected");
2367
2368 if (gpio_is_valid(port->rts_gpio)) {
2369 ret = devm_gpio_request(&pdev->dev, port->rts_gpio, "RTS");
2370 if (ret) {
2371 dev_err(&pdev->dev, "error requesting RTS GPIO\n");
2372 goto err;
2373 }
2374 /* Default to 1 as RTS is active low */
2375 ret = gpio_direction_output(port->rts_gpio, 1);
2376 if (ret) {
2377 dev_err(&pdev->dev, "error setting up RTS GPIO\n");
2378 goto err;
2379 }
2380 }
2381 2535
2382 ret = atmel_init_port(port, pdev); 2536 ret = atmel_init_port(port, pdev);
2383 if (ret) 2537 if (ret)
diff --git a/drivers/tty/serial/cpm_uart/cpm_uart_core.c b/drivers/tty/serial/cpm_uart/cpm_uart_core.c
index 7d76214612c7..aa60e6d13eca 100644
--- a/drivers/tty/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/tty/serial/cpm_uart/cpm_uart_core.c
@@ -971,7 +971,7 @@ static void cpm_uart_config_port(struct uart_port *port, int flags)
971 * Note that this is called with interrupts already disabled 971 * Note that this is called with interrupts already disabled
972 */ 972 */
973static void cpm_uart_early_write(struct uart_cpm_port *pinfo, 973static void cpm_uart_early_write(struct uart_cpm_port *pinfo,
974 const char *string, u_int count) 974 const char *string, u_int count, bool handle_linefeed)
975{ 975{
976 unsigned int i; 976 unsigned int i;
977 cbd_t __iomem *bdp, *bdbase; 977 cbd_t __iomem *bdp, *bdbase;
@@ -1013,7 +1013,7 @@ static void cpm_uart_early_write(struct uart_cpm_port *pinfo,
1013 bdp++; 1013 bdp++;
1014 1014
1015 /* if a LF, also do CR... */ 1015 /* if a LF, also do CR... */
1016 if (*string == 10) { 1016 if (handle_linefeed && *string == 10) {
1017 while ((in_be16(&bdp->cbd_sc) & BD_SC_READY) != 0) 1017 while ((in_be16(&bdp->cbd_sc) & BD_SC_READY) != 0)
1018 ; 1018 ;
1019 1019
@@ -1111,7 +1111,7 @@ static void cpm_put_poll_char(struct uart_port *port,
1111 static char ch[2]; 1111 static char ch[2];
1112 1112
1113 ch[0] = (char)c; 1113 ch[0] = (char)c;
1114 cpm_uart_early_write(pinfo, ch, 1); 1114 cpm_uart_early_write(pinfo, ch, 1, false);
1115} 1115}
1116#endif /* CONFIG_CONSOLE_POLL */ 1116#endif /* CONFIG_CONSOLE_POLL */
1117 1117
@@ -1275,7 +1275,7 @@ static void cpm_uart_console_write(struct console *co, const char *s,
1275 spin_lock_irqsave(&pinfo->port.lock, flags); 1275 spin_lock_irqsave(&pinfo->port.lock, flags);
1276 } 1276 }
1277 1277
1278 cpm_uart_early_write(pinfo, s, count); 1278 cpm_uart_early_write(pinfo, s, count, true);
1279 1279
1280 if (unlikely(nolock)) { 1280 if (unlikely(nolock)) {
1281 local_irq_restore(flags); 1281 local_irq_restore(flags);
diff --git a/drivers/tty/serial/earlycon-arm-semihost.c b/drivers/tty/serial/earlycon-arm-semihost.c
new file mode 100644
index 000000000000..383db10fbb49
--- /dev/null
+++ b/drivers/tty/serial/earlycon-arm-semihost.c
@@ -0,0 +1,61 @@
1/*
2 * Copyright (C) 2012 ARM Ltd.
3 * Author: Marc Zyngier <marc.zyngier@arm.com>
4 *
5 * Adapted for ARM and earlycon:
6 * Copyright (C) 2014 Linaro Ltd.
7 * Author: Rob Herring <robh@kernel.org>
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21#include <linux/kernel.h>
22#include <linux/console.h>
23#include <linux/init.h>
24#include <linux/serial_core.h>
25
26#ifdef CONFIG_THUMB2_KERNEL
27#define SEMIHOST_SWI "0xab"
28#else
29#define SEMIHOST_SWI "0x123456"
30#endif
31
32/*
33 * Semihosting-based debug console
34 */
35static void smh_putc(struct uart_port *port, int c)
36{
37#ifdef CONFIG_ARM64
38 asm volatile("mov x1, %0\n"
39 "mov x0, #3\n"
40 "hlt 0xf000\n"
41 : : "r" (&c) : "x0", "x1", "memory");
42#else
43 asm volatile("mov r1, %0\n"
44 "mov r0, #3\n"
45 "svc " SEMIHOST_SWI "\n"
46 : : "r" (&c) : "r0", "r1", "memory");
47#endif
48}
49
50static void smh_write(struct console *con, const char *s, unsigned n)
51{
52 struct earlycon_device *dev = con->data;
53 uart_console_write(&dev->port, s, n, smh_putc);
54}
55
56int __init early_smh_setup(struct earlycon_device *device, const char *opt)
57{
58 device->con->write = smh_write;
59 return 0;
60}
61EARLYCON_DECLARE(smh, early_smh_setup);
diff --git a/drivers/tty/serial/earlycon.c b/drivers/tty/serial/earlycon.c
new file mode 100644
index 000000000000..5131b5ee6164
--- /dev/null
+++ b/drivers/tty/serial/earlycon.c
@@ -0,0 +1,172 @@
1/*
2 * Copyright (C) 2014 Linaro Ltd.
3 * Author: Rob Herring <robh@kernel.org>
4 *
5 * Based on 8250 earlycon:
6 * (c) Copyright 2004 Hewlett-Packard Development Company, L.P.
7 * Bjorn Helgaas <bjorn.helgaas@hp.com>
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13#include <linux/console.h>
14#include <linux/kernel.h>
15#include <linux/init.h>
16#include <linux/io.h>
17#include <linux/serial_core.h>
18#include <linux/sizes.h>
19#include <linux/mod_devicetable.h>
20
21#ifdef CONFIG_FIX_EARLYCON_MEM
22#include <asm/fixmap.h>
23#endif
24
25#include <asm/serial.h>
26
27static struct console early_con = {
28 .name = "earlycon",
29 .flags = CON_PRINTBUFFER | CON_BOOT,
30 .index = -1,
31};
32
33static struct earlycon_device early_console_dev = {
34 .con = &early_con,
35};
36
37static const struct of_device_id __earlycon_of_table_sentinel
38 __used __section(__earlycon_of_table_end);
39
40static void __iomem * __init earlycon_map(unsigned long paddr, size_t size)
41{
42 void __iomem *base;
43#ifdef CONFIG_FIX_EARLYCON_MEM
44 set_fixmap_io(FIX_EARLYCON_MEM_BASE, paddr & PAGE_MASK);
45 base = (void __iomem *)__fix_to_virt(FIX_EARLYCON_MEM_BASE);
46 base += paddr & ~PAGE_MASK;
47#else
48 base = ioremap(paddr, size);
49#endif
50 if (!base)
51 pr_err("%s: Couldn't map 0x%llx\n", __func__,
52 (unsigned long long)paddr);
53
54 return base;
55}
56
57static int __init parse_options(struct earlycon_device *device,
58 char *options)
59{
60 struct uart_port *port = &device->port;
61 int mmio, mmio32, length;
62 unsigned long addr;
63
64 if (!options)
65 return -ENODEV;
66
67 mmio = !strncmp(options, "mmio,", 5);
68 mmio32 = !strncmp(options, "mmio32,", 7);
69 if (mmio || mmio32) {
70 port->iotype = (mmio ? UPIO_MEM : UPIO_MEM32);
71 options += mmio ? 5 : 7;
72 addr = simple_strtoul(options, NULL, 0);
73 port->mapbase = addr;
74 if (mmio32)
75 port->regshift = 2;
76 } else if (!strncmp(options, "io,", 3)) {
77 port->iotype = UPIO_PORT;
78 options += 3;
79 addr = simple_strtoul(options, NULL, 0);
80 port->iobase = addr;
81 mmio = 0;
82 } else if (!strncmp(options, "0x", 2)) {
83 port->iotype = UPIO_MEM;
84 addr = simple_strtoul(options, NULL, 0);
85 port->mapbase = addr;
86 } else {
87 return -EINVAL;
88 }
89
90 port->uartclk = BASE_BAUD * 16;
91
92 options = strchr(options, ',');
93 if (options) {
94 options++;
95 device->baud = simple_strtoul(options, NULL, 0);
96 length = min(strcspn(options, " ") + 1,
97 (size_t)(sizeof(device->options)));
98 strlcpy(device->options, options, length);
99 }
100
101 if (mmio || mmio32)
102 pr_info("Early serial console at MMIO%s 0x%llx (options '%s')\n",
103 mmio32 ? "32" : "",
104 (unsigned long long)port->mapbase,
105 device->options);
106 else
107 pr_info("Early serial console at I/O port 0x%lx (options '%s')\n",
108 port->iobase,
109 device->options);
110
111 return 0;
112}
113
114int __init setup_earlycon(char *buf, const char *match,
115 int (*setup)(struct earlycon_device *, const char *))
116{
117 int err;
118 size_t len;
119 struct uart_port *port = &early_console_dev.port;
120
121 if (!buf || !match || !setup)
122 return 0;
123
124 len = strlen(match);
125 if (strncmp(buf, match, len))
126 return 0;
127 if (buf[len] && (buf[len] != ','))
128 return 0;
129
130 buf += len + 1;
131
132 err = parse_options(&early_console_dev, buf);
133 /* On parsing error, pass the options buf to the setup function */
134 if (!err)
135 buf = NULL;
136
137 if (port->mapbase)
138 port->membase = earlycon_map(port->mapbase, 64);
139
140 early_console_dev.con->data = &early_console_dev;
141 err = setup(&early_console_dev, buf);
142 if (err < 0)
143 return err;
144 if (!early_console_dev.con->write)
145 return -ENODEV;
146
147 register_console(early_console_dev.con);
148 return 0;
149}
150
151int __init of_setup_earlycon(unsigned long addr,
152 int (*setup)(struct earlycon_device *, const char *))
153{
154 int err;
155 struct uart_port *port = &early_console_dev.port;
156
157 port->iotype = UPIO_MEM;
158 port->mapbase = addr;
159 port->uartclk = BASE_BAUD * 16;
160 port->membase = earlycon_map(addr, SZ_4K);
161
162 early_console_dev.con->data = &early_console_dev;
163 err = setup(&early_console_dev, NULL);
164 if (err < 0)
165 return err;
166 if (!early_console_dev.con->write)
167 return -ENODEV;
168
169
170 register_console(early_console_dev.con);
171 return 0;
172}
diff --git a/drivers/tty/serial/efm32-uart.c b/drivers/tty/serial/efm32-uart.c
index c167a710dc39..b373f6416e8c 100644
--- a/drivers/tty/serial/efm32-uart.c
+++ b/drivers/tty/serial/efm32-uart.c
@@ -842,6 +842,7 @@ static void __exit efm32_uart_exit(void)
842 platform_driver_unregister(&efm32_uart_driver); 842 platform_driver_unregister(&efm32_uart_driver);
843 uart_unregister_driver(&efm32_uart_reg); 843 uart_unregister_driver(&efm32_uart_reg);
844} 844}
845module_exit(efm32_uart_exit);
845 846
846MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>"); 847MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
847MODULE_DESCRIPTION("EFM32 UART/USART driver"); 848MODULE_DESCRIPTION("EFM32 UART/USART driver");
diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 3b6c1a2e25de..e2f93874989b 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -116,7 +116,7 @@
116#define UCR3_DSR (1<<10) /* Data set ready */ 116#define UCR3_DSR (1<<10) /* Data set ready */
117#define UCR3_DCD (1<<9) /* Data carrier detect */ 117#define UCR3_DCD (1<<9) /* Data carrier detect */
118#define UCR3_RI (1<<8) /* Ring indicator */ 118#define UCR3_RI (1<<8) /* Ring indicator */
119#define UCR3_TIMEOUTEN (1<<7) /* Timeout interrupt enable */ 119#define UCR3_ADNIMP (1<<7) /* Autobaud Detection Not Improved */
120#define UCR3_RXDSEN (1<<6) /* Receive status interrupt enable */ 120#define UCR3_RXDSEN (1<<6) /* Receive status interrupt enable */
121#define UCR3_AIRINTEN (1<<5) /* Async IR wake interrupt enable */ 121#define UCR3_AIRINTEN (1<<5) /* Async IR wake interrupt enable */
122#define UCR3_AWAKEN (1<<4) /* Async wake interrupt enable */ 122#define UCR3_AWAKEN (1<<4) /* Async wake interrupt enable */
@@ -444,6 +444,10 @@ static void imx_stop_rx(struct uart_port *port)
444 444
445 temp = readl(sport->port.membase + UCR2); 445 temp = readl(sport->port.membase + UCR2);
446 writel(temp & ~UCR2_RXEN, sport->port.membase + UCR2); 446 writel(temp & ~UCR2_RXEN, sport->port.membase + UCR2);
447
448 /* disable the `Receiver Ready Interrrupt` */
449 temp = readl(sport->port.membase + UCR1);
450 writel(temp & ~UCR1_RRDYEN, sport->port.membase + UCR1);
447} 451}
448 452
449/* 453/*
@@ -1070,7 +1074,7 @@ static void imx_disable_dma(struct imx_port *sport)
1070static int imx_startup(struct uart_port *port) 1074static int imx_startup(struct uart_port *port)
1071{ 1075{
1072 struct imx_port *sport = (struct imx_port *)port; 1076 struct imx_port *sport = (struct imx_port *)port;
1073 int retval; 1077 int retval, i;
1074 unsigned long flags, temp; 1078 unsigned long flags, temp;
1075 1079
1076 retval = clk_prepare_enable(sport->clk_per); 1080 retval = clk_prepare_enable(sport->clk_per);
@@ -1098,17 +1102,15 @@ static int imx_startup(struct uart_port *port)
1098 1102
1099 writel(temp & ~UCR4_DREN, sport->port.membase + UCR4); 1103 writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
1100 1104
1101 if (USE_IRDA(sport)) { 1105 /* Reset fifo's and state machines */
1102 /* reset fifo's and state machines */ 1106 i = 100;
1103 int i = 100; 1107
1104 temp = readl(sport->port.membase + UCR2); 1108 temp = readl(sport->port.membase + UCR2);
1105 temp &= ~UCR2_SRST; 1109 temp &= ~UCR2_SRST;
1106 writel(temp, sport->port.membase + UCR2); 1110 writel(temp, sport->port.membase + UCR2);
1107 while (!(readl(sport->port.membase + UCR2) & UCR2_SRST) && 1111
1108 (--i > 0)) { 1112 while (!(readl(sport->port.membase + UCR2) & UCR2_SRST) && (--i > 0))
1109 udelay(1); 1113 udelay(1);
1110 }
1111 }
1112 1114
1113 /* 1115 /*
1114 * Allocate the IRQ(s) i.MX1 has three interrupts whereas later 1116 * Allocate the IRQ(s) i.MX1 has three interrupts whereas later
@@ -1163,18 +1165,9 @@ static int imx_startup(struct uart_port *port)
1163 temp |= UCR2_IRTS; 1165 temp |= UCR2_IRTS;
1164 writel(temp, sport->port.membase + UCR2); 1166 writel(temp, sport->port.membase + UCR2);
1165 1167
1166 if (USE_IRDA(sport)) {
1167 /* clear RX-FIFO */
1168 int i = 64;
1169 while ((--i > 0) &&
1170 (readl(sport->port.membase + URXD0) & URXD_CHARRDY)) {
1171 barrier();
1172 }
1173 }
1174
1175 if (!is_imx1_uart(sport)) { 1168 if (!is_imx1_uart(sport)) {
1176 temp = readl(sport->port.membase + UCR3); 1169 temp = readl(sport->port.membase + UCR3);
1177 temp |= IMX21_UCR3_RXDMUXSEL; 1170 temp |= IMX21_UCR3_RXDMUXSEL | UCR3_ADNIMP;
1178 writel(temp, sport->port.membase + UCR3); 1171 writel(temp, sport->port.membase + UCR3);
1179 } 1172 }
1180 1173
diff --git a/drivers/tty/serial/kgdb_nmi.c b/drivers/tty/serial/kgdb_nmi.c
index 5f673b7ca50e..cfadf2971b12 100644
--- a/drivers/tty/serial/kgdb_nmi.c
+++ b/drivers/tty/serial/kgdb_nmi.c
@@ -44,13 +44,22 @@ MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");
44 44
45static bool kgdb_nmi_tty_enabled; 45static bool kgdb_nmi_tty_enabled;
46 46
47static int kgdb_nmi_console_setup(struct console *co, char *options)
48{
49 /* The NMI console uses the dbg_io_ops to issue console messages. To
50 * avoid duplicate messages during kdb sessions we must inform kdb's
51 * I/O utilities that messages sent to the console will automatically
52 * be displayed on the dbg_io.
53 */
54 dbg_io_ops->is_console = true;
55
56 return 0;
57}
58
47static void kgdb_nmi_console_write(struct console *co, const char *s, uint c) 59static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
48{ 60{
49 int i; 61 int i;
50 62
51 if (!kgdb_nmi_tty_enabled || atomic_read(&kgdb_active) >= 0)
52 return;
53
54 for (i = 0; i < c; i++) 63 for (i = 0; i < c; i++)
55 dbg_io_ops->write_char(s[i]); 64 dbg_io_ops->write_char(s[i]);
56} 65}
@@ -65,6 +74,7 @@ static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
65 74
66static struct console kgdb_nmi_console = { 75static struct console kgdb_nmi_console = {
67 .name = "ttyNMI", 76 .name = "ttyNMI",
77 .setup = kgdb_nmi_console_setup,
68 .write = kgdb_nmi_console_write, 78 .write = kgdb_nmi_console_write,
69 .device = kgdb_nmi_console_device, 79 .device = kgdb_nmi_console_device,
70 .flags = CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED, 80 .flags = CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED,
@@ -80,29 +90,10 @@ static struct console kgdb_nmi_console = {
80 90
81struct kgdb_nmi_tty_priv { 91struct kgdb_nmi_tty_priv {
82 struct tty_port port; 92 struct tty_port port;
83 struct tasklet_struct tlet; 93 struct timer_list timer;
84 STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo; 94 STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
85}; 95};
86 96
87static struct kgdb_nmi_tty_priv *kgdb_nmi_port_to_priv(struct tty_port *port)
88{
89 return container_of(port, struct kgdb_nmi_tty_priv, port);
90}
91
92/*
93 * Our debugging console is polled in a tasklet, so we'll check for input
94 * every tick. In HZ-less mode, we should program the next tick. We have
95 * to use the lowlevel stuff as no locks should be grabbed.
96 */
97#ifdef CONFIG_HIGH_RES_TIMERS
98static void kgdb_tty_poke(void)
99{
100 tick_program_event(ktime_get(), 0);
101}
102#else
103static inline void kgdb_tty_poke(void) {}
104#endif
105
106static struct tty_port *kgdb_nmi_port; 97static struct tty_port *kgdb_nmi_port;
107 98
108static void kgdb_tty_recv(int ch) 99static void kgdb_tty_recv(int ch)
@@ -113,14 +104,13 @@ static void kgdb_tty_recv(int ch)
113 if (!kgdb_nmi_port || ch < 0) 104 if (!kgdb_nmi_port || ch < 0)
114 return; 105 return;
115 /* 106 /*
116 * Can't use port->tty->driver_data as tty might be not there. Tasklet 107 * Can't use port->tty->driver_data as tty might be not there. Timer
117 * will check for tty and will get the ref, but here we don't have to 108 * will check for tty and will get the ref, but here we don't have to
118 * do that, and actually, we can't: we're in NMI context, no locks are 109 * do that, and actually, we can't: we're in NMI context, no locks are
119 * possible. 110 * possible.
120 */ 111 */
121 priv = kgdb_nmi_port_to_priv(kgdb_nmi_port); 112 priv = container_of(kgdb_nmi_port, struct kgdb_nmi_tty_priv, port);
122 kfifo_in(&priv->fifo, &c, 1); 113 kfifo_in(&priv->fifo, &c, 1);
123 kgdb_tty_poke();
124} 114}
125 115
126static int kgdb_nmi_poll_one_knock(void) 116static int kgdb_nmi_poll_one_knock(void)
@@ -204,7 +194,8 @@ static void kgdb_nmi_tty_receiver(unsigned long data)
204 struct kgdb_nmi_tty_priv *priv = (void *)data; 194 struct kgdb_nmi_tty_priv *priv = (void *)data;
205 char ch; 195 char ch;
206 196
207 tasklet_schedule(&priv->tlet); 197 priv->timer.expires = jiffies + (HZ/100);
198 add_timer(&priv->timer);
208 199
209 if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo))) 200 if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
210 return; 201 return;
@@ -216,18 +207,22 @@ static void kgdb_nmi_tty_receiver(unsigned long data)
216 207
217static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty) 208static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
218{ 209{
219 struct kgdb_nmi_tty_priv *priv = tty->driver_data; 210 struct kgdb_nmi_tty_priv *priv =
211 container_of(port, struct kgdb_nmi_tty_priv, port);
220 212
221 kgdb_nmi_port = port; 213 kgdb_nmi_port = port;
222 tasklet_schedule(&priv->tlet); 214 priv->timer.expires = jiffies + (HZ/100);
215 add_timer(&priv->timer);
216
223 return 0; 217 return 0;
224} 218}
225 219
226static void kgdb_nmi_tty_shutdown(struct tty_port *port) 220static void kgdb_nmi_tty_shutdown(struct tty_port *port)
227{ 221{
228 struct kgdb_nmi_tty_priv *priv = port->tty->driver_data; 222 struct kgdb_nmi_tty_priv *priv =
223 container_of(port, struct kgdb_nmi_tty_priv, port);
229 224
230 tasklet_kill(&priv->tlet); 225 del_timer(&priv->timer);
231 kgdb_nmi_port = NULL; 226 kgdb_nmi_port = NULL;
232} 227}
233 228
@@ -246,7 +241,7 @@ static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
246 return -ENOMEM; 241 return -ENOMEM;
247 242
248 INIT_KFIFO(priv->fifo); 243 INIT_KFIFO(priv->fifo);
249 tasklet_init(&priv->tlet, kgdb_nmi_tty_receiver, (unsigned long)priv); 244 setup_timer(&priv->timer, kgdb_nmi_tty_receiver, (unsigned long)priv);
250 tty_port_init(&priv->port); 245 tty_port_init(&priv->port);
251 priv->port.ops = &kgdb_nmi_tty_port_ops; 246 priv->port.ops = &kgdb_nmi_tty_port_ops;
252 tty->driver_data = priv; 247 tty->driver_data = priv;
diff --git a/drivers/tty/serial/men_z135_uart.c b/drivers/tty/serial/men_z135_uart.c
new file mode 100644
index 000000000000..c9d18548783a
--- /dev/null
+++ b/drivers/tty/serial/men_z135_uart.c
@@ -0,0 +1,867 @@
1/*
2 * MEN 16z135 High Speed UART
3 *
4 * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de)
5 * Author: Johannes Thumshirn <johannes.thumshirn@men.de>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; version 2 of the License.
10 */
11#define pr_fmt(fmt) KBUILD_MODNAME ":" fmt
12
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/interrupt.h>
16#include <linux/serial_core.h>
17#include <linux/ioport.h>
18#include <linux/io.h>
19#include <linux/tty_flip.h>
20#include <linux/bitops.h>
21#include <linux/mcb.h>
22
23#define MEN_Z135_MAX_PORTS 12
24#define MEN_Z135_BASECLK 29491200
25#define MEN_Z135_FIFO_SIZE 1024
26#define MEN_Z135_NUM_MSI_VECTORS 2
27#define MEN_Z135_FIFO_WATERMARK 1020
28
29#define MEN_Z135_STAT_REG 0x0
30#define MEN_Z135_RX_RAM 0x4
31#define MEN_Z135_TX_RAM 0x400
32#define MEN_Z135_RX_CTRL 0x800
33#define MEN_Z135_TX_CTRL 0x804
34#define MEN_Z135_CONF_REG 0x808
35#define MEN_Z135_UART_FREQ 0x80c
36#define MEN_Z135_BAUD_REG 0x810
37#define MENZ135_TIMEOUT 0x814
38
39#define MEN_Z135_MEM_SIZE 0x818
40
41#define IS_IRQ(x) ((x) & 1)
42#define IRQ_ID(x) (((x) >> 1) & 7)
43
44#define MEN_Z135_IER_RXCIEN BIT(0) /* RX Space IRQ */
45#define MEN_Z135_IER_TXCIEN BIT(1) /* TX Space IRQ */
46#define MEN_Z135_IER_RLSIEN BIT(2) /* Receiver Line Status IRQ */
47#define MEN_Z135_IER_MSIEN BIT(3) /* Modem Status IRQ */
48#define MEN_Z135_ALL_IRQS (MEN_Z135_IER_RXCIEN \
49 | MEN_Z135_IER_RLSIEN \
50 | MEN_Z135_IER_MSIEN \
51 | MEN_Z135_IER_TXCIEN)
52
53#define MEN_Z135_MCR_DTR BIT(24)
54#define MEN_Z135_MCR_RTS BIT(25)
55#define MEN_Z135_MCR_OUT1 BIT(26)
56#define MEN_Z135_MCR_OUT2 BIT(27)
57#define MEN_Z135_MCR_LOOP BIT(28)
58#define MEN_Z135_MCR_RCFC BIT(29)
59
60#define MEN_Z135_MSR_DCTS BIT(0)
61#define MEN_Z135_MSR_DDSR BIT(1)
62#define MEN_Z135_MSR_DRI BIT(2)
63#define MEN_Z135_MSR_DDCD BIT(3)
64#define MEN_Z135_MSR_CTS BIT(4)
65#define MEN_Z135_MSR_DSR BIT(5)
66#define MEN_Z135_MSR_RI BIT(6)
67#define MEN_Z135_MSR_DCD BIT(7)
68
69#define MEN_Z135_LCR_SHIFT 8 /* LCR shift mask */
70
71#define MEN_Z135_WL5 0 /* CS5 */
72#define MEN_Z135_WL6 1 /* CS6 */
73#define MEN_Z135_WL7 2 /* CS7 */
74#define MEN_Z135_WL8 3 /* CS8 */
75
76#define MEN_Z135_STB_SHIFT 2 /* Stopbits */
77#define MEN_Z135_NSTB1 0
78#define MEN_Z135_NSTB2 1
79
80#define MEN_Z135_PEN_SHIFT 3 /* Parity enable */
81#define MEN_Z135_PAR_DIS 0
82#define MEN_Z135_PAR_ENA 1
83
84#define MEN_Z135_PTY_SHIFT 4 /* Parity type */
85#define MEN_Z135_PTY_ODD 0
86#define MEN_Z135_PTY_EVN 1
87
88#define MEN_Z135_LSR_DR BIT(0)
89#define MEN_Z135_LSR_OE BIT(1)
90#define MEN_Z135_LSR_PE BIT(2)
91#define MEN_Z135_LSR_FE BIT(3)
92#define MEN_Z135_LSR_BI BIT(4)
93#define MEN_Z135_LSR_THEP BIT(5)
94#define MEN_Z135_LSR_TEXP BIT(6)
95#define MEN_Z135_LSR_RXFIFOERR BIT(7)
96
97#define MEN_Z135_IRQ_ID_MST 0
98#define MEN_Z135_IRQ_ID_TSA 1
99#define MEN_Z135_IRQ_ID_RDA 2
100#define MEN_Z135_IRQ_ID_RLS 3
101#define MEN_Z135_IRQ_ID_CTI 6
102
103#define LCR(x) (((x) >> MEN_Z135_LCR_SHIFT) & 0xff)
104
105#define BYTES_TO_ALIGN(x) ((x) & 0x3)
106
107static int line;
108
109static int txlvl = 5;
110module_param(txlvl, int, S_IRUGO);
111MODULE_PARM_DESC(txlvl, "TX IRQ trigger level 0-7, default 5 (128 byte)");
112
113static int rxlvl = 6;
114module_param(rxlvl, int, S_IRUGO);
115MODULE_PARM_DESC(rxlvl, "RX IRQ trigger level 0-7, default 6 (256 byte)");
116
117static int align;
118module_param(align, int, S_IRUGO);
119MODULE_PARM_DESC(align, "Keep hardware FIFO write pointer aligned, default 0");
120
121struct men_z135_port {
122 struct uart_port port;
123 struct mcb_device *mdev;
124 unsigned char *rxbuf;
125 u32 stat_reg;
126 spinlock_t lock;
127};
128#define to_men_z135(port) container_of((port), struct men_z135_port, port)
129
130/**
131 * men_z135_reg_set() - Set value in register
132 * @uart: The UART port
133 * @addr: Register address
134 * @val: value to set
135 */
136static inline void men_z135_reg_set(struct men_z135_port *uart,
137 u32 addr, u32 val)
138{
139 struct uart_port *port = &uart->port;
140 unsigned long flags;
141 u32 reg;
142
143 spin_lock_irqsave(&uart->lock, flags);
144
145 reg = ioread32(port->membase + addr);
146 reg |= val;
147 iowrite32(reg, port->membase + addr);
148
149 spin_unlock_irqrestore(&uart->lock, flags);
150}
151
152/**
153 * men_z135_reg_clr() - Unset value in register
154 * @uart: The UART port
155 * @addr: Register address
156 * @val: value to clear
157 */
158static inline void men_z135_reg_clr(struct men_z135_port *uart,
159 u32 addr, u32 val)
160{
161 struct uart_port *port = &uart->port;
162 unsigned long flags;
163 u32 reg;
164
165 spin_lock_irqsave(&uart->lock, flags);
166
167 reg = ioread32(port->membase + addr);
168 reg &= ~val;
169 iowrite32(reg, port->membase + addr);
170
171 spin_unlock_irqrestore(&uart->lock, flags);
172}
173
174/**
175 * men_z135_handle_modem_status() - Handle change of modem status
176 * @port: The UART port
177 *
178 * Handle change of modem status register. This is done by reading the "delta"
179 * versions of DCD (Data Carrier Detect) and CTS (Clear To Send).
180 */
181static void men_z135_handle_modem_status(struct men_z135_port *uart)
182{
183 if (uart->stat_reg & MEN_Z135_MSR_DDCD)
184 uart_handle_dcd_change(&uart->port,
185 uart->stat_reg & ~MEN_Z135_MSR_DCD);
186 if (uart->stat_reg & MEN_Z135_MSR_DCTS)
187 uart_handle_cts_change(&uart->port,
188 uart->stat_reg & ~MEN_Z135_MSR_CTS);
189}
190
191static void men_z135_handle_lsr(struct men_z135_port *uart)
192{
193 struct uart_port *port = &uart->port;
194 u8 lsr;
195
196 lsr = (uart->stat_reg >> 16) & 0xff;
197
198 if (lsr & MEN_Z135_LSR_OE)
199 port->icount.overrun++;
200 if (lsr & MEN_Z135_LSR_PE)
201 port->icount.parity++;
202 if (lsr & MEN_Z135_LSR_FE)
203 port->icount.frame++;
204 if (lsr & MEN_Z135_LSR_BI) {
205 port->icount.brk++;
206 uart_handle_break(port);
207 }
208}
209
210/**
211 * get_rx_fifo_content() - Get the number of bytes in RX FIFO
212 * @uart: The UART port
213 *
214 * Read RXC register from hardware and return current FIFO fill size.
215 */
216static u16 get_rx_fifo_content(struct men_z135_port *uart)
217{
218 struct uart_port *port = &uart->port;
219 u32 stat_reg;
220 u16 rxc;
221 u8 rxc_lo;
222 u8 rxc_hi;
223
224 stat_reg = ioread32(port->membase + MEN_Z135_STAT_REG);
225 rxc_lo = stat_reg >> 24;
226 rxc_hi = (stat_reg & 0xC0) >> 6;
227
228 rxc = rxc_lo | (rxc_hi << 8);
229
230 return rxc;
231}
232
233/**
234 * men_z135_handle_rx() - RX tasklet routine
235 * @arg: Pointer to struct men_z135_port
236 *
237 * Copy from RX FIFO and acknowledge number of bytes copied.
238 */
239static void men_z135_handle_rx(struct men_z135_port *uart)
240{
241 struct uart_port *port = &uart->port;
242 struct tty_port *tport = &port->state->port;
243 int copied;
244 u16 size;
245 int room;
246
247 size = get_rx_fifo_content(uart);
248
249 if (size == 0)
250 return;
251
252 /* Avoid accidently accessing TX FIFO instead of RX FIFO. Last
253 * longword in RX FIFO cannot be read.(0x004-0x3FF)
254 */
255 if (size > MEN_Z135_FIFO_WATERMARK)
256 size = MEN_Z135_FIFO_WATERMARK;
257
258 room = tty_buffer_request_room(tport, size);
259 if (room != size)
260 dev_warn(&uart->mdev->dev,
261 "Not enough room in flip buffer, truncating to %d\n",
262 room);
263
264 if (room == 0)
265 return;
266
267 memcpy_fromio(uart->rxbuf, port->membase + MEN_Z135_RX_RAM, room);
268 /* Be sure to first copy all data and then acknowledge it */
269 mb();
270 iowrite32(room, port->membase + MEN_Z135_RX_CTRL);
271
272 copied = tty_insert_flip_string(tport, uart->rxbuf, room);
273 if (copied != room)
274 dev_warn(&uart->mdev->dev,
275 "Only copied %d instead of %d bytes\n",
276 copied, room);
277
278 port->icount.rx += copied;
279
280 tty_flip_buffer_push(tport);
281
282}
283
284/**
285 * men_z135_handle_tx() - TX tasklet routine
286 * @arg: Pointer to struct men_z135_port
287 *
288 */
289static void men_z135_handle_tx(struct men_z135_port *uart)
290{
291 struct uart_port *port = &uart->port;
292 struct circ_buf *xmit = &port->state->xmit;
293 u32 txc;
294 u32 wptr;
295 int qlen;
296 int n;
297 int txfree;
298 int head;
299 int tail;
300 int s;
301
302 if (uart_circ_empty(xmit))
303 goto out;
304
305 if (uart_tx_stopped(port))
306 goto out;
307
308 if (port->x_char)
309 goto out;
310
311 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
312 uart_write_wakeup(port);
313
314 /* calculate bytes to copy */
315 qlen = uart_circ_chars_pending(xmit);
316 if (qlen <= 0)
317 goto out;
318
319 wptr = ioread32(port->membase + MEN_Z135_TX_CTRL);
320 txc = (wptr >> 16) & 0x3ff;
321 wptr &= 0x3ff;
322
323 if (txc > MEN_Z135_FIFO_WATERMARK)
324 txc = MEN_Z135_FIFO_WATERMARK;
325
326 txfree = MEN_Z135_FIFO_WATERMARK - txc;
327 if (txfree <= 0) {
328 pr_err("Not enough room in TX FIFO have %d, need %d\n",
329 txfree, qlen);
330 goto irq_en;
331 }
332
333 /* if we're not aligned, it's better to copy only 1 or 2 bytes and
334 * then the rest.
335 */
336 if (align && qlen >= 3 && BYTES_TO_ALIGN(wptr))
337 n = 4 - BYTES_TO_ALIGN(wptr);
338 else if (qlen > txfree)
339 n = txfree;
340 else
341 n = qlen;
342
343 if (n <= 0)
344 goto irq_en;
345
346 head = xmit->head & (UART_XMIT_SIZE - 1);
347 tail = xmit->tail & (UART_XMIT_SIZE - 1);
348
349 s = ((head >= tail) ? head : UART_XMIT_SIZE) - tail;
350 n = min(n, s);
351
352 memcpy_toio(port->membase + MEN_Z135_TX_RAM, &xmit->buf[xmit->tail], n);
353 xmit->tail = (xmit->tail + n) & (UART_XMIT_SIZE - 1);
354 mmiowb();
355
356 iowrite32(n & 0x3ff, port->membase + MEN_Z135_TX_CTRL);
357
358 port->icount.tx += n;
359
360irq_en:
361 if (!uart_circ_empty(xmit))
362 men_z135_reg_set(uart, MEN_Z135_CONF_REG, MEN_Z135_IER_TXCIEN);
363 else
364 men_z135_reg_clr(uart, MEN_Z135_CONF_REG, MEN_Z135_IER_TXCIEN);
365
366out:
367 return;
368
369}
370
371/**
372 * men_z135_intr() - Handle legacy IRQs
373 * @irq: The IRQ number
374 * @data: Pointer to UART port
375 *
376 * Check IIR register to see which tasklet to start.
377 */
378static irqreturn_t men_z135_intr(int irq, void *data)
379{
380 struct men_z135_port *uart = (struct men_z135_port *)data;
381 struct uart_port *port = &uart->port;
382 int irq_id;
383
384 uart->stat_reg = ioread32(port->membase + MEN_Z135_STAT_REG);
385 /* IRQ pending is low active */
386 if (IS_IRQ(uart->stat_reg))
387 return IRQ_NONE;
388
389 irq_id = IRQ_ID(uart->stat_reg);
390 switch (irq_id) {
391 case MEN_Z135_IRQ_ID_MST:
392 men_z135_handle_modem_status(uart);
393 break;
394 case MEN_Z135_IRQ_ID_TSA:
395 men_z135_handle_tx(uart);
396 break;
397 case MEN_Z135_IRQ_ID_CTI:
398 dev_dbg(&uart->mdev->dev, "Character Timeout Indication\n");
399 /* Fallthrough */
400 case MEN_Z135_IRQ_ID_RDA:
401 /* Reading data clears RX IRQ */
402 men_z135_handle_rx(uart);
403 break;
404 case MEN_Z135_IRQ_ID_RLS:
405 men_z135_handle_lsr(uart);
406 break;
407 default:
408 dev_warn(&uart->mdev->dev, "Unknown IRQ id %d\n", irq_id);
409 return IRQ_NONE;
410 }
411
412 return IRQ_HANDLED;
413}
414
415/**
416 * men_z135_request_irq() - Request IRQ for 16z135 core
417 * @uart: z135 private uart port structure
418 *
419 * Request an IRQ for 16z135 to use. First try using MSI, if it fails
420 * fall back to using legacy interrupts.
421 */
422static int men_z135_request_irq(struct men_z135_port *uart)
423{
424 struct device *dev = &uart->mdev->dev;
425 struct uart_port *port = &uart->port;
426 int err = 0;
427
428 err = request_irq(port->irq, men_z135_intr, IRQF_SHARED,
429 "men_z135_intr", uart);
430 if (err)
431 dev_err(dev, "Error %d getting interrupt\n", err);
432
433 return err;
434}
435
436/**
437 * men_z135_tx_empty() - Handle tx_empty call
438 * @port: The UART port
439 *
440 * This function tests whether the TX FIFO and shifter for the port
441 * described by @port is empty.
442 */
443static unsigned int men_z135_tx_empty(struct uart_port *port)
444{
445 u32 wptr;
446 u16 txc;
447
448 wptr = ioread32(port->membase + MEN_Z135_TX_CTRL);
449 txc = (wptr >> 16) & 0x3ff;
450
451 if (txc == 0)
452 return TIOCSER_TEMT;
453 else
454 return 0;
455}
456
457/**
458 * men_z135_set_mctrl() - Set modem control lines
459 * @port: The UART port
460 * @mctrl: The modem control lines
461 *
462 * This function sets the modem control lines for a port described by @port
463 * to the state described by @mctrl
464 */
465static void men_z135_set_mctrl(struct uart_port *port, unsigned int mctrl)
466{
467 struct men_z135_port *uart = to_men_z135(port);
468 u32 conf_reg = 0;
469
470 if (mctrl & TIOCM_RTS)
471 conf_reg |= MEN_Z135_MCR_RTS;
472 if (mctrl & TIOCM_DTR)
473 conf_reg |= MEN_Z135_MCR_DTR;
474 if (mctrl & TIOCM_OUT1)
475 conf_reg |= MEN_Z135_MCR_OUT1;
476 if (mctrl & TIOCM_OUT2)
477 conf_reg |= MEN_Z135_MCR_OUT2;
478 if (mctrl & TIOCM_LOOP)
479 conf_reg |= MEN_Z135_MCR_LOOP;
480
481 men_z135_reg_set(uart, MEN_Z135_CONF_REG, conf_reg);
482}
483
484/**
485 * men_z135_get_mctrl() - Get modem control lines
486 * @port: The UART port
487 *
488 * Retruns the current state of modem control inputs.
489 */
490static unsigned int men_z135_get_mctrl(struct uart_port *port)
491{
492 unsigned int mctrl = 0;
493 u32 stat_reg;
494 u8 msr;
495
496 stat_reg = ioread32(port->membase + MEN_Z135_STAT_REG);
497
498 msr = ~((stat_reg >> 8) & 0xff);
499
500 if (msr & MEN_Z135_MSR_CTS)
501 mctrl |= TIOCM_CTS;
502 if (msr & MEN_Z135_MSR_DSR)
503 mctrl |= TIOCM_DSR;
504 if (msr & MEN_Z135_MSR_RI)
505 mctrl |= TIOCM_RI;
506 if (msr & MEN_Z135_MSR_DCD)
507 mctrl |= TIOCM_CAR;
508
509 return mctrl;
510}
511
512/**
513 * men_z135_stop_tx() - Stop transmitting characters
514 * @port: The UART port
515 *
516 * Stop transmitting characters. This might be due to CTS line becomming
517 * inactive or the tty layer indicating we want to stop transmission due to
518 * an XOFF character.
519 */
520static void men_z135_stop_tx(struct uart_port *port)
521{
522 struct men_z135_port *uart = to_men_z135(port);
523
524 men_z135_reg_clr(uart, MEN_Z135_CONF_REG, MEN_Z135_IER_TXCIEN);
525}
526
527/**
528 * men_z135_start_tx() - Start transmitting characters
529 * @port: The UART port
530 *
531 * Start transmitting character. This actually doesn't transmit anything, but
532 * fires off the TX tasklet.
533 */
534static void men_z135_start_tx(struct uart_port *port)
535{
536 struct men_z135_port *uart = to_men_z135(port);
537
538 men_z135_handle_tx(uart);
539}
540
541/**
542 * men_z135_stop_rx() - Stop receiving characters
543 * @port: The UART port
544 *
545 * Stop receiving characters; the port is in the process of being closed.
546 */
547static void men_z135_stop_rx(struct uart_port *port)
548{
549 struct men_z135_port *uart = to_men_z135(port);
550
551 men_z135_reg_clr(uart, MEN_Z135_CONF_REG, MEN_Z135_IER_RXCIEN);
552}
553
554/**
555 * men_z135_enable_ms() - Enable Modem Status
556 * port:
557 *
558 * Enable Modem Status IRQ.
559 */
560static void men_z135_enable_ms(struct uart_port *port)
561{
562 struct men_z135_port *uart = to_men_z135(port);
563
564 men_z135_reg_set(uart, MEN_Z135_CONF_REG, MEN_Z135_IER_MSIEN);
565}
566
567static int men_z135_startup(struct uart_port *port)
568{
569 struct men_z135_port *uart = to_men_z135(port);
570 int err;
571 u32 conf_reg = 0;
572
573 err = men_z135_request_irq(uart);
574 if (err)
575 return -ENODEV;
576
577 conf_reg = ioread32(port->membase + MEN_Z135_CONF_REG);
578
579 /* Activate all but TX space available IRQ */
580 conf_reg |= MEN_Z135_ALL_IRQS & ~MEN_Z135_IER_TXCIEN;
581 conf_reg &= ~(0xff << 16);
582 conf_reg |= (txlvl << 16);
583 conf_reg |= (rxlvl << 20);
584
585 iowrite32(conf_reg, port->membase + MEN_Z135_CONF_REG);
586
587 return 0;
588}
589
590static void men_z135_shutdown(struct uart_port *port)
591{
592 struct men_z135_port *uart = to_men_z135(port);
593 u32 conf_reg = 0;
594
595 conf_reg |= MEN_Z135_ALL_IRQS;
596
597 men_z135_reg_clr(uart, MEN_Z135_CONF_REG, conf_reg);
598
599 free_irq(uart->port.irq, uart);
600}
601
602static void men_z135_set_termios(struct uart_port *port,
603 struct ktermios *termios,
604 struct ktermios *old)
605{
606 unsigned int baud;
607 u32 conf_reg;
608 u32 bd_reg;
609 u32 uart_freq;
610 u8 lcr;
611
612 conf_reg = ioread32(port->membase + MEN_Z135_CONF_REG);
613 lcr = LCR(conf_reg);
614
615 /* byte size */
616 switch (termios->c_cflag & CSIZE) {
617 case CS5:
618 lcr |= MEN_Z135_WL5;
619 break;
620 case CS6:
621 lcr |= MEN_Z135_WL6;
622 break;
623 case CS7:
624 lcr |= MEN_Z135_WL7;
625 break;
626 case CS8:
627 lcr |= MEN_Z135_WL8;
628 break;
629 }
630
631 /* stop bits */
632 if (termios->c_cflag & CSTOPB)
633 lcr |= MEN_Z135_NSTB2 << MEN_Z135_STB_SHIFT;
634
635 /* parity */
636 if (termios->c_cflag & PARENB) {
637 lcr |= MEN_Z135_PAR_ENA << MEN_Z135_PEN_SHIFT;
638
639 if (termios->c_cflag & PARODD)
640 lcr |= MEN_Z135_PTY_ODD << MEN_Z135_PTY_SHIFT;
641 else
642 lcr |= MEN_Z135_PTY_EVN << MEN_Z135_PTY_SHIFT;
643 } else
644 lcr |= MEN_Z135_PAR_DIS << MEN_Z135_PEN_SHIFT;
645
646 termios->c_cflag &= ~CMSPAR; /* Mark/Space parity is not supported */
647
648 conf_reg |= lcr << MEN_Z135_LCR_SHIFT;
649 iowrite32(conf_reg, port->membase + MEN_Z135_CONF_REG);
650
651 uart_freq = ioread32(port->membase + MEN_Z135_UART_FREQ);
652 if (uart_freq == 0)
653 uart_freq = MEN_Z135_BASECLK;
654
655 baud = uart_get_baud_rate(port, termios, old, 0, uart_freq / 16);
656
657 spin_lock(&port->lock);
658 if (tty_termios_baud_rate(termios))
659 tty_termios_encode_baud_rate(termios, baud, baud);
660
661 bd_reg = uart_freq / (4 * baud);
662 iowrite32(bd_reg, port->membase + MEN_Z135_BAUD_REG);
663
664 uart_update_timeout(port, termios->c_cflag, baud);
665 spin_unlock(&port->lock);
666}
667
668static const char *men_z135_type(struct uart_port *port)
669{
670 return KBUILD_MODNAME;
671}
672
673static void men_z135_release_port(struct uart_port *port)
674{
675 iounmap(port->membase);
676 port->membase = NULL;
677
678 release_mem_region(port->mapbase, MEN_Z135_MEM_SIZE);
679}
680
681static int men_z135_request_port(struct uart_port *port)
682{
683 int size = MEN_Z135_MEM_SIZE;
684
685 if (!request_mem_region(port->mapbase, size, "men_z135_port"))
686 return -EBUSY;
687
688 port->membase = ioremap(port->mapbase, MEN_Z135_MEM_SIZE);
689 if (port->membase == NULL) {
690 release_mem_region(port->mapbase, MEN_Z135_MEM_SIZE);
691 return -ENOMEM;
692 }
693
694 return 0;
695}
696
697static void men_z135_config_port(struct uart_port *port, int type)
698{
699 port->type = PORT_MEN_Z135;
700 men_z135_request_port(port);
701}
702
703static int men_z135_verify_port(struct uart_port *port,
704 struct serial_struct *serinfo)
705{
706 return -EINVAL;
707}
708
709static struct uart_ops men_z135_ops = {
710 .tx_empty = men_z135_tx_empty,
711 .set_mctrl = men_z135_set_mctrl,
712 .get_mctrl = men_z135_get_mctrl,
713 .stop_tx = men_z135_stop_tx,
714 .start_tx = men_z135_start_tx,
715 .stop_rx = men_z135_stop_rx,
716 .enable_ms = men_z135_enable_ms,
717 .startup = men_z135_startup,
718 .shutdown = men_z135_shutdown,
719 .set_termios = men_z135_set_termios,
720 .type = men_z135_type,
721 .release_port = men_z135_release_port,
722 .request_port = men_z135_request_port,
723 .config_port = men_z135_config_port,
724 .verify_port = men_z135_verify_port,
725};
726
727static struct uart_driver men_z135_driver = {
728 .owner = THIS_MODULE,
729 .driver_name = KBUILD_MODNAME,
730 .dev_name = "ttyHSU",
731 .major = 0,
732 .minor = 0,
733 .nr = MEN_Z135_MAX_PORTS,
734};
735
736/**
737 * men_z135_probe() - Probe a z135 instance
738 * @mdev: The MCB device
739 * @id: The MCB device ID
740 *
741 * men_z135_probe does the basic setup of hardware resources and registers the
742 * new uart port to the tty layer.
743 */
744static int men_z135_probe(struct mcb_device *mdev,
745 const struct mcb_device_id *id)
746{
747 struct men_z135_port *uart;
748 struct resource *mem;
749 struct device *dev;
750 int err;
751
752 dev = &mdev->dev;
753
754 uart = devm_kzalloc(dev, sizeof(struct men_z135_port), GFP_KERNEL);
755 if (!uart)
756 return -ENOMEM;
757
758 uart->rxbuf = (unsigned char *)__get_free_page(GFP_KERNEL);
759 if (!uart->rxbuf)
760 return -ENOMEM;
761
762 mem = &mdev->mem;
763
764 mcb_set_drvdata(mdev, uart);
765
766 uart->port.uartclk = MEN_Z135_BASECLK * 16;
767 uart->port.fifosize = MEN_Z135_FIFO_SIZE;
768 uart->port.iotype = UPIO_MEM;
769 uart->port.ops = &men_z135_ops;
770 uart->port.irq = mcb_get_irq(mdev);
771 uart->port.iotype = UPIO_MEM;
772 uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
773 uart->port.line = line++;
774 uart->port.dev = dev;
775 uart->port.type = PORT_MEN_Z135;
776 uart->port.mapbase = mem->start;
777 uart->port.membase = NULL;
778 uart->mdev = mdev;
779
780 spin_lock_init(&uart->port.lock);
781 spin_lock_init(&uart->lock);
782
783 err = uart_add_one_port(&men_z135_driver, &uart->port);
784 if (err)
785 goto err;
786
787 return 0;
788
789err:
790 free_page((unsigned long) uart->rxbuf);
791 dev_err(dev, "Failed to add UART: %d\n", err);
792
793 return err;
794}
795
796/**
797 * men_z135_remove() - Remove a z135 instance from the system
798 *
799 * @mdev: The MCB device
800 */
801static void men_z135_remove(struct mcb_device *mdev)
802{
803 struct men_z135_port *uart = mcb_get_drvdata(mdev);
804
805 line--;
806 uart_remove_one_port(&men_z135_driver, &uart->port);
807 free_page((unsigned long) uart->rxbuf);
808}
809
810static const struct mcb_device_id men_z135_ids[] = {
811 { .device = 0x87 },
812};
813MODULE_DEVICE_TABLE(mcb, men_z135_ids);
814
815static struct mcb_driver mcb_driver = {
816 .driver = {
817 .name = "z135-uart",
818 .owner = THIS_MODULE,
819 },
820 .probe = men_z135_probe,
821 .remove = men_z135_remove,
822 .id_table = men_z135_ids,
823};
824
825/**
826 * men_z135_init() - Driver Registration Routine
827 *
828 * men_z135_init is the first routine called when the driver is loaded. All it
829 * does is register with the legacy MEN Chameleon subsystem.
830 */
831static int __init men_z135_init(void)
832{
833 int err;
834
835 err = uart_register_driver(&men_z135_driver);
836 if (err) {
837 pr_err("Failed to register UART: %d\n", err);
838 return err;
839 }
840
841 err = mcb_register_driver(&mcb_driver);
842 if (err) {
843 pr_err("Failed to register MCB driver: %d\n", err);
844 uart_unregister_driver(&men_z135_driver);
845 return err;
846 }
847
848 return 0;
849}
850module_init(men_z135_init);
851
852/**
853 * men_z135_exit() - Driver Exit Routine
854 *
855 * men_z135_exit is called just before the driver is removed from memory.
856 */
857static void __exit men_z135_exit(void)
858{
859 mcb_unregister_driver(&mcb_driver);
860 uart_unregister_driver(&men_z135_driver);
861}
862module_exit(men_z135_exit);
863
864MODULE_AUTHOR("Johannes Thumshirn <johannes.thumshirn@men.de>");
865MODULE_LICENSE("GPL v2");
866MODULE_DESCRIPTION("MEN 16z135 High Speed UART");
867MODULE_ALIAS("mcb:16z135");
diff --git a/drivers/tty/serial/msm_serial.c b/drivers/tty/serial/msm_serial.c
index 053b98eb46c8..778e376f197e 100644
--- a/drivers/tty/serial/msm_serial.c
+++ b/drivers/tty/serial/msm_serial.c
@@ -52,7 +52,6 @@ struct msm_port {
52 struct clk *clk; 52 struct clk *clk;
53 struct clk *pclk; 53 struct clk *pclk;
54 unsigned int imr; 54 unsigned int imr;
55 void __iomem *gsbi_base;
56 int is_uartdm; 55 int is_uartdm;
57 unsigned int old_snap_state; 56 unsigned int old_snap_state;
58}; 57};
@@ -599,9 +598,7 @@ static const char *msm_type(struct uart_port *port)
599static void msm_release_port(struct uart_port *port) 598static void msm_release_port(struct uart_port *port)
600{ 599{
601 struct platform_device *pdev = to_platform_device(port->dev); 600 struct platform_device *pdev = to_platform_device(port->dev);
602 struct msm_port *msm_port = UART_TO_MSM(port);
603 struct resource *uart_resource; 601 struct resource *uart_resource;
604 struct resource *gsbi_resource;
605 resource_size_t size; 602 resource_size_t size;
606 603
607 uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0); 604 uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -612,28 +609,12 @@ static void msm_release_port(struct uart_port *port)
612 release_mem_region(port->mapbase, size); 609 release_mem_region(port->mapbase, size);
613 iounmap(port->membase); 610 iounmap(port->membase);
614 port->membase = NULL; 611 port->membase = NULL;
615
616 if (msm_port->gsbi_base) {
617 writel_relaxed(GSBI_PROTOCOL_IDLE,
618 msm_port->gsbi_base + GSBI_CONTROL);
619
620 gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
621 if (unlikely(!gsbi_resource))
622 return;
623
624 size = resource_size(gsbi_resource);
625 release_mem_region(gsbi_resource->start, size);
626 iounmap(msm_port->gsbi_base);
627 msm_port->gsbi_base = NULL;
628 }
629} 612}
630 613
631static int msm_request_port(struct uart_port *port) 614static int msm_request_port(struct uart_port *port)
632{ 615{
633 struct msm_port *msm_port = UART_TO_MSM(port);
634 struct platform_device *pdev = to_platform_device(port->dev); 616 struct platform_device *pdev = to_platform_device(port->dev);
635 struct resource *uart_resource; 617 struct resource *uart_resource;
636 struct resource *gsbi_resource;
637 resource_size_t size; 618 resource_size_t size;
638 int ret; 619 int ret;
639 620
@@ -652,30 +633,8 @@ static int msm_request_port(struct uart_port *port)
652 goto fail_release_port; 633 goto fail_release_port;
653 } 634 }
654 635
655 gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
656 /* Is this a GSBI-based port? */
657 if (gsbi_resource) {
658 size = resource_size(gsbi_resource);
659
660 if (!request_mem_region(gsbi_resource->start, size,
661 "msm_serial")) {
662 ret = -EBUSY;
663 goto fail_release_port_membase;
664 }
665
666 msm_port->gsbi_base = ioremap(gsbi_resource->start, size);
667 if (!msm_port->gsbi_base) {
668 ret = -EBUSY;
669 goto fail_release_gsbi;
670 }
671 }
672
673 return 0; 636 return 0;
674 637
675fail_release_gsbi:
676 release_mem_region(gsbi_resource->start, size);
677fail_release_port_membase:
678 iounmap(port->membase);
679fail_release_port: 638fail_release_port:
680 release_mem_region(port->mapbase, size); 639 release_mem_region(port->mapbase, size);
681 return ret; 640 return ret;
@@ -683,7 +642,6 @@ fail_release_port:
683 642
684static void msm_config_port(struct uart_port *port, int flags) 643static void msm_config_port(struct uart_port *port, int flags)
685{ 644{
686 struct msm_port *msm_port = UART_TO_MSM(port);
687 int ret; 645 int ret;
688 if (flags & UART_CONFIG_TYPE) { 646 if (flags & UART_CONFIG_TYPE) {
689 port->type = PORT_MSM; 647 port->type = PORT_MSM;
@@ -691,9 +649,6 @@ static void msm_config_port(struct uart_port *port, int flags)
691 if (ret) 649 if (ret)
692 return; 650 return;
693 } 651 }
694 if (msm_port->gsbi_base)
695 writel_relaxed(GSBI_PROTOCOL_UART,
696 msm_port->gsbi_base + GSBI_CONTROL);
697} 652}
698 653
699static int msm_verify_port(struct uart_port *port, struct serial_struct *ser) 654static int msm_verify_port(struct uart_port *port, struct serial_struct *ser)
@@ -1110,6 +1065,7 @@ static struct of_device_id msm_match_table[] = {
1110 1065
1111static struct platform_driver msm_platform_driver = { 1066static struct platform_driver msm_platform_driver = {
1112 .remove = msm_serial_remove, 1067 .remove = msm_serial_remove,
1068 .probe = msm_serial_probe,
1113 .driver = { 1069 .driver = {
1114 .name = "msm_serial", 1070 .name = "msm_serial",
1115 .owner = THIS_MODULE, 1071 .owner = THIS_MODULE,
@@ -1125,7 +1081,7 @@ static int __init msm_serial_init(void)
1125 if (unlikely(ret)) 1081 if (unlikely(ret))
1126 return ret; 1082 return ret;
1127 1083
1128 ret = platform_driver_probe(&msm_platform_driver, msm_serial_probe); 1084 ret = platform_driver_register(&msm_platform_driver);
1129 if (unlikely(ret)) 1085 if (unlikely(ret))
1130 uart_unregister_driver(&msm_uart_driver); 1086 uart_unregister_driver(&msm_uart_driver);
1131 1087
diff --git a/drivers/tty/serial/msm_serial.h b/drivers/tty/serial/msm_serial.h
index 1e9b68b6f9eb..d98d45efdf86 100644
--- a/drivers/tty/serial/msm_serial.h
+++ b/drivers/tty/serial/msm_serial.h
@@ -109,11 +109,6 @@
109#define UART_ISR 0x0014 109#define UART_ISR 0x0014
110#define UART_ISR_TX_READY (1 << 7) 110#define UART_ISR_TX_READY (1 << 7)
111 111
112#define GSBI_CONTROL 0x0
113#define GSBI_PROTOCOL_CODE 0x30
114#define GSBI_PROTOCOL_UART 0x40
115#define GSBI_PROTOCOL_IDLE 0x0
116
117#define UARTDM_RXFS 0x50 112#define UARTDM_RXFS 0x50
118#define UARTDM_RXFS_BUF_SHIFT 0x7 113#define UARTDM_RXFS_BUF_SHIFT 0x7
119#define UARTDM_RXFS_BUF_MASK 0x7 114#define UARTDM_RXFS_BUF_MASK 0x7
diff --git a/drivers/tty/serial/mux.c b/drivers/tty/serial/mux.c
index 7fd6aaaacd8e..be127d0da32c 100644
--- a/drivers/tty/serial/mux.c
+++ b/drivers/tty/serial/mux.c
@@ -29,7 +29,7 @@
29#include <asm/irq.h> 29#include <asm/irq.h>
30#include <asm/parisc-device.h> 30#include <asm/parisc-device.h>
31 31
32#ifdef CONFIG_MAGIC_SYSRQ 32#if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
33#include <linux/sysrq.h> 33#include <linux/sysrq.h>
34#define SUPPORT_SYSRQ 34#define SUPPORT_SYSRQ
35#endif 35#endif
@@ -613,7 +613,7 @@ static void __exit mux_exit(void)
613{ 613{
614 /* Delete the Mux timer. */ 614 /* Delete the Mux timer. */
615 if(port_cnt > 0) { 615 if(port_cnt > 0) {
616 del_timer(&mux_timer); 616 del_timer_sync(&mux_timer);
617#ifdef CONFIG_SERIAL_MUX_CONSOLE 617#ifdef CONFIG_SERIAL_MUX_CONSOLE
618 unregister_console(&mux_console); 618 unregister_console(&mux_console);
619#endif 619#endif
diff --git a/drivers/tty/serial/mxs-auart.c b/drivers/tty/serial/mxs-auart.c
index aa97fd845b4d..4b5b3c2fe328 100644
--- a/drivers/tty/serial/mxs-auart.c
+++ b/drivers/tty/serial/mxs-auart.c
@@ -200,7 +200,7 @@ static void dma_tx_callback(void *param)
200 200
201 /* clear the bit used to serialize the DMA tx. */ 201 /* clear the bit used to serialize the DMA tx. */
202 clear_bit(MXS_AUART_DMA_TX_SYNC, &s->flags); 202 clear_bit(MXS_AUART_DMA_TX_SYNC, &s->flags);
203 smp_mb__after_clear_bit(); 203 smp_mb__after_atomic();
204 204
205 /* wake up the possible processes. */ 205 /* wake up the possible processes. */
206 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 206 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
@@ -275,7 +275,7 @@ static void mxs_auart_tx_chars(struct mxs_auart_port *s)
275 mxs_auart_dma_tx(s, i); 275 mxs_auart_dma_tx(s, i);
276 } else { 276 } else {
277 clear_bit(MXS_AUART_DMA_TX_SYNC, &s->flags); 277 clear_bit(MXS_AUART_DMA_TX_SYNC, &s->flags);
278 smp_mb__after_clear_bit(); 278 smp_mb__after_atomic();
279 } 279 }
280 return; 280 return;
281 } 281 }
diff --git a/drivers/tty/serial/of_serial.c b/drivers/tty/serial/of_serial.c
index 99246606a256..68d4455f3cf9 100644
--- a/drivers/tty/serial/of_serial.c
+++ b/drivers/tty/serial/of_serial.c
@@ -173,6 +173,7 @@ static int of_platform_serial_probe(struct platform_device *ofdev)
173 { 173 {
174 struct uart_8250_port port8250; 174 struct uart_8250_port port8250;
175 memset(&port8250, 0, sizeof(port8250)); 175 memset(&port8250, 0, sizeof(port8250));
176 port.type = port_type;
176 port8250.port = port; 177 port8250.port = port;
177 178
178 if (port.fifosize) 179 if (port.fifosize)
@@ -182,6 +183,10 @@ static int of_platform_serial_probe(struct platform_device *ofdev)
182 "auto-flow-control")) 183 "auto-flow-control"))
183 port8250.capabilities |= UART_CAP_AFE; 184 port8250.capabilities |= UART_CAP_AFE;
184 185
186 if (of_property_read_bool(ofdev->dev.of_node,
187 "has-hw-flow-control"))
188 port8250.port.flags |= UPF_HARD_FLOW;
189
185 ret = serial8250_register_8250_port(&port8250); 190 ret = serial8250_register_8250_port(&port8250);
186 break; 191 break;
187 } 192 }
diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c
index 08b6b9419f0d..d017cec8a34a 100644
--- a/drivers/tty/serial/omap-serial.c
+++ b/drivers/tty/serial/omap-serial.c
@@ -163,10 +163,6 @@ struct uart_omap_port {
163 u8 wakeups_enabled; 163 u8 wakeups_enabled;
164 u32 features; 164 u32 features;
165 165
166 int DTR_gpio;
167 int DTR_inverted;
168 int DTR_active;
169
170 struct serial_rs485 rs485; 166 struct serial_rs485 rs485;
171 int rts_gpio; 167 int rts_gpio;
172 168
@@ -184,8 +180,6 @@ static struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS];
184/* Forward declaration of functions */ 180/* Forward declaration of functions */
185static void serial_omap_mdr1_errataset(struct uart_omap_port *up, u8 mdr1); 181static void serial_omap_mdr1_errataset(struct uart_omap_port *up, u8 mdr1);
186 182
187static struct workqueue_struct *serial_omap_uart_wq;
188
189static inline unsigned int serial_in(struct uart_omap_port *up, int offset) 183static inline unsigned int serial_in(struct uart_omap_port *up, int offset)
190{ 184{
191 offset <<= up->port.regshift; 185 offset <<= up->port.regshift;
@@ -398,11 +392,8 @@ static void transmit_chars(struct uart_omap_port *up, unsigned int lsr)
398 break; 392 break;
399 } while (--count > 0); 393 } while (--count > 0);
400 394
401 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) { 395 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
402 spin_unlock(&up->port.lock);
403 uart_write_wakeup(&up->port); 396 uart_write_wakeup(&up->port);
404 spin_lock(&up->port.lock);
405 }
406 397
407 if (uart_circ_empty(xmit)) 398 if (uart_circ_empty(xmit))
408 serial_omap_stop_tx(&up->port); 399 serial_omap_stop_tx(&up->port);
@@ -697,16 +688,6 @@ static void serial_omap_set_mctrl(struct uart_port *port, unsigned int mctrl)
697 serial_out(up, UART_MCR, up->mcr); 688 serial_out(up, UART_MCR, up->mcr);
698 pm_runtime_mark_last_busy(up->dev); 689 pm_runtime_mark_last_busy(up->dev);
699 pm_runtime_put_autosuspend(up->dev); 690 pm_runtime_put_autosuspend(up->dev);
700
701 if (gpio_is_valid(up->DTR_gpio) &&
702 !!(mctrl & TIOCM_DTR) != up->DTR_active) {
703 up->DTR_active = !up->DTR_active;
704 if (gpio_cansleep(up->DTR_gpio))
705 schedule_work(&up->qos_work);
706 else
707 gpio_set_value(up->DTR_gpio,
708 up->DTR_active != up->DTR_inverted);
709 }
710} 691}
711 692
712static void serial_omap_break_ctl(struct uart_port *port, int break_state) 693static void serial_omap_break_ctl(struct uart_port *port, int break_state)
@@ -850,9 +831,6 @@ static void serial_omap_uart_qos_work(struct work_struct *work)
850 qos_work); 831 qos_work);
851 832
852 pm_qos_update_request(&up->pm_qos_request, up->latency); 833 pm_qos_update_request(&up->pm_qos_request, up->latency);
853 if (gpio_is_valid(up->DTR_gpio))
854 gpio_set_value_cansleep(up->DTR_gpio,
855 up->DTR_active != up->DTR_inverted);
856} 834}
857 835
858static void 836static void
@@ -1420,7 +1398,7 @@ serial_omap_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
1420 1398
1421 switch (cmd) { 1399 switch (cmd) {
1422 case TIOCSRS485: 1400 case TIOCSRS485:
1423 if (copy_from_user(&rs485conf, (struct serial_rs485 *) arg, 1401 if (copy_from_user(&rs485conf, (void __user *) arg,
1424 sizeof(rs485conf))) 1402 sizeof(rs485conf)))
1425 return -EFAULT; 1403 return -EFAULT;
1426 1404
@@ -1428,7 +1406,7 @@ serial_omap_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
1428 break; 1406 break;
1429 1407
1430 case TIOCGRS485: 1408 case TIOCGRS485:
1431 if (copy_to_user((struct serial_rs485 *) arg, 1409 if (copy_to_user((void __user *) arg,
1432 &(to_uart_omap_port(port)->rs485), 1410 &(to_uart_omap_port(port)->rs485),
1433 sizeof(rs485conf))) 1411 sizeof(rs485conf)))
1434 return -EFAULT; 1412 return -EFAULT;
@@ -1614,7 +1592,7 @@ static int serial_omap_probe_rs485(struct uart_omap_port *up,
1614 /* check for tx enable gpio */ 1592 /* check for tx enable gpio */
1615 up->rts_gpio = of_get_named_gpio_flags(np, "rts-gpio", 0, &flags); 1593 up->rts_gpio = of_get_named_gpio_flags(np, "rts-gpio", 0, &flags);
1616 if (gpio_is_valid(up->rts_gpio)) { 1594 if (gpio_is_valid(up->rts_gpio)) {
1617 ret = gpio_request(up->rts_gpio, "omap-serial"); 1595 ret = devm_gpio_request(up->dev, up->rts_gpio, "omap-serial");
1618 if (ret < 0) 1596 if (ret < 0)
1619 return ret; 1597 return ret;
1620 ret = gpio_direction_output(up->rts_gpio, 1598 ret = gpio_direction_output(up->rts_gpio,
@@ -1644,10 +1622,13 @@ static int serial_omap_probe_rs485(struct uart_omap_port *up,
1644 1622
1645static int serial_omap_probe(struct platform_device *pdev) 1623static int serial_omap_probe(struct platform_device *pdev)
1646{ 1624{
1647 struct uart_omap_port *up;
1648 struct resource *mem, *irq;
1649 struct omap_uart_port_info *omap_up_info = dev_get_platdata(&pdev->dev); 1625 struct omap_uart_port_info *omap_up_info = dev_get_platdata(&pdev->dev);
1650 int ret, uartirq = 0, wakeirq = 0; 1626 struct uart_omap_port *up;
1627 struct resource *mem;
1628 void __iomem *base;
1629 int uartirq = 0;
1630 int wakeirq = 0;
1631 int ret;
1651 1632
1652 /* The optional wakeirq may be specified in the board dts file */ 1633 /* The optional wakeirq may be specified in the board dts file */
1653 if (pdev->dev.of_node) { 1634 if (pdev->dev.of_node) {
@@ -1658,48 +1639,19 @@ static int serial_omap_probe(struct platform_device *pdev)
1658 omap_up_info = of_get_uart_port_info(&pdev->dev); 1639 omap_up_info = of_get_uart_port_info(&pdev->dev);
1659 pdev->dev.platform_data = omap_up_info; 1640 pdev->dev.platform_data = omap_up_info;
1660 } else { 1641 } else {
1661 irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 1642 uartirq = platform_get_irq(pdev, 0);
1662 if (!irq) { 1643 if (uartirq < 0)
1663 dev_err(&pdev->dev, "no irq resource?\n"); 1644 return -EPROBE_DEFER;
1664 return -ENODEV;
1665 }
1666 uartirq = irq->start;
1667 }
1668
1669 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1670 if (!mem) {
1671 dev_err(&pdev->dev, "no mem resource?\n");
1672 return -ENODEV;
1673 }
1674
1675 if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem),
1676 pdev->dev.driver->name)) {
1677 dev_err(&pdev->dev, "memory region already claimed\n");
1678 return -EBUSY;
1679 }
1680
1681 if (gpio_is_valid(omap_up_info->DTR_gpio) &&
1682 omap_up_info->DTR_present) {
1683 ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial");
1684 if (ret < 0)
1685 return ret;
1686 ret = gpio_direction_output(omap_up_info->DTR_gpio,
1687 omap_up_info->DTR_inverted);
1688 if (ret < 0)
1689 return ret;
1690 } 1645 }
1691 1646
1692 up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL); 1647 up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL);
1693 if (!up) 1648 if (!up)
1694 return -ENOMEM; 1649 return -ENOMEM;
1695 1650
1696 if (gpio_is_valid(omap_up_info->DTR_gpio) && 1651 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1697 omap_up_info->DTR_present) { 1652 base = devm_ioremap_resource(&pdev->dev, mem);
1698 up->DTR_gpio = omap_up_info->DTR_gpio; 1653 if (IS_ERR(base))
1699 up->DTR_inverted = omap_up_info->DTR_inverted; 1654 return PTR_ERR(base);
1700 } else
1701 up->DTR_gpio = -EINVAL;
1702 up->DTR_active = 0;
1703 1655
1704 up->dev = &pdev->dev; 1656 up->dev = &pdev->dev;
1705 up->port.dev = &pdev->dev; 1657 up->port.dev = &pdev->dev;
@@ -1733,14 +1685,7 @@ static int serial_omap_probe(struct platform_device *pdev)
1733 1685
1734 sprintf(up->name, "OMAP UART%d", up->port.line); 1686 sprintf(up->name, "OMAP UART%d", up->port.line);
1735 up->port.mapbase = mem->start; 1687 up->port.mapbase = mem->start;
1736 up->port.membase = devm_ioremap(&pdev->dev, mem->start, 1688 up->port.membase = base;
1737 resource_size(mem));
1738 if (!up->port.membase) {
1739 dev_err(&pdev->dev, "can't ioremap UART\n");
1740 ret = -ENOMEM;
1741 goto err_ioremap;
1742 }
1743
1744 up->port.flags = omap_up_info->flags; 1689 up->port.flags = omap_up_info->flags;
1745 up->port.uartclk = omap_up_info->uartclk; 1690 up->port.uartclk = omap_up_info->uartclk;
1746 if (!up->port.uartclk) { 1691 if (!up->port.uartclk) {
@@ -1754,12 +1699,12 @@ static int serial_omap_probe(struct platform_device *pdev)
1754 up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; 1699 up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
1755 pm_qos_add_request(&up->pm_qos_request, 1700 pm_qos_add_request(&up->pm_qos_request,
1756 PM_QOS_CPU_DMA_LATENCY, up->latency); 1701 PM_QOS_CPU_DMA_LATENCY, up->latency);
1757 serial_omap_uart_wq = create_singlethread_workqueue(up->name);
1758 INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); 1702 INIT_WORK(&up->qos_work, serial_omap_uart_qos_work);
1759 1703
1760 platform_set_drvdata(pdev, up); 1704 platform_set_drvdata(pdev, up);
1761 if (omap_up_info->autosuspend_timeout == 0) 1705 if (omap_up_info->autosuspend_timeout == 0)
1762 omap_up_info->autosuspend_timeout = -1; 1706 omap_up_info->autosuspend_timeout = -1;
1707
1763 device_init_wakeup(up->dev, true); 1708 device_init_wakeup(up->dev, true);
1764 pm_runtime_use_autosuspend(&pdev->dev); 1709 pm_runtime_use_autosuspend(&pdev->dev);
1765 pm_runtime_set_autosuspend_delay(&pdev->dev, 1710 pm_runtime_set_autosuspend_delay(&pdev->dev,
@@ -1786,7 +1731,6 @@ static int serial_omap_probe(struct platform_device *pdev)
1786err_add_port: 1731err_add_port:
1787 pm_runtime_put(&pdev->dev); 1732 pm_runtime_put(&pdev->dev);
1788 pm_runtime_disable(&pdev->dev); 1733 pm_runtime_disable(&pdev->dev);
1789err_ioremap:
1790err_rs485: 1734err_rs485:
1791err_port_line: 1735err_port_line:
1792 dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", 1736 dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n",
diff --git a/drivers/tty/serial/pch_uart.c b/drivers/tty/serial/pch_uart.c
index 0931b3fe9edf..0cb6a8e52bd0 100644
--- a/drivers/tty/serial/pch_uart.c
+++ b/drivers/tty/serial/pch_uart.c
@@ -257,6 +257,8 @@ struct eg20t_port {
257 dma_addr_t rx_buf_dma; 257 dma_addr_t rx_buf_dma;
258 258
259 struct dentry *debugfs; 259 struct dentry *debugfs;
260#define IRQ_NAME_SIZE 17
261 char irq_name[IRQ_NAME_SIZE];
260 262
261 /* protect the eg20t_port private structure and io access to membase */ 263 /* protect the eg20t_port private structure and io access to membase */
262 spinlock_t lock; 264 spinlock_t lock;
@@ -1343,7 +1345,7 @@ static int pch_uart_startup(struct uart_port *port)
1343 return ret; 1345 return ret;
1344 1346
1345 ret = request_irq(priv->port.irq, pch_uart_interrupt, IRQF_SHARED, 1347 ret = request_irq(priv->port.irq, pch_uart_interrupt, IRQF_SHARED,
1346 KBUILD_MODNAME, priv); 1348 priv->irq_name, priv);
1347 if (ret < 0) 1349 if (ret < 0)
1348 return ret; 1350 return ret;
1349 1351
@@ -1588,13 +1590,8 @@ static void pch_uart_put_poll_char(struct uart_port *port,
1588 wait_for_xmitr(priv, UART_LSR_THRE); 1590 wait_for_xmitr(priv, UART_LSR_THRE);
1589 /* 1591 /*
1590 * Send the character out. 1592 * Send the character out.
1591 * If a LF, also do CR...
1592 */ 1593 */
1593 iowrite8(c, priv->membase + PCH_UART_THR); 1594 iowrite8(c, priv->membase + PCH_UART_THR);
1594 if (c == 10) {
1595 wait_for_xmitr(priv, UART_LSR_THRE);
1596 iowrite8(13, priv->membase + PCH_UART_THR);
1597 }
1598 1595
1599 /* 1596 /*
1600 * Finally, wait for transmitter to become empty 1597 * Finally, wait for transmitter to become empty
@@ -1818,6 +1815,10 @@ static struct eg20t_port *pch_uart_init_port(struct pci_dev *pdev,
1818 priv->port.line = board->line_no; 1815 priv->port.line = board->line_no;
1819 priv->trigger = PCH_UART_HAL_TRIGGER_M; 1816 priv->trigger = PCH_UART_HAL_TRIGGER_M;
1820 1817
1818 snprintf(priv->irq_name, IRQ_NAME_SIZE,
1819 KBUILD_MODNAME ":" PCH_UART_DRIVER_DEVICE "%d",
1820 priv->port.line);
1821
1821 spin_lock_init(&priv->port.lock); 1822 spin_lock_init(&priv->port.lock);
1822 1823
1823 pci_set_drvdata(pdev, priv); 1824 pci_set_drvdata(pdev, priv);
diff --git a/drivers/tty/serial/pxa.c b/drivers/tty/serial/pxa.c
index f9f20f383760..9e7ee39f8b2a 100644
--- a/drivers/tty/serial/pxa.c
+++ b/drivers/tty/serial/pxa.c
@@ -711,13 +711,8 @@ static void serial_pxa_put_poll_char(struct uart_port *port,
711 wait_for_xmitr(up); 711 wait_for_xmitr(up);
712 /* 712 /*
713 * Send the character out. 713 * Send the character out.
714 * If a LF, also do CR...
715 */ 714 */
716 serial_out(up, UART_TX, c); 715 serial_out(up, UART_TX, c);
717 if (c == 10) {
718 wait_for_xmitr(up);
719 serial_out(up, UART_TX, 13);
720 }
721 716
722 /* 717 /*
723 * Finally, wait for transmitter to become empty 718 * Finally, wait for transmitter to become empty
diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c
index 1f5505e7f90d..329337711bb0 100644
--- a/drivers/tty/serial/samsung.c
+++ b/drivers/tty/serial/samsung.c
@@ -53,6 +53,29 @@
53 53
54#include "samsung.h" 54#include "samsung.h"
55 55
56#if defined(CONFIG_SERIAL_SAMSUNG_DEBUG) && \
57 defined(CONFIG_DEBUG_LL) && \
58 !defined(MODULE)
59
60extern void printascii(const char *);
61
62__printf(1, 2)
63static void dbg(const char *fmt, ...)
64{
65 va_list va;
66 char buff[256];
67
68 va_start(va, fmt);
69 vscnprintf(buff, sizeof(buf), fmt, va);
70 va_end(va);
71
72 printascii(buff);
73}
74
75#else
76#define dbg(fmt, ...) do { if (0) no_printk(fmt, ##__VA_ARGS__); } while (0)
77#endif
78
56/* UART name and device definitions */ 79/* UART name and device definitions */
57 80
58#define S3C24XX_SERIAL_NAME "ttySAC" 81#define S3C24XX_SERIAL_NAME "ttySAC"
@@ -468,8 +491,8 @@ static int s3c24xx_serial_startup(struct uart_port *port)
468 struct s3c24xx_uart_port *ourport = to_ourport(port); 491 struct s3c24xx_uart_port *ourport = to_ourport(port);
469 int ret; 492 int ret;
470 493
471 dbg("s3c24xx_serial_startup: port=%p (%08lx,%p)\n", 494 dbg("s3c24xx_serial_startup: port=%p (%08llx,%p)\n",
472 port->mapbase, port->membase); 495 port, (unsigned long long)port->mapbase, port->membase);
473 496
474 rx_enabled(port) = 1; 497 rx_enabled(port) = 1;
475 498
@@ -514,8 +537,8 @@ static int s3c64xx_serial_startup(struct uart_port *port)
514 struct s3c24xx_uart_port *ourport = to_ourport(port); 537 struct s3c24xx_uart_port *ourport = to_ourport(port);
515 int ret; 538 int ret;
516 539
517 dbg("s3c64xx_serial_startup: port=%p (%08lx,%p)\n", 540 dbg("s3c64xx_serial_startup: port=%p (%08llx,%p)\n",
518 port->mapbase, port->membase); 541 port, (unsigned long long)port->mapbase, port->membase);
519 542
520 wr_regl(port, S3C64XX_UINTM, 0xf); 543 wr_regl(port, S3C64XX_UINTM, 0xf);
521 544
@@ -1160,7 +1183,7 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
1160 return -EINVAL; 1183 return -EINVAL;
1161 } 1184 }
1162 1185
1163 dbg("resource %p (%lx..%lx)\n", res, res->start, res->end); 1186 dbg("resource %pR)\n", res);
1164 1187
1165 port->membase = devm_ioremap(port->dev, res->start, resource_size(res)); 1188 port->membase = devm_ioremap(port->dev, res->start, resource_size(res));
1166 if (!port->membase) { 1189 if (!port->membase) {
@@ -1203,7 +1226,7 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
1203 wr_regl(port, S3C64XX_UINTSP, 0xf); 1226 wr_regl(port, S3C64XX_UINTSP, 0xf);
1204 } 1227 }
1205 1228
1206 dbg("port: map=%08x, mem=%08x, irq=%d (%d,%d), clock=%ld\n", 1229 dbg("port: map=%08x, mem=%p, irq=%d (%d,%d), clock=%u\n",
1207 port->mapbase, port->membase, port->irq, 1230 port->mapbase, port->membase, port->irq,
1208 ourport->rx_irq, ourport->tx_irq, port->uartclk); 1231 ourport->rx_irq, ourport->tx_irq, port->uartclk);
1209 1232
diff --git a/drivers/tty/serial/samsung.h b/drivers/tty/serial/samsung.h
index 8827e5424cef..eb071dd19b2d 100644
--- a/drivers/tty/serial/samsung.h
+++ b/drivers/tty/serial/samsung.h
@@ -1,3 +1,6 @@
1#ifndef __SAMSUNG_H
2#define __SAMSUNG_H
3
1/* 4/*
2 * Driver for Samsung SoC onboard UARTs. 5 * Driver for Samsung SoC onboard UARTs.
3 * 6 *
@@ -77,24 +80,4 @@ struct s3c24xx_uart_port {
77#define wr_regb(port, reg, val) __raw_writeb(val, portaddr(port, reg)) 80#define wr_regb(port, reg, val) __raw_writeb(val, portaddr(port, reg))
78#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg)) 81#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg))
79 82
80#if defined(CONFIG_SERIAL_SAMSUNG_DEBUG) && \
81 defined(CONFIG_DEBUG_LL) && \
82 !defined(MODULE)
83
84extern void printascii(const char *);
85
86static void dbg(const char *fmt, ...)
87{
88 va_list va;
89 char buff[256];
90
91 va_start(va, fmt);
92 vsprintf(buff, fmt, va);
93 va_end(va);
94
95 printascii(buff);
96}
97
98#else
99#define dbg(x...) do { } while (0)
100#endif 83#endif
diff --git a/drivers/tty/serial/sc16is7xx.c b/drivers/tty/serial/sc16is7xx.c
new file mode 100644
index 000000000000..1b6a77c4b2cb
--- /dev/null
+++ b/drivers/tty/serial/sc16is7xx.c
@@ -0,0 +1,1277 @@
1/*
2 * SC16IS7xx tty serial driver - Copyright (C) 2014 GridPoint
3 * Author: Jon Ringle <jringle@gridpoint.com>
4 *
5 * Based on max310x.c, by Alexander Shiyan <shc_work@mail.ru>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 */
13
14#include <linux/bitops.h>
15#include <linux/clk.h>
16#include <linux/delay.h>
17#include <linux/device.h>
18#include <linux/gpio.h>
19#include <linux/i2c.h>
20#include <linux/module.h>
21#include <linux/of.h>
22#include <linux/of_device.h>
23#include <linux/regmap.h>
24#include <linux/serial_core.h>
25#include <linux/serial.h>
26#include <linux/tty.h>
27#include <linux/tty_flip.h>
28#include <linux/uaccess.h>
29
30#define SC16IS7XX_NAME "sc16is7xx"
31
32/* SC16IS7XX register definitions */
33#define SC16IS7XX_RHR_REG (0x00) /* RX FIFO */
34#define SC16IS7XX_THR_REG (0x00) /* TX FIFO */
35#define SC16IS7XX_IER_REG (0x01) /* Interrupt enable */
36#define SC16IS7XX_IIR_REG (0x02) /* Interrupt Identification */
37#define SC16IS7XX_FCR_REG (0x02) /* FIFO control */
38#define SC16IS7XX_LCR_REG (0x03) /* Line Control */
39#define SC16IS7XX_MCR_REG (0x04) /* Modem Control */
40#define SC16IS7XX_LSR_REG (0x05) /* Line Status */
41#define SC16IS7XX_MSR_REG (0x06) /* Modem Status */
42#define SC16IS7XX_SPR_REG (0x07) /* Scratch Pad */
43#define SC16IS7XX_TXLVL_REG (0x08) /* TX FIFO level */
44#define SC16IS7XX_RXLVL_REG (0x09) /* RX FIFO level */
45#define SC16IS7XX_IODIR_REG (0x0a) /* I/O Direction
46 * - only on 75x/76x
47 */
48#define SC16IS7XX_IOSTATE_REG (0x0b) /* I/O State
49 * - only on 75x/76x
50 */
51#define SC16IS7XX_IOINTENA_REG (0x0c) /* I/O Interrupt Enable
52 * - only on 75x/76x
53 */
54#define SC16IS7XX_IOCONTROL_REG (0x0e) /* I/O Control
55 * - only on 75x/76x
56 */
57#define SC16IS7XX_EFCR_REG (0x0f) /* Extra Features Control */
58
59/* TCR/TLR Register set: Only if ((MCR[2] == 1) && (EFR[4] == 1)) */
60#define SC16IS7XX_TCR_REG (0x06) /* Transmit control */
61#define SC16IS7XX_TLR_REG (0x07) /* Trigger level */
62
63/* Special Register set: Only if ((LCR[7] == 1) && (LCR != 0xBF)) */
64#define SC16IS7XX_DLL_REG (0x00) /* Divisor Latch Low */
65#define SC16IS7XX_DLH_REG (0x01) /* Divisor Latch High */
66
67/* Enhanced Register set: Only if (LCR == 0xBF) */
68#define SC16IS7XX_EFR_REG (0x02) /* Enhanced Features */
69#define SC16IS7XX_XON1_REG (0x04) /* Xon1 word */
70#define SC16IS7XX_XON2_REG (0x05) /* Xon2 word */
71#define SC16IS7XX_XOFF1_REG (0x06) /* Xoff1 word */
72#define SC16IS7XX_XOFF2_REG (0x07) /* Xoff2 word */
73
74/* IER register bits */
75#define SC16IS7XX_IER_RDI_BIT (1 << 0) /* Enable RX data interrupt */
76#define SC16IS7XX_IER_THRI_BIT (1 << 1) /* Enable TX holding register
77 * interrupt */
78#define SC16IS7XX_IER_RLSI_BIT (1 << 2) /* Enable RX line status
79 * interrupt */
80#define SC16IS7XX_IER_MSI_BIT (1 << 3) /* Enable Modem status
81 * interrupt */
82
83/* IER register bits - write only if (EFR[4] == 1) */
84#define SC16IS7XX_IER_SLEEP_BIT (1 << 4) /* Enable Sleep mode */
85#define SC16IS7XX_IER_XOFFI_BIT (1 << 5) /* Enable Xoff interrupt */
86#define SC16IS7XX_IER_RTSI_BIT (1 << 6) /* Enable nRTS interrupt */
87#define SC16IS7XX_IER_CTSI_BIT (1 << 7) /* Enable nCTS interrupt */
88
89/* FCR register bits */
90#define SC16IS7XX_FCR_FIFO_BIT (1 << 0) /* Enable FIFO */
91#define SC16IS7XX_FCR_RXRESET_BIT (1 << 1) /* Reset RX FIFO */
92#define SC16IS7XX_FCR_TXRESET_BIT (1 << 2) /* Reset TX FIFO */
93#define SC16IS7XX_FCR_RXLVLL_BIT (1 << 6) /* RX Trigger level LSB */
94#define SC16IS7XX_FCR_RXLVLH_BIT (1 << 7) /* RX Trigger level MSB */
95
96/* FCR register bits - write only if (EFR[4] == 1) */
97#define SC16IS7XX_FCR_TXLVLL_BIT (1 << 4) /* TX Trigger level LSB */
98#define SC16IS7XX_FCR_TXLVLH_BIT (1 << 5) /* TX Trigger level MSB */
99
100/* IIR register bits */
101#define SC16IS7XX_IIR_NO_INT_BIT (1 << 0) /* No interrupts pending */
102#define SC16IS7XX_IIR_ID_MASK 0x3e /* Mask for the interrupt ID */
103#define SC16IS7XX_IIR_THRI_SRC 0x02 /* TX holding register empty */
104#define SC16IS7XX_IIR_RDI_SRC 0x04 /* RX data interrupt */
105#define SC16IS7XX_IIR_RLSE_SRC 0x06 /* RX line status error */
106#define SC16IS7XX_IIR_RTOI_SRC 0x0c /* RX time-out interrupt */
107#define SC16IS7XX_IIR_MSI_SRC 0x00 /* Modem status interrupt
108 * - only on 75x/76x
109 */
110#define SC16IS7XX_IIR_INPIN_SRC 0x30 /* Input pin change of state
111 * - only on 75x/76x
112 */
113#define SC16IS7XX_IIR_XOFFI_SRC 0x10 /* Received Xoff */
114#define SC16IS7XX_IIR_CTSRTS_SRC 0x20 /* nCTS,nRTS change of state
115 * from active (LOW)
116 * to inactive (HIGH)
117 */
118/* LCR register bits */
119#define SC16IS7XX_LCR_LENGTH0_BIT (1 << 0) /* Word length bit 0 */
120#define SC16IS7XX_LCR_LENGTH1_BIT (1 << 1) /* Word length bit 1
121 *
122 * Word length bits table:
123 * 00 -> 5 bit words
124 * 01 -> 6 bit words
125 * 10 -> 7 bit words
126 * 11 -> 8 bit words
127 */
128#define SC16IS7XX_LCR_STOPLEN_BIT (1 << 2) /* STOP length bit
129 *
130 * STOP length bit table:
131 * 0 -> 1 stop bit
132 * 1 -> 1-1.5 stop bits if
133 * word length is 5,
134 * 2 stop bits otherwise
135 */
136#define SC16IS7XX_LCR_PARITY_BIT (1 << 3) /* Parity bit enable */
137#define SC16IS7XX_LCR_EVENPARITY_BIT (1 << 4) /* Even parity bit enable */
138#define SC16IS7XX_LCR_FORCEPARITY_BIT (1 << 5) /* 9-bit multidrop parity */
139#define SC16IS7XX_LCR_TXBREAK_BIT (1 << 6) /* TX break enable */
140#define SC16IS7XX_LCR_DLAB_BIT (1 << 7) /* Divisor Latch enable */
141#define SC16IS7XX_LCR_WORD_LEN_5 (0x00)
142#define SC16IS7XX_LCR_WORD_LEN_6 (0x01)
143#define SC16IS7XX_LCR_WORD_LEN_7 (0x02)
144#define SC16IS7XX_LCR_WORD_LEN_8 (0x03)
145#define SC16IS7XX_LCR_CONF_MODE_A SC16IS7XX_LCR_DLAB_BIT /* Special
146 * reg set */
147#define SC16IS7XX_LCR_CONF_MODE_B 0xBF /* Enhanced
148 * reg set */
149
150/* MCR register bits */
151#define SC16IS7XX_MCR_DTR_BIT (1 << 0) /* DTR complement
152 * - only on 75x/76x
153 */
154#define SC16IS7XX_MCR_RTS_BIT (1 << 1) /* RTS complement */
155#define SC16IS7XX_MCR_TCRTLR_BIT (1 << 2) /* TCR/TLR register enable */
156#define SC16IS7XX_MCR_LOOP_BIT (1 << 4) /* Enable loopback test mode */
157#define SC16IS7XX_MCR_XONANY_BIT (1 << 5) /* Enable Xon Any
158 * - write enabled
159 * if (EFR[4] == 1)
160 */
161#define SC16IS7XX_MCR_IRDA_BIT (1 << 6) /* Enable IrDA mode
162 * - write enabled
163 * if (EFR[4] == 1)
164 */
165#define SC16IS7XX_MCR_CLKSEL_BIT (1 << 7) /* Divide clock by 4
166 * - write enabled
167 * if (EFR[4] == 1)
168 */
169
170/* LSR register bits */
171#define SC16IS7XX_LSR_DR_BIT (1 << 0) /* Receiver data ready */
172#define SC16IS7XX_LSR_OE_BIT (1 << 1) /* Overrun Error */
173#define SC16IS7XX_LSR_PE_BIT (1 << 2) /* Parity Error */
174#define SC16IS7XX_LSR_FE_BIT (1 << 3) /* Frame Error */
175#define SC16IS7XX_LSR_BI_BIT (1 << 4) /* Break Interrupt */
176#define SC16IS7XX_LSR_BRK_ERROR_MASK 0x1E /* BI, FE, PE, OE bits */
177#define SC16IS7XX_LSR_THRE_BIT (1 << 5) /* TX holding register empty */
178#define SC16IS7XX_LSR_TEMT_BIT (1 << 6) /* Transmitter empty */
179#define SC16IS7XX_LSR_FIFOE_BIT (1 << 7) /* Fifo Error */
180
181/* MSR register bits */
182#define SC16IS7XX_MSR_DCTS_BIT (1 << 0) /* Delta CTS Clear To Send */
183#define SC16IS7XX_MSR_DDSR_BIT (1 << 1) /* Delta DSR Data Set Ready
184 * or (IO4)
185 * - only on 75x/76x
186 */
187#define SC16IS7XX_MSR_DRI_BIT (1 << 2) /* Delta RI Ring Indicator
188 * or (IO7)
189 * - only on 75x/76x
190 */
191#define SC16IS7XX_MSR_DCD_BIT (1 << 3) /* Delta CD Carrier Detect
192 * or (IO6)
193 * - only on 75x/76x
194 */
195#define SC16IS7XX_MSR_CTS_BIT (1 << 0) /* CTS */
196#define SC16IS7XX_MSR_DSR_BIT (1 << 1) /* DSR (IO4)
197 * - only on 75x/76x
198 */
199#define SC16IS7XX_MSR_RI_BIT (1 << 2) /* RI (IO7)
200 * - only on 75x/76x
201 */
202#define SC16IS7XX_MSR_CD_BIT (1 << 3) /* CD (IO6)
203 * - only on 75x/76x
204 */
205#define SC16IS7XX_MSR_DELTA_MASK 0x0F /* Any of the delta bits! */
206
207/*
208 * TCR register bits
209 * TCR trigger levels are available from 0 to 60 characters with a granularity
210 * of four.
211 * The programmer must program the TCR such that TCR[3:0] > TCR[7:4]. There is
212 * no built-in hardware check to make sure this condition is met. Also, the TCR
213 * must be programmed with this condition before auto RTS or software flow
214 * control is enabled to avoid spurious operation of the device.
215 */
216#define SC16IS7XX_TCR_RX_HALT(words) ((((words) / 4) & 0x0f) << 0)
217#define SC16IS7XX_TCR_RX_RESUME(words) ((((words) / 4) & 0x0f) << 4)
218
219/*
220 * TLR register bits
221 * If TLR[3:0] or TLR[7:4] are logical 0, the selectable trigger levels via the
222 * FIFO Control Register (FCR) are used for the transmit and receive FIFO
223 * trigger levels. Trigger levels from 4 characters to 60 characters are
224 * available with a granularity of four.
225 *
226 * When the trigger level setting in TLR is zero, the SC16IS740/750/760 uses the
227 * trigger level setting defined in FCR. If TLR has non-zero trigger level value
228 * the trigger level defined in FCR is discarded. This applies to both transmit
229 * FIFO and receive FIFO trigger level setting.
230 *
231 * When TLR is used for RX trigger level control, FCR[7:6] should be left at the
232 * default state, that is, '00'.
233 */
234#define SC16IS7XX_TLR_TX_TRIGGER(words) ((((words) / 4) & 0x0f) << 0)
235#define SC16IS7XX_TLR_RX_TRIGGER(words) ((((words) / 4) & 0x0f) << 4)
236
237/* IOControl register bits (Only 750/760) */
238#define SC16IS7XX_IOCONTROL_LATCH_BIT (1 << 0) /* Enable input latching */
239#define SC16IS7XX_IOCONTROL_GPIO_BIT (1 << 1) /* Enable GPIO[7:4] */
240#define SC16IS7XX_IOCONTROL_SRESET_BIT (1 << 3) /* Software Reset */
241
242/* EFCR register bits */
243#define SC16IS7XX_EFCR_9BIT_MODE_BIT (1 << 0) /* Enable 9-bit or Multidrop
244 * mode (RS485) */
245#define SC16IS7XX_EFCR_RXDISABLE_BIT (1 << 1) /* Disable receiver */
246#define SC16IS7XX_EFCR_TXDISABLE_BIT (1 << 2) /* Disable transmitter */
247#define SC16IS7XX_EFCR_AUTO_RS485_BIT (1 << 4) /* Auto RS485 RTS direction */
248#define SC16IS7XX_EFCR_RTS_INVERT_BIT (1 << 5) /* RTS output inversion */
249#define SC16IS7XX_EFCR_IRDA_MODE_BIT (1 << 7) /* IrDA mode
250 * 0 = rate upto 115.2 kbit/s
251 * - Only 750/760
252 * 1 = rate upto 1.152 Mbit/s
253 * - Only 760
254 */
255
256/* EFR register bits */
257#define SC16IS7XX_EFR_AUTORTS_BIT (1 << 6) /* Auto RTS flow ctrl enable */
258#define SC16IS7XX_EFR_AUTOCTS_BIT (1 << 7) /* Auto CTS flow ctrl enable */
259#define SC16IS7XX_EFR_XOFF2_DETECT_BIT (1 << 5) /* Enable Xoff2 detection */
260#define SC16IS7XX_EFR_ENABLE_BIT (1 << 4) /* Enable enhanced functions
261 * and writing to IER[7:4],
262 * FCR[5:4], MCR[7:5]
263 */
264#define SC16IS7XX_EFR_SWFLOW3_BIT (1 << 3) /* SWFLOW bit 3 */
265#define SC16IS7XX_EFR_SWFLOW2_BIT (1 << 2) /* SWFLOW bit 2
266 *
267 * SWFLOW bits 3 & 2 table:
268 * 00 -> no transmitter flow
269 * control
270 * 01 -> transmitter generates
271 * XON2 and XOFF2
272 * 10 -> transmitter generates
273 * XON1 and XOFF1
274 * 11 -> transmitter generates
275 * XON1, XON2, XOFF1 and
276 * XOFF2
277 */
278#define SC16IS7XX_EFR_SWFLOW1_BIT (1 << 1) /* SWFLOW bit 2 */
279#define SC16IS7XX_EFR_SWFLOW0_BIT (1 << 0) /* SWFLOW bit 3
280 *
281 * SWFLOW bits 3 & 2 table:
282 * 00 -> no received flow
283 * control
284 * 01 -> receiver compares
285 * XON2 and XOFF2
286 * 10 -> receiver compares
287 * XON1 and XOFF1
288 * 11 -> receiver compares
289 * XON1, XON2, XOFF1 and
290 * XOFF2
291 */
292
293/* Misc definitions */
294#define SC16IS7XX_FIFO_SIZE (64)
295#define SC16IS7XX_REG_SHIFT 2
296
297struct sc16is7xx_devtype {
298 char name[10];
299 int nr_gpio;
300 int nr_uart;
301};
302
303struct sc16is7xx_one {
304 struct uart_port port;
305 struct work_struct tx_work;
306 struct work_struct md_work;
307
308 struct serial_rs485 rs485;
309};
310
311struct sc16is7xx_port {
312 struct uart_driver uart;
313 struct sc16is7xx_devtype *devtype;
314 struct regmap *regmap;
315 struct mutex mutex;
316 struct clk *clk;
317#ifdef CONFIG_GPIOLIB
318 struct gpio_chip gpio;
319#endif
320 unsigned char buf[SC16IS7XX_FIFO_SIZE];
321 struct sc16is7xx_one p[0];
322};
323
324#define to_sc16is7xx_one(p,e) ((container_of((p), struct sc16is7xx_one, e)))
325
326static u8 sc16is7xx_port_read(struct uart_port *port, u8 reg)
327{
328 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
329 unsigned int val = 0;
330
331 regmap_read(s->regmap,
332 (reg << SC16IS7XX_REG_SHIFT) | port->line, &val);
333
334 return val;
335}
336
337static void sc16is7xx_port_write(struct uart_port *port, u8 reg, u8 val)
338{
339 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
340
341 regmap_write(s->regmap,
342 (reg << SC16IS7XX_REG_SHIFT) | port->line, val);
343}
344
345static void sc16is7xx_port_update(struct uart_port *port, u8 reg,
346 u8 mask, u8 val)
347{
348 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
349
350 regmap_update_bits(s->regmap,
351 (reg << SC16IS7XX_REG_SHIFT) | port->line,
352 mask, val);
353}
354
355
356static void sc16is7xx_power(struct uart_port *port, int on)
357{
358 sc16is7xx_port_update(port, SC16IS7XX_IER_REG,
359 SC16IS7XX_IER_SLEEP_BIT,
360 on ? 0 : SC16IS7XX_IER_SLEEP_BIT);
361}
362
363static const struct sc16is7xx_devtype sc16is74x_devtype = {
364 .name = "SC16IS74X",
365 .nr_gpio = 0,
366 .nr_uart = 1,
367};
368
369static const struct sc16is7xx_devtype sc16is750_devtype = {
370 .name = "SC16IS750",
371 .nr_gpio = 8,
372 .nr_uart = 1,
373};
374
375static const struct sc16is7xx_devtype sc16is752_devtype = {
376 .name = "SC16IS752",
377 .nr_gpio = 8,
378 .nr_uart = 2,
379};
380
381static const struct sc16is7xx_devtype sc16is760_devtype = {
382 .name = "SC16IS760",
383 .nr_gpio = 8,
384 .nr_uart = 1,
385};
386
387static const struct sc16is7xx_devtype sc16is762_devtype = {
388 .name = "SC16IS762",
389 .nr_gpio = 8,
390 .nr_uart = 2,
391};
392
393static bool sc16is7xx_regmap_volatile(struct device *dev, unsigned int reg)
394{
395 switch (reg >> SC16IS7XX_REG_SHIFT) {
396 case SC16IS7XX_RHR_REG:
397 case SC16IS7XX_IIR_REG:
398 case SC16IS7XX_LSR_REG:
399 case SC16IS7XX_MSR_REG:
400 case SC16IS7XX_TXLVL_REG:
401 case SC16IS7XX_RXLVL_REG:
402 case SC16IS7XX_IOSTATE_REG:
403 return true;
404 default:
405 break;
406 }
407
408 return false;
409}
410
411static bool sc16is7xx_regmap_precious(struct device *dev, unsigned int reg)
412{
413 switch (reg >> SC16IS7XX_REG_SHIFT) {
414 case SC16IS7XX_RHR_REG:
415 return true;
416 default:
417 break;
418 }
419
420 return false;
421}
422
423static int sc16is7xx_set_baud(struct uart_port *port, int baud)
424{
425 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
426 u8 lcr;
427 u8 prescaler = 0;
428 unsigned long clk = port->uartclk, div = clk / 16 / baud;
429
430 if (div > 0xffff) {
431 prescaler = SC16IS7XX_MCR_CLKSEL_BIT;
432 div /= 4;
433 }
434
435 lcr = sc16is7xx_port_read(port, SC16IS7XX_LCR_REG);
436
437 /* Open the LCR divisors for configuration */
438 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG,
439 SC16IS7XX_LCR_CONF_MODE_B);
440
441 /* Enable enhanced features */
442 regcache_cache_bypass(s->regmap, true);
443 sc16is7xx_port_write(port, SC16IS7XX_EFR_REG,
444 SC16IS7XX_EFR_ENABLE_BIT);
445 regcache_cache_bypass(s->regmap, false);
446
447 /* Put LCR back to the normal mode */
448 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG, lcr);
449
450 sc16is7xx_port_update(port, SC16IS7XX_MCR_REG,
451 SC16IS7XX_MCR_CLKSEL_BIT,
452 prescaler);
453
454 /* Open the LCR divisors for configuration */
455 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG,
456 SC16IS7XX_LCR_CONF_MODE_A);
457
458 /* Write the new divisor */
459 regcache_cache_bypass(s->regmap, true);
460 sc16is7xx_port_write(port, SC16IS7XX_DLH_REG, div / 256);
461 sc16is7xx_port_write(port, SC16IS7XX_DLL_REG, div % 256);
462 regcache_cache_bypass(s->regmap, false);
463
464 /* Put LCR back to the normal mode */
465 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG, lcr);
466
467 return DIV_ROUND_CLOSEST(clk / 16, div);
468}
469
470static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen,
471 unsigned int iir)
472{
473 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
474 unsigned int lsr = 0, ch, flag, bytes_read, i;
475 bool read_lsr = (iir == SC16IS7XX_IIR_RLSE_SRC) ? true : false;
476
477 if (unlikely(rxlen >= sizeof(s->buf))) {
478 dev_warn_ratelimited(port->dev,
479 "Port %i: Possible RX FIFO overrun: %d\n",
480 port->line, rxlen);
481 port->icount.buf_overrun++;
482 /* Ensure sanity of RX level */
483 rxlen = sizeof(s->buf);
484 }
485
486 while (rxlen) {
487 /* Only read lsr if there are possible errors in FIFO */
488 if (read_lsr) {
489 lsr = sc16is7xx_port_read(port, SC16IS7XX_LSR_REG);
490 if (!(lsr & SC16IS7XX_LSR_FIFOE_BIT))
491 read_lsr = false; /* No errors left in FIFO */
492 } else
493 lsr = 0;
494
495 if (read_lsr) {
496 s->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);
497 bytes_read = 1;
498 } else {
499 regcache_cache_bypass(s->regmap, true);
500 regmap_raw_read(s->regmap, SC16IS7XX_RHR_REG,
501 s->buf, rxlen);
502 regcache_cache_bypass(s->regmap, false);
503 bytes_read = rxlen;
504 }
505
506 lsr &= SC16IS7XX_LSR_BRK_ERROR_MASK;
507
508 port->icount.rx++;
509 flag = TTY_NORMAL;
510
511 if (unlikely(lsr)) {
512 if (lsr & SC16IS7XX_LSR_BI_BIT) {
513 port->icount.brk++;
514 if (uart_handle_break(port))
515 continue;
516 } else if (lsr & SC16IS7XX_LSR_PE_BIT)
517 port->icount.parity++;
518 else if (lsr & SC16IS7XX_LSR_FE_BIT)
519 port->icount.frame++;
520 else if (lsr & SC16IS7XX_LSR_OE_BIT)
521 port->icount.overrun++;
522
523 lsr &= port->read_status_mask;
524 if (lsr & SC16IS7XX_LSR_BI_BIT)
525 flag = TTY_BREAK;
526 else if (lsr & SC16IS7XX_LSR_PE_BIT)
527 flag = TTY_PARITY;
528 else if (lsr & SC16IS7XX_LSR_FE_BIT)
529 flag = TTY_FRAME;
530 else if (lsr & SC16IS7XX_LSR_OE_BIT)
531 flag = TTY_OVERRUN;
532 }
533
534 for (i = 0; i < bytes_read; ++i) {
535 ch = s->buf[i];
536 if (uart_handle_sysrq_char(port, ch))
537 continue;
538
539 if (lsr & port->ignore_status_mask)
540 continue;
541
542 uart_insert_char(port, lsr, SC16IS7XX_LSR_OE_BIT, ch,
543 flag);
544 }
545 rxlen -= bytes_read;
546 }
547
548 tty_flip_buffer_push(&port->state->port);
549}
550
551static void sc16is7xx_handle_tx(struct uart_port *port)
552{
553 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
554 struct circ_buf *xmit = &port->state->xmit;
555 unsigned int txlen, to_send, i;
556
557 if (unlikely(port->x_char)) {
558 sc16is7xx_port_write(port, SC16IS7XX_THR_REG, port->x_char);
559 port->icount.tx++;
560 port->x_char = 0;
561 return;
562 }
563
564 if (uart_circ_empty(xmit) || uart_tx_stopped(port))
565 return;
566
567 /* Get length of data pending in circular buffer */
568 to_send = uart_circ_chars_pending(xmit);
569 if (likely(to_send)) {
570 /* Limit to size of TX FIFO */
571 txlen = sc16is7xx_port_read(port, SC16IS7XX_TXLVL_REG);
572 to_send = (to_send > txlen) ? txlen : to_send;
573
574 /* Add data to send */
575 port->icount.tx += to_send;
576
577 /* Convert to linear buffer */
578 for (i = 0; i < to_send; ++i) {
579 s->buf[i] = xmit->buf[xmit->tail];
580 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
581 }
582 regcache_cache_bypass(s->regmap, true);
583 regmap_raw_write(s->regmap, SC16IS7XX_THR_REG, s->buf, to_send);
584 regcache_cache_bypass(s->regmap, false);
585 }
586
587 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
588 uart_write_wakeup(port);
589}
590
591static void sc16is7xx_port_irq(struct sc16is7xx_port *s, int portno)
592{
593 struct uart_port *port = &s->p[portno].port;
594
595 do {
596 unsigned int iir, msr, rxlen;
597
598 iir = sc16is7xx_port_read(port, SC16IS7XX_IIR_REG);
599 if (iir & SC16IS7XX_IIR_NO_INT_BIT)
600 break;
601
602 iir &= SC16IS7XX_IIR_ID_MASK;
603
604 switch (iir) {
605 case SC16IS7XX_IIR_RDI_SRC:
606 case SC16IS7XX_IIR_RLSE_SRC:
607 case SC16IS7XX_IIR_RTOI_SRC:
608 case SC16IS7XX_IIR_XOFFI_SRC:
609 rxlen = sc16is7xx_port_read(port, SC16IS7XX_RXLVL_REG);
610 if (rxlen)
611 sc16is7xx_handle_rx(port, rxlen, iir);
612 break;
613
614 case SC16IS7XX_IIR_CTSRTS_SRC:
615 msr = sc16is7xx_port_read(port, SC16IS7XX_MSR_REG);
616 uart_handle_cts_change(port,
617 !!(msr & SC16IS7XX_MSR_CTS_BIT));
618 break;
619 case SC16IS7XX_IIR_THRI_SRC:
620 mutex_lock(&s->mutex);
621 sc16is7xx_handle_tx(port);
622 mutex_unlock(&s->mutex);
623 break;
624 default:
625 dev_err_ratelimited(port->dev,
626 "Port %i: Unexpected interrupt: %x",
627 port->line, iir);
628 break;
629 }
630 } while (1);
631}
632
633static irqreturn_t sc16is7xx_ist(int irq, void *dev_id)
634{
635 struct sc16is7xx_port *s = (struct sc16is7xx_port *)dev_id;
636 int i;
637
638 for (i = 0; i < s->uart.nr; ++i)
639 sc16is7xx_port_irq(s, i);
640
641 return IRQ_HANDLED;
642}
643
644static void sc16is7xx_wq_proc(struct work_struct *ws)
645{
646 struct sc16is7xx_one *one = to_sc16is7xx_one(ws, tx_work);
647 struct sc16is7xx_port *s = dev_get_drvdata(one->port.dev);
648
649 mutex_lock(&s->mutex);
650 sc16is7xx_handle_tx(&one->port);
651 mutex_unlock(&s->mutex);
652}
653
654static void sc16is7xx_stop_tx(struct uart_port* port)
655{
656 struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
657 struct circ_buf *xmit = &one->port.state->xmit;
658
659 /* handle rs485 */
660 if (one->rs485.flags & SER_RS485_ENABLED) {
661 /* do nothing if current tx not yet completed */
662 int lsr = sc16is7xx_port_read(port, SC16IS7XX_LSR_REG);
663 if (!(lsr & SC16IS7XX_LSR_TEMT_BIT))
664 return;
665
666 if (uart_circ_empty(xmit) &&
667 (one->rs485.delay_rts_after_send > 0))
668 mdelay(one->rs485.delay_rts_after_send);
669 }
670
671 sc16is7xx_port_update(port, SC16IS7XX_IER_REG,
672 SC16IS7XX_IER_THRI_BIT,
673 0);
674}
675
676static void sc16is7xx_stop_rx(struct uart_port* port)
677{
678 struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
679
680 one->port.read_status_mask &= ~SC16IS7XX_LSR_DR_BIT;
681 sc16is7xx_port_update(port, SC16IS7XX_IER_REG,
682 SC16IS7XX_LSR_DR_BIT,
683 0);
684}
685
686static void sc16is7xx_start_tx(struct uart_port *port)
687{
688 struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
689
690 /* handle rs485 */
691 if ((one->rs485.flags & SER_RS485_ENABLED) &&
692 (one->rs485.delay_rts_before_send > 0)) {
693 mdelay(one->rs485.delay_rts_before_send);
694 }
695
696 if (!work_pending(&one->tx_work))
697 schedule_work(&one->tx_work);
698}
699
700static unsigned int sc16is7xx_tx_empty(struct uart_port *port)
701{
702 unsigned int lvl, lsr;
703
704 lvl = sc16is7xx_port_read(port, SC16IS7XX_TXLVL_REG);
705 lsr = sc16is7xx_port_read(port, SC16IS7XX_LSR_REG);
706
707 return ((lsr & SC16IS7XX_LSR_THRE_BIT) && !lvl) ? TIOCSER_TEMT : 0;
708}
709
710static unsigned int sc16is7xx_get_mctrl(struct uart_port *port)
711{
712 /* DCD and DSR are not wired and CTS/RTS is handled automatically
713 * so just indicate DSR and CAR asserted
714 */
715 return TIOCM_DSR | TIOCM_CAR;
716}
717
718static void sc16is7xx_md_proc(struct work_struct *ws)
719{
720 struct sc16is7xx_one *one = to_sc16is7xx_one(ws, md_work);
721
722 sc16is7xx_port_update(&one->port, SC16IS7XX_MCR_REG,
723 SC16IS7XX_MCR_LOOP_BIT,
724 (one->port.mctrl & TIOCM_LOOP) ?
725 SC16IS7XX_MCR_LOOP_BIT : 0);
726}
727
728static void sc16is7xx_set_mctrl(struct uart_port *port, unsigned int mctrl)
729{
730 struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
731
732 schedule_work(&one->md_work);
733}
734
735static void sc16is7xx_break_ctl(struct uart_port *port, int break_state)
736{
737 sc16is7xx_port_update(port, SC16IS7XX_LCR_REG,
738 SC16IS7XX_LCR_TXBREAK_BIT,
739 break_state ? SC16IS7XX_LCR_TXBREAK_BIT : 0);
740}
741
742static void sc16is7xx_set_termios(struct uart_port *port,
743 struct ktermios *termios,
744 struct ktermios *old)
745{
746 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
747 unsigned int lcr, flow = 0;
748 int baud;
749
750 /* Mask termios capabilities we don't support */
751 termios->c_cflag &= ~CMSPAR;
752
753 /* Word size */
754 switch (termios->c_cflag & CSIZE) {
755 case CS5:
756 lcr = SC16IS7XX_LCR_WORD_LEN_5;
757 break;
758 case CS6:
759 lcr = SC16IS7XX_LCR_WORD_LEN_6;
760 break;
761 case CS7:
762 lcr = SC16IS7XX_LCR_WORD_LEN_7;
763 break;
764 case CS8:
765 lcr = SC16IS7XX_LCR_WORD_LEN_8;
766 break;
767 default:
768 lcr = SC16IS7XX_LCR_WORD_LEN_8;
769 termios->c_cflag &= ~CSIZE;
770 termios->c_cflag |= CS8;
771 break;
772 }
773
774 /* Parity */
775 if (termios->c_cflag & PARENB) {
776 lcr |= SC16IS7XX_LCR_PARITY_BIT;
777 if (!(termios->c_cflag & PARODD))
778 lcr |= SC16IS7XX_LCR_EVENPARITY_BIT;
779 }
780
781 /* Stop bits */
782 if (termios->c_cflag & CSTOPB)
783 lcr |= SC16IS7XX_LCR_STOPLEN_BIT; /* 2 stops */
784
785 /* Set read status mask */
786 port->read_status_mask = SC16IS7XX_LSR_OE_BIT;
787 if (termios->c_iflag & INPCK)
788 port->read_status_mask |= SC16IS7XX_LSR_PE_BIT |
789 SC16IS7XX_LSR_FE_BIT;
790 if (termios->c_iflag & (BRKINT | PARMRK))
791 port->read_status_mask |= SC16IS7XX_LSR_BI_BIT;
792
793 /* Set status ignore mask */
794 port->ignore_status_mask = 0;
795 if (termios->c_iflag & IGNBRK)
796 port->ignore_status_mask |= SC16IS7XX_LSR_BI_BIT;
797 if (!(termios->c_cflag & CREAD))
798 port->ignore_status_mask |= SC16IS7XX_LSR_BRK_ERROR_MASK;
799
800 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG,
801 SC16IS7XX_LCR_CONF_MODE_B);
802
803 /* Configure flow control */
804 regcache_cache_bypass(s->regmap, true);
805 sc16is7xx_port_write(port, SC16IS7XX_XON1_REG, termios->c_cc[VSTART]);
806 sc16is7xx_port_write(port, SC16IS7XX_XOFF1_REG, termios->c_cc[VSTOP]);
807 if (termios->c_cflag & CRTSCTS)
808 flow |= SC16IS7XX_EFR_AUTOCTS_BIT |
809 SC16IS7XX_EFR_AUTORTS_BIT;
810 if (termios->c_iflag & IXON)
811 flow |= SC16IS7XX_EFR_SWFLOW3_BIT;
812 if (termios->c_iflag & IXOFF)
813 flow |= SC16IS7XX_EFR_SWFLOW1_BIT;
814
815 sc16is7xx_port_write(port, SC16IS7XX_EFR_REG, flow);
816 regcache_cache_bypass(s->regmap, false);
817
818 /* Update LCR register */
819 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG, lcr);
820
821 /* Get baud rate generator configuration */
822 baud = uart_get_baud_rate(port, termios, old,
823 port->uartclk / 16 / 4 / 0xffff,
824 port->uartclk / 16);
825
826 /* Setup baudrate generator */
827 baud = sc16is7xx_set_baud(port, baud);
828
829 /* Update timeout according to new baud rate */
830 uart_update_timeout(port, termios->c_cflag, baud);
831}
832
833#if defined(TIOCSRS485) && defined(TIOCGRS485)
834static void sc16is7xx_config_rs485(struct uart_port *port,
835 struct serial_rs485 *rs485)
836{
837 struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
838
839 one->rs485 = *rs485;
840
841 if (one->rs485.flags & SER_RS485_ENABLED) {
842 sc16is7xx_port_update(port, SC16IS7XX_EFCR_REG,
843 SC16IS7XX_EFCR_AUTO_RS485_BIT,
844 SC16IS7XX_EFCR_AUTO_RS485_BIT);
845 } else {
846 sc16is7xx_port_update(port, SC16IS7XX_EFCR_REG,
847 SC16IS7XX_EFCR_AUTO_RS485_BIT,
848 0);
849 }
850}
851#endif
852
853static int sc16is7xx_ioctl(struct uart_port *port, unsigned int cmd,
854 unsigned long arg)
855{
856#if defined(TIOCSRS485) && defined(TIOCGRS485)
857 struct serial_rs485 rs485;
858
859 switch (cmd) {
860 case TIOCSRS485:
861 if (copy_from_user(&rs485, (void __user *)arg, sizeof(rs485)))
862 return -EFAULT;
863
864 sc16is7xx_config_rs485(port, &rs485);
865 return 0;
866 case TIOCGRS485:
867 if (copy_to_user((void __user *)arg,
868 &(to_sc16is7xx_one(port, port)->rs485),
869 sizeof(rs485)))
870 return -EFAULT;
871 return 0;
872 default:
873 break;
874 }
875#endif
876
877 return -ENOIOCTLCMD;
878}
879
880static int sc16is7xx_startup(struct uart_port *port)
881{
882 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
883 unsigned int val;
884
885 sc16is7xx_power(port, 1);
886
887 /* Reset FIFOs*/
888 val = SC16IS7XX_FCR_RXRESET_BIT | SC16IS7XX_FCR_TXRESET_BIT;
889 sc16is7xx_port_write(port, SC16IS7XX_FCR_REG, val);
890 udelay(5);
891 sc16is7xx_port_write(port, SC16IS7XX_FCR_REG,
892 SC16IS7XX_FCR_FIFO_BIT);
893
894 /* Enable EFR */
895 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG,
896 SC16IS7XX_LCR_CONF_MODE_B);
897
898 regcache_cache_bypass(s->regmap, true);
899
900 /* Enable write access to enhanced features and internal clock div */
901 sc16is7xx_port_write(port, SC16IS7XX_EFR_REG,
902 SC16IS7XX_EFR_ENABLE_BIT);
903
904 /* Enable TCR/TLR */
905 sc16is7xx_port_update(port, SC16IS7XX_MCR_REG,
906 SC16IS7XX_MCR_TCRTLR_BIT,
907 SC16IS7XX_MCR_TCRTLR_BIT);
908
909 /* Configure flow control levels */
910 /* Flow control halt level 48, resume level 24 */
911 sc16is7xx_port_write(port, SC16IS7XX_TCR_REG,
912 SC16IS7XX_TCR_RX_RESUME(24) |
913 SC16IS7XX_TCR_RX_HALT(48));
914
915 regcache_cache_bypass(s->regmap, false);
916
917 /* Now, initialize the UART */
918 sc16is7xx_port_write(port, SC16IS7XX_LCR_REG, SC16IS7XX_LCR_WORD_LEN_8);
919
920 /* Enable the Rx and Tx FIFO */
921 sc16is7xx_port_update(port, SC16IS7XX_EFCR_REG,
922 SC16IS7XX_EFCR_RXDISABLE_BIT |
923 SC16IS7XX_EFCR_TXDISABLE_BIT,
924 0);
925
926 /* Enable RX, TX, CTS change interrupts */
927 val = SC16IS7XX_IER_RDI_BIT | SC16IS7XX_IER_THRI_BIT |
928 SC16IS7XX_IER_CTSI_BIT;
929 sc16is7xx_port_write(port, SC16IS7XX_IER_REG, val);
930
931 return 0;
932}
933
934static void sc16is7xx_shutdown(struct uart_port *port)
935{
936 /* Disable all interrupts */
937 sc16is7xx_port_write(port, SC16IS7XX_IER_REG, 0);
938 /* Disable TX/RX */
939 sc16is7xx_port_write(port, SC16IS7XX_EFCR_REG,
940 SC16IS7XX_EFCR_RXDISABLE_BIT |
941 SC16IS7XX_EFCR_TXDISABLE_BIT);
942
943 sc16is7xx_power(port, 0);
944}
945
946static const char *sc16is7xx_type(struct uart_port *port)
947{
948 struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
949
950 return (port->type == PORT_SC16IS7XX) ? s->devtype->name : NULL;
951}
952
953static int sc16is7xx_request_port(struct uart_port *port)
954{
955 /* Do nothing */
956 return 0;
957}
958
959static void sc16is7xx_config_port(struct uart_port *port, int flags)
960{
961 if (flags & UART_CONFIG_TYPE)
962 port->type = PORT_SC16IS7XX;
963}
964
965static int sc16is7xx_verify_port(struct uart_port *port,
966 struct serial_struct *s)
967{
968 if ((s->type != PORT_UNKNOWN) && (s->type != PORT_SC16IS7XX))
969 return -EINVAL;
970 if (s->irq != port->irq)
971 return -EINVAL;
972
973 return 0;
974}
975
976static void sc16is7xx_pm(struct uart_port *port, unsigned int state,
977 unsigned int oldstate)
978{
979 sc16is7xx_power(port, (state == UART_PM_STATE_ON) ? 1 : 0);
980}
981
982static void sc16is7xx_null_void(struct uart_port *port)
983{
984 /* Do nothing */
985}
986
987static const struct uart_ops sc16is7xx_ops = {
988 .tx_empty = sc16is7xx_tx_empty,
989 .set_mctrl = sc16is7xx_set_mctrl,
990 .get_mctrl = sc16is7xx_get_mctrl,
991 .stop_tx = sc16is7xx_stop_tx,
992 .start_tx = sc16is7xx_start_tx,
993 .stop_rx = sc16is7xx_stop_rx,
994 .enable_ms = sc16is7xx_null_void,
995 .break_ctl = sc16is7xx_break_ctl,
996 .startup = sc16is7xx_startup,
997 .shutdown = sc16is7xx_shutdown,
998 .set_termios = sc16is7xx_set_termios,
999 .type = sc16is7xx_type,
1000 .request_port = sc16is7xx_request_port,
1001 .release_port = sc16is7xx_null_void,
1002 .config_port = sc16is7xx_config_port,
1003 .verify_port = sc16is7xx_verify_port,
1004 .ioctl = sc16is7xx_ioctl,
1005 .pm = sc16is7xx_pm,
1006};
1007
1008#ifdef CONFIG_GPIOLIB
1009static int sc16is7xx_gpio_get(struct gpio_chip *chip, unsigned offset)
1010{
1011 unsigned int val;
1012 struct sc16is7xx_port *s = container_of(chip, struct sc16is7xx_port,
1013 gpio);
1014 struct uart_port *port = &s->p[0].port;
1015
1016 val = sc16is7xx_port_read(port, SC16IS7XX_IOSTATE_REG);
1017
1018 return !!(val & BIT(offset));
1019}
1020
1021static void sc16is7xx_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
1022{
1023 struct sc16is7xx_port *s = container_of(chip, struct sc16is7xx_port,
1024 gpio);
1025 struct uart_port *port = &s->p[0].port;
1026
1027 sc16is7xx_port_update(port, SC16IS7XX_IOSTATE_REG, BIT(offset),
1028 val ? BIT(offset) : 0);
1029}
1030
1031static int sc16is7xx_gpio_direction_input(struct gpio_chip *chip,
1032 unsigned offset)
1033{
1034 struct sc16is7xx_port *s = container_of(chip, struct sc16is7xx_port,
1035 gpio);
1036 struct uart_port *port = &s->p[0].port;
1037
1038 sc16is7xx_port_update(port, SC16IS7XX_IODIR_REG, BIT(offset), 0);
1039
1040 return 0;
1041}
1042
1043static int sc16is7xx_gpio_direction_output(struct gpio_chip *chip,
1044 unsigned offset, int val)
1045{
1046 struct sc16is7xx_port *s = container_of(chip, struct sc16is7xx_port,
1047 gpio);
1048 struct uart_port *port = &s->p[0].port;
1049
1050 sc16is7xx_port_update(port, SC16IS7XX_IOSTATE_REG, BIT(offset),
1051 val ? BIT(offset) : 0);
1052 sc16is7xx_port_update(port, SC16IS7XX_IODIR_REG, BIT(offset),
1053 BIT(offset));
1054
1055 return 0;
1056}
1057#endif
1058
1059static int sc16is7xx_probe(struct device *dev,
1060 struct sc16is7xx_devtype *devtype,
1061 struct regmap *regmap, int irq, unsigned long flags)
1062{
1063 unsigned long freq, *pfreq = dev_get_platdata(dev);
1064 struct clk *clk;
1065 int i, ret;
1066 struct sc16is7xx_port *s;
1067
1068 if (IS_ERR(regmap))
1069 return PTR_ERR(regmap);
1070
1071 /* Alloc port structure */
1072 s = devm_kzalloc(dev, sizeof(*s) +
1073 sizeof(struct sc16is7xx_one) * devtype->nr_uart,
1074 GFP_KERNEL);
1075 if (!s) {
1076 dev_err(dev, "Error allocating port structure\n");
1077 return -ENOMEM;
1078 }
1079
1080 clk = devm_clk_get(dev, NULL);
1081 if (IS_ERR(clk)) {
1082 if (pfreq)
1083 freq = *pfreq;
1084 else
1085 return PTR_ERR(clk);
1086 } else {
1087 freq = clk_get_rate(clk);
1088 }
1089
1090 s->regmap = regmap;
1091 s->devtype = devtype;
1092 dev_set_drvdata(dev, s);
1093
1094 /* Register UART driver */
1095 s->uart.owner = THIS_MODULE;
1096 s->uart.dev_name = "ttySC";
1097 s->uart.nr = devtype->nr_uart;
1098 ret = uart_register_driver(&s->uart);
1099 if (ret) {
1100 dev_err(dev, "Registering UART driver failed\n");
1101 goto out_clk;
1102 }
1103
1104#ifdef CONFIG_GPIOLIB
1105 if (devtype->nr_gpio) {
1106 /* Setup GPIO cotroller */
1107 s->gpio.owner = THIS_MODULE;
1108 s->gpio.dev = dev;
1109 s->gpio.label = dev_name(dev);
1110 s->gpio.direction_input = sc16is7xx_gpio_direction_input;
1111 s->gpio.get = sc16is7xx_gpio_get;
1112 s->gpio.direction_output = sc16is7xx_gpio_direction_output;
1113 s->gpio.set = sc16is7xx_gpio_set;
1114 s->gpio.base = -1;
1115 s->gpio.ngpio = devtype->nr_gpio;
1116 s->gpio.can_sleep = 1;
1117 ret = gpiochip_add(&s->gpio);
1118 if (ret)
1119 goto out_uart;
1120 }
1121#endif
1122
1123 mutex_init(&s->mutex);
1124
1125 for (i = 0; i < devtype->nr_uart; ++i) {
1126 /* Initialize port data */
1127 s->p[i].port.line = i;
1128 s->p[i].port.dev = dev;
1129 s->p[i].port.irq = irq;
1130 s->p[i].port.type = PORT_SC16IS7XX;
1131 s->p[i].port.fifosize = SC16IS7XX_FIFO_SIZE;
1132 s->p[i].port.flags = UPF_FIXED_TYPE | UPF_LOW_LATENCY;
1133 s->p[i].port.iotype = UPIO_PORT;
1134 s->p[i].port.uartclk = freq;
1135 s->p[i].port.ops = &sc16is7xx_ops;
1136 /* Disable all interrupts */
1137 sc16is7xx_port_write(&s->p[i].port, SC16IS7XX_IER_REG, 0);
1138 /* Disable TX/RX */
1139 sc16is7xx_port_write(&s->p[i].port, SC16IS7XX_EFCR_REG,
1140 SC16IS7XX_EFCR_RXDISABLE_BIT |
1141 SC16IS7XX_EFCR_TXDISABLE_BIT);
1142 /* Initialize queue for start TX */
1143 INIT_WORK(&s->p[i].tx_work, sc16is7xx_wq_proc);
1144 /* Initialize queue for changing mode */
1145 INIT_WORK(&s->p[i].md_work, sc16is7xx_md_proc);
1146 /* Register port */
1147 uart_add_one_port(&s->uart, &s->p[i].port);
1148 /* Go to suspend mode */
1149 sc16is7xx_power(&s->p[i].port, 0);
1150 }
1151
1152 /* Setup interrupt */
1153 ret = devm_request_threaded_irq(dev, irq, NULL, sc16is7xx_ist,
1154 IRQF_ONESHOT | flags, dev_name(dev), s);
1155 if (!ret)
1156 return 0;
1157
1158 mutex_destroy(&s->mutex);
1159
1160#ifdef CONFIG_GPIOLIB
1161 if (devtype->nr_gpio)
1162 WARN_ON(gpiochip_remove(&s->gpio));
1163
1164out_uart:
1165#endif
1166 uart_unregister_driver(&s->uart);
1167
1168out_clk:
1169 if (!IS_ERR(s->clk))
1170 clk_disable_unprepare(s->clk);
1171
1172 return ret;
1173}
1174
1175static int sc16is7xx_remove(struct device *dev)
1176{
1177 struct sc16is7xx_port *s = dev_get_drvdata(dev);
1178 int i, ret = 0;
1179
1180#ifdef CONFIG_GPIOLIB
1181 if (s->devtype->nr_gpio) {
1182 ret = gpiochip_remove(&s->gpio);
1183 if (ret)
1184 return ret;
1185 }
1186#endif
1187
1188 for (i = 0; i < s->uart.nr; i++) {
1189 cancel_work_sync(&s->p[i].tx_work);
1190 cancel_work_sync(&s->p[i].md_work);
1191 uart_remove_one_port(&s->uart, &s->p[i].port);
1192 sc16is7xx_power(&s->p[i].port, 0);
1193 }
1194
1195 mutex_destroy(&s->mutex);
1196 uart_unregister_driver(&s->uart);
1197 if (!IS_ERR(s->clk))
1198 clk_disable_unprepare(s->clk);
1199
1200 return ret;
1201}
1202
1203static const struct of_device_id __maybe_unused sc16is7xx_dt_ids[] = {
1204 { .compatible = "nxp,sc16is740", .data = &sc16is74x_devtype, },
1205 { .compatible = "nxp,sc16is741", .data = &sc16is74x_devtype, },
1206 { .compatible = "nxp,sc16is750", .data = &sc16is750_devtype, },
1207 { .compatible = "nxp,sc16is752", .data = &sc16is752_devtype, },
1208 { .compatible = "nxp,sc16is760", .data = &sc16is760_devtype, },
1209 { .compatible = "nxp,sc16is762", .data = &sc16is762_devtype, },
1210 { }
1211};
1212MODULE_DEVICE_TABLE(of, sc16is7xx_dt_ids);
1213
1214static struct regmap_config regcfg = {
1215 .reg_bits = 7,
1216 .pad_bits = 1,
1217 .val_bits = 8,
1218 .cache_type = REGCACHE_RBTREE,
1219 .volatile_reg = sc16is7xx_regmap_volatile,
1220 .precious_reg = sc16is7xx_regmap_precious,
1221};
1222
1223static int sc16is7xx_i2c_probe(struct i2c_client *i2c,
1224 const struct i2c_device_id *id)
1225{
1226 struct sc16is7xx_devtype *devtype;
1227 unsigned long flags = 0;
1228 struct regmap *regmap;
1229
1230 if (i2c->dev.of_node) {
1231 const struct of_device_id *of_id =
1232 of_match_device(sc16is7xx_dt_ids, &i2c->dev);
1233
1234 devtype = (struct sc16is7xx_devtype *)of_id->data;
1235 } else {
1236 devtype = (struct sc16is7xx_devtype *)id->driver_data;
1237 flags = IRQF_TRIGGER_FALLING;
1238 }
1239
1240 regcfg.max_register = (0xf << SC16IS7XX_REG_SHIFT) |
1241 (devtype->nr_uart - 1);
1242 regmap = devm_regmap_init_i2c(i2c, &regcfg);
1243
1244 return sc16is7xx_probe(&i2c->dev, devtype, regmap, i2c->irq, flags);
1245}
1246
1247static int sc16is7xx_i2c_remove(struct i2c_client *client)
1248{
1249 return sc16is7xx_remove(&client->dev);
1250}
1251
1252static const struct i2c_device_id sc16is7xx_i2c_id_table[] = {
1253 { "sc16is74x", (kernel_ulong_t)&sc16is74x_devtype, },
1254 { "sc16is750", (kernel_ulong_t)&sc16is750_devtype, },
1255 { "sc16is752", (kernel_ulong_t)&sc16is752_devtype, },
1256 { "sc16is760", (kernel_ulong_t)&sc16is760_devtype, },
1257 { "sc16is762", (kernel_ulong_t)&sc16is762_devtype, },
1258 { }
1259};
1260MODULE_DEVICE_TABLE(i2c, sc16is7xx_i2c_id_table);
1261
1262static struct i2c_driver sc16is7xx_i2c_uart_driver = {
1263 .driver = {
1264 .name = SC16IS7XX_NAME,
1265 .owner = THIS_MODULE,
1266 .of_match_table = of_match_ptr(sc16is7xx_dt_ids),
1267 },
1268 .probe = sc16is7xx_i2c_probe,
1269 .remove = sc16is7xx_i2c_remove,
1270 .id_table = sc16is7xx_i2c_id_table,
1271};
1272module_i2c_driver(sc16is7xx_i2c_uart_driver);
1273MODULE_ALIAS("i2c:sc16is7xx");
1274
1275MODULE_LICENSE("GPL");
1276MODULE_AUTHOR("Jon Ringle <jringle@gridpoint.com>");
1277MODULE_DESCRIPTION("SC16IS7XX serial driver");
diff --git a/drivers/tty/serial/sccnxp.c b/drivers/tty/serial/sccnxp.c
index a447f71538ef..5443b46345ed 100644
--- a/drivers/tty/serial/sccnxp.c
+++ b/drivers/tty/serial/sccnxp.c
@@ -474,9 +474,7 @@ static void sccnxp_timer(unsigned long data)
474 sccnxp_handle_events(s); 474 sccnxp_handle_events(s);
475 spin_unlock_irqrestore(&s->lock, flags); 475 spin_unlock_irqrestore(&s->lock, flags);
476 476
477 if (!timer_pending(&s->timer)) 477 mod_timer(&s->timer, jiffies + usecs_to_jiffies(s->pdata.poll_time_us));
478 mod_timer(&s->timer, jiffies +
479 usecs_to_jiffies(s->pdata.poll_time_us));
480} 478}
481 479
482static irqreturn_t sccnxp_ist(int irq, void *dev_id) 480static irqreturn_t sccnxp_ist(int irq, void *dev_id)
@@ -674,6 +672,8 @@ static void sccnxp_set_termios(struct uart_port *port,
674 port->ignore_status_mask = 0; 672 port->ignore_status_mask = 0;
675 if (termios->c_iflag & IGNBRK) 673 if (termios->c_iflag & IGNBRK)
676 port->ignore_status_mask |= SR_BRK; 674 port->ignore_status_mask |= SR_BRK;
675 if (termios->c_iflag & IGNPAR)
676 port->ignore_status_mask |= SR_PE;
677 if (!(termios->c_cflag & CREAD)) 677 if (!(termios->c_cflag & CREAD))
678 port->ignore_status_mask |= SR_PE | SR_OVR | SR_FE | SR_BRK; 678 port->ignore_status_mask |= SR_PE | SR_OVR | SR_FE | SR_BRK;
679 679
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index b68550d95a40..fbf6c5ad222f 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -174,8 +174,12 @@ static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
174 if (tty->termios.c_cflag & CBAUD) 174 if (tty->termios.c_cflag & CBAUD)
175 uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR); 175 uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
176 } 176 }
177 177 /*
178 if (tty_port_cts_enabled(port)) { 178 * if hw support flow control without software intervention,
179 * then skip the below check
180 */
181 if (tty_port_cts_enabled(port) &&
182 !(uport->flags & UPF_HARD_FLOW)) {
179 spin_lock_irq(&uport->lock); 183 spin_lock_irq(&uport->lock);
180 if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS)) 184 if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
181 tty->hw_stopped = 1; 185 tty->hw_stopped = 1;
@@ -2239,6 +2243,9 @@ static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
2239 return; 2243 return;
2240 2244
2241 port = state->uart_port; 2245 port = state->uart_port;
2246
2247 if (ch == '\n')
2248 port->ops->poll_put_char(port, '\r');
2242 port->ops->poll_put_char(port, ch); 2249 port->ops->poll_put_char(port, ch);
2243} 2250}
2244#endif 2251#endif
@@ -2772,7 +2779,9 @@ void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
2772 2779
2773 uport->icount.cts++; 2780 uport->icount.cts++;
2774 2781
2775 if (tty_port_cts_enabled(port)) { 2782 /* skip below code if the hw flow control is supported */
2783 if (tty_port_cts_enabled(port) &&
2784 !(uport->flags & UPF_HARD_FLOW)) {
2776 if (tty->hw_stopped) { 2785 if (tty->hw_stopped) {
2777 if (status) { 2786 if (status) {
2778 tty->hw_stopped = 0; 2787 tty->hw_stopped = 0;
diff --git a/drivers/tty/serial/serial_mctrl_gpio.c b/drivers/tty/serial/serial_mctrl_gpio.c
new file mode 100644
index 000000000000..bf9560ffe3f4
--- /dev/null
+++ b/drivers/tty/serial/serial_mctrl_gpio.c
@@ -0,0 +1,143 @@
1/*
2 * Helpers for controlling modem lines via GPIO
3 *
4 * Copyright (C) 2014 Paratronic S.A.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18#include <linux/err.h>
19#include <linux/device.h>
20#include <linux/gpio/consumer.h>
21#include <uapi/asm-generic/termios.h>
22
23#include "serial_mctrl_gpio.h"
24
25struct mctrl_gpios {
26 struct gpio_desc *gpio[UART_GPIO_MAX];
27};
28
29static const struct {
30 const char *name;
31 unsigned int mctrl;
32 bool dir_out;
33} mctrl_gpios_desc[UART_GPIO_MAX] = {
34 { "cts", TIOCM_CTS, false, },
35 { "dsr", TIOCM_DSR, false, },
36 { "dcd", TIOCM_CD, false, },
37 { "rng", TIOCM_RNG, false, },
38 { "rts", TIOCM_RTS, true, },
39 { "dtr", TIOCM_DTR, true, },
40 { "out1", TIOCM_OUT1, true, },
41 { "out2", TIOCM_OUT2, true, },
42};
43
44void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl)
45{
46 enum mctrl_gpio_idx i;
47
48 if (IS_ERR_OR_NULL(gpios))
49 return;
50
51 for (i = 0; i < UART_GPIO_MAX; i++)
52 if (!IS_ERR_OR_NULL(gpios->gpio[i]) &&
53 mctrl_gpios_desc[i].dir_out)
54 gpiod_set_value(gpios->gpio[i],
55 !!(mctrl & mctrl_gpios_desc[i].mctrl));
56}
57EXPORT_SYMBOL_GPL(mctrl_gpio_set);
58
59struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
60 enum mctrl_gpio_idx gidx)
61{
62 if (!IS_ERR_OR_NULL(gpios) && !IS_ERR_OR_NULL(gpios->gpio[gidx]))
63 return gpios->gpio[gidx];
64 else
65 return NULL;
66}
67EXPORT_SYMBOL_GPL(mctrl_gpio_to_gpiod);
68
69unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl)
70{
71 enum mctrl_gpio_idx i;
72
73 /*
74 * return it unchanged if the structure is not allocated
75 */
76 if (IS_ERR_OR_NULL(gpios))
77 return *mctrl;
78
79 for (i = 0; i < UART_GPIO_MAX; i++) {
80 if (!IS_ERR_OR_NULL(gpios->gpio[i]) &&
81 !mctrl_gpios_desc[i].dir_out) {
82 if (gpiod_get_value(gpios->gpio[i]))
83 *mctrl |= mctrl_gpios_desc[i].mctrl;
84 else
85 *mctrl &= ~mctrl_gpios_desc[i].mctrl;
86 }
87 }
88
89 return *mctrl;
90}
91EXPORT_SYMBOL_GPL(mctrl_gpio_get);
92
93struct mctrl_gpios *mctrl_gpio_init(struct device *dev, unsigned int idx)
94{
95 struct mctrl_gpios *gpios;
96 enum mctrl_gpio_idx i;
97 int err;
98
99 gpios = devm_kzalloc(dev, sizeof(*gpios), GFP_KERNEL);
100 if (!gpios)
101 return ERR_PTR(-ENOMEM);
102
103 for (i = 0; i < UART_GPIO_MAX; i++) {
104 gpios->gpio[i] = devm_gpiod_get_index(dev,
105 mctrl_gpios_desc[i].name,
106 idx);
107
108 /*
109 * The GPIOs are maybe not all filled,
110 * this is not an error.
111 */
112 if (IS_ERR_OR_NULL(gpios->gpio[i]))
113 continue;
114
115 if (mctrl_gpios_desc[i].dir_out)
116 err = gpiod_direction_output(gpios->gpio[i], 0);
117 else
118 err = gpiod_direction_input(gpios->gpio[i]);
119 if (err) {
120 dev_dbg(dev, "Unable to set direction for %s GPIO",
121 mctrl_gpios_desc[i].name);
122 devm_gpiod_put(dev, gpios->gpio[i]);
123 gpios->gpio[i] = NULL;
124 }
125 }
126
127 return gpios;
128}
129EXPORT_SYMBOL_GPL(mctrl_gpio_init);
130
131void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios)
132{
133 enum mctrl_gpio_idx i;
134
135 if (IS_ERR_OR_NULL(gpios))
136 return;
137
138 for (i = 0; i < UART_GPIO_MAX; i++)
139 if (!IS_ERR_OR_NULL(gpios->gpio[i]))
140 devm_gpiod_put(dev, gpios->gpio[i]);
141 devm_kfree(dev, gpios);
142}
143EXPORT_SYMBOL_GPL(mctrl_gpio_free);
diff --git a/drivers/tty/serial/serial_mctrl_gpio.h b/drivers/tty/serial/serial_mctrl_gpio.h
new file mode 100644
index 000000000000..400ba0494a17
--- /dev/null
+++ b/drivers/tty/serial/serial_mctrl_gpio.h
@@ -0,0 +1,110 @@
1/*
2 * Helpers for controlling modem lines via GPIO
3 *
4 * Copyright (C) 2014 Paratronic S.A.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18#ifndef __SERIAL_MCTRL_GPIO__
19#define __SERIAL_MCTRL_GPIO__
20
21#include <linux/err.h>
22#include <linux/device.h>
23#include <linux/gpio/consumer.h>
24
25enum mctrl_gpio_idx {
26 UART_GPIO_CTS,
27 UART_GPIO_DSR,
28 UART_GPIO_DCD,
29 UART_GPIO_RNG,
30 UART_GPIO_RI = UART_GPIO_RNG,
31 UART_GPIO_RTS,
32 UART_GPIO_DTR,
33 UART_GPIO_OUT1,
34 UART_GPIO_OUT2,
35 UART_GPIO_MAX,
36};
37
38/*
39 * Opaque descriptor for modem lines controlled by GPIOs
40 */
41struct mctrl_gpios;
42
43#ifdef CONFIG_GPIOLIB
44
45/*
46 * Set state of the modem control output lines via GPIOs.
47 */
48void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl);
49
50/*
51 * Get state of the modem control output lines from GPIOs.
52 * The mctrl flags are updated and returned.
53 */
54unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl);
55
56/*
57 * Returns the associated struct gpio_desc to the modem line gidx
58 */
59struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
60 enum mctrl_gpio_idx gidx);
61
62/*
63 * Request and set direction of modem control lines GPIOs.
64 * devm_* functions are used, so there's no need to call mctrl_gpio_free().
65 * Returns a pointer to the allocated mctrl structure if ok, -ENOMEM on
66 * allocation error.
67 */
68struct mctrl_gpios *mctrl_gpio_init(struct device *dev, unsigned int idx);
69
70/*
71 * Free the mctrl_gpios structure.
72 * Normally, this function will not be called, as the GPIOs will
73 * be disposed of by the resource management code.
74 */
75void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios);
76
77#else /* GPIOLIB */
78
79static inline
80void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl)
81{
82}
83
84static inline
85unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl)
86{
87 return *mctrl;
88}
89
90static inline
91struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
92 enum mctrl_gpio_idx gidx)
93{
94 return ERR_PTR(-ENOSYS);
95}
96
97static inline
98struct mctrl_gpios *mctrl_gpio_init(struct device *dev, unsigned int idx)
99{
100 return ERR_PTR(-ENOSYS);
101}
102
103static inline
104void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios)
105{
106}
107
108#endif /* GPIOLIB */
109
110#endif
diff --git a/drivers/tty/serial/serial_txx9.c b/drivers/tty/serial/serial_txx9.c
index 90a080b1f9ee..60f49b9d7e39 100644
--- a/drivers/tty/serial/serial_txx9.c
+++ b/drivers/tty/serial/serial_txx9.c
@@ -535,13 +535,8 @@ static void serial_txx9_put_poll_char(struct uart_port *port, unsigned char c)
535 wait_for_xmitr(up); 535 wait_for_xmitr(up);
536 /* 536 /*
537 * Send the character out. 537 * Send the character out.
538 * If a LF, also do CR...
539 */ 538 */
540 sio_out(up, TXX9_SITFIFO, c); 539 sio_out(up, TXX9_SITFIFO, c);
541 if (c == 10) {
542 wait_for_xmitr(up);
543 sio_out(up, TXX9_SITFIFO, 13);
544 }
545 540
546 /* 541 /*
547 * Finally, wait for transmitter to become empty 542 * Finally, wait for transmitter to become empty
diff --git a/drivers/tty/serial/sirfsoc_uart.c b/drivers/tty/serial/sirfsoc_uart.c
index 68b0fd4b9a6a..1f2be48c92ce 100644
--- a/drivers/tty/serial/sirfsoc_uart.c
+++ b/drivers/tty/serial/sirfsoc_uart.c
@@ -358,9 +358,11 @@ static irqreturn_t sirfsoc_uart_usp_cts_handler(int irq, void *dev_id)
358{ 358{
359 struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id; 359 struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)dev_id;
360 struct uart_port *port = &sirfport->port; 360 struct uart_port *port = &sirfport->port;
361 spin_lock(&port->lock);
361 if (gpio_is_valid(sirfport->cts_gpio) && sirfport->ms_enabled) 362 if (gpio_is_valid(sirfport->cts_gpio) && sirfport->ms_enabled)
362 uart_handle_cts_change(port, 363 uart_handle_cts_change(port,
363 !gpio_get_value(sirfport->cts_gpio)); 364 !gpio_get_value(sirfport->cts_gpio));
365 spin_unlock(&port->lock);
364 return IRQ_HANDLED; 366 return IRQ_HANDLED;
365} 367}
366 368
@@ -428,10 +430,6 @@ sirfsoc_uart_pio_rx_chars(struct uart_port *port, unsigned int max_rx_count)
428 sirfport->rx_io_count += rx_count; 430 sirfport->rx_io_count += rx_count;
429 port->icount.rx += rx_count; 431 port->icount.rx += rx_count;
430 432
431 spin_unlock(&port->lock);
432 tty_flip_buffer_push(&port->state->port);
433 spin_lock(&port->lock);
434
435 return rx_count; 433 return rx_count;
436} 434}
437 435
@@ -465,6 +463,7 @@ static void sirfsoc_uart_tx_dma_complete_callback(void *param)
465 struct circ_buf *xmit = &port->state->xmit; 463 struct circ_buf *xmit = &port->state->xmit;
466 unsigned long flags; 464 unsigned long flags;
467 465
466 spin_lock_irqsave(&port->lock, flags);
468 xmit->tail = (xmit->tail + sirfport->transfer_size) & 467 xmit->tail = (xmit->tail + sirfport->transfer_size) &
469 (UART_XMIT_SIZE - 1); 468 (UART_XMIT_SIZE - 1);
470 port->icount.tx += sirfport->transfer_size; 469 port->icount.tx += sirfport->transfer_size;
@@ -473,10 +472,9 @@ static void sirfsoc_uart_tx_dma_complete_callback(void *param)
473 if (sirfport->tx_dma_addr) 472 if (sirfport->tx_dma_addr)
474 dma_unmap_single(port->dev, sirfport->tx_dma_addr, 473 dma_unmap_single(port->dev, sirfport->tx_dma_addr,
475 sirfport->transfer_size, DMA_TO_DEVICE); 474 sirfport->transfer_size, DMA_TO_DEVICE);
476 spin_lock_irqsave(&sirfport->tx_lock, flags);
477 sirfport->tx_dma_state = TX_DMA_IDLE; 475 sirfport->tx_dma_state = TX_DMA_IDLE;
478 sirfsoc_uart_tx_with_dma(sirfport); 476 sirfsoc_uart_tx_with_dma(sirfport);
479 spin_unlock_irqrestore(&sirfport->tx_lock, flags); 477 spin_unlock_irqrestore(&port->lock, flags);
480} 478}
481 479
482static void sirfsoc_uart_insert_rx_buf_to_tty( 480static void sirfsoc_uart_insert_rx_buf_to_tty(
@@ -489,7 +487,6 @@ static void sirfsoc_uart_insert_rx_buf_to_tty(
489 inserted = tty_insert_flip_string(tport, 487 inserted = tty_insert_flip_string(tport,
490 sirfport->rx_dma_items[sirfport->rx_completed].xmit.buf, count); 488 sirfport->rx_dma_items[sirfport->rx_completed].xmit.buf, count);
491 port->icount.rx += inserted; 489 port->icount.rx += inserted;
492 tty_flip_buffer_push(tport);
493} 490}
494 491
495static void sirfsoc_rx_submit_one_dma_desc(struct uart_port *port, int index) 492static void sirfsoc_rx_submit_one_dma_desc(struct uart_port *port, int index)
@@ -525,7 +522,7 @@ static void sirfsoc_rx_tmo_process_tl(unsigned long param)
525 unsigned long flags; 522 unsigned long flags;
526 struct dma_tx_state tx_state; 523 struct dma_tx_state tx_state;
527 524
528 spin_lock_irqsave(&sirfport->rx_lock, flags); 525 spin_lock_irqsave(&port->lock, flags);
529 while (DMA_COMPLETE == dmaengine_tx_status(sirfport->rx_dma_chan, 526 while (DMA_COMPLETE == dmaengine_tx_status(sirfport->rx_dma_chan,
530 sirfport->rx_dma_items[sirfport->rx_completed].cookie, &tx_state)) { 527 sirfport->rx_dma_items[sirfport->rx_completed].cookie, &tx_state)) {
531 sirfsoc_uart_insert_rx_buf_to_tty(sirfport, 528 sirfsoc_uart_insert_rx_buf_to_tty(sirfport,
@@ -541,12 +538,8 @@ static void sirfsoc_rx_tmo_process_tl(unsigned long param)
541 wr_regl(port, ureg->sirfsoc_rx_dma_io_ctrl, 538 wr_regl(port, ureg->sirfsoc_rx_dma_io_ctrl,
542 rd_regl(port, ureg->sirfsoc_rx_dma_io_ctrl) | 539 rd_regl(port, ureg->sirfsoc_rx_dma_io_ctrl) |
543 SIRFUART_IO_MODE); 540 SIRFUART_IO_MODE);
544 spin_unlock_irqrestore(&sirfport->rx_lock, flags);
545 spin_lock(&port->lock);
546 sirfsoc_uart_pio_rx_chars(port, 4 - sirfport->rx_io_count); 541 sirfsoc_uart_pio_rx_chars(port, 4 - sirfport->rx_io_count);
547 spin_unlock(&port->lock);
548 if (sirfport->rx_io_count == 4) { 542 if (sirfport->rx_io_count == 4) {
549 spin_lock_irqsave(&sirfport->rx_lock, flags);
550 sirfport->rx_io_count = 0; 543 sirfport->rx_io_count = 0;
551 wr_regl(port, ureg->sirfsoc_int_st_reg, 544 wr_regl(port, ureg->sirfsoc_int_st_reg,
552 uint_st->sirfsoc_rx_done); 545 uint_st->sirfsoc_rx_done);
@@ -557,11 +550,8 @@ static void sirfsoc_rx_tmo_process_tl(unsigned long param)
557 else 550 else
558 wr_regl(port, SIRFUART_INT_EN_CLR, 551 wr_regl(port, SIRFUART_INT_EN_CLR,
559 uint_en->sirfsoc_rx_done_en); 552 uint_en->sirfsoc_rx_done_en);
560 spin_unlock_irqrestore(&sirfport->rx_lock, flags);
561
562 sirfsoc_uart_start_next_rx_dma(port); 553 sirfsoc_uart_start_next_rx_dma(port);
563 } else { 554 } else {
564 spin_lock_irqsave(&sirfport->rx_lock, flags);
565 wr_regl(port, ureg->sirfsoc_int_st_reg, 555 wr_regl(port, ureg->sirfsoc_int_st_reg,
566 uint_st->sirfsoc_rx_done); 556 uint_st->sirfsoc_rx_done);
567 if (!sirfport->is_marco) 557 if (!sirfport->is_marco)
@@ -571,8 +561,9 @@ static void sirfsoc_rx_tmo_process_tl(unsigned long param)
571 else 561 else
572 wr_regl(port, ureg->sirfsoc_int_en_reg, 562 wr_regl(port, ureg->sirfsoc_int_en_reg,
573 uint_en->sirfsoc_rx_done_en); 563 uint_en->sirfsoc_rx_done_en);
574 spin_unlock_irqrestore(&sirfport->rx_lock, flags);
575 } 564 }
565 spin_unlock_irqrestore(&port->lock, flags);
566 tty_flip_buffer_push(&port->state->port);
576} 567}
577 568
578static void sirfsoc_uart_handle_rx_tmo(struct sirfsoc_uart_port *sirfport) 569static void sirfsoc_uart_handle_rx_tmo(struct sirfsoc_uart_port *sirfport)
@@ -581,8 +572,6 @@ static void sirfsoc_uart_handle_rx_tmo(struct sirfsoc_uart_port *sirfport)
581 struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg; 572 struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg;
582 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en; 573 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en;
583 struct dma_tx_state tx_state; 574 struct dma_tx_state tx_state;
584 spin_lock(&sirfport->rx_lock);
585
586 dmaengine_tx_status(sirfport->rx_dma_chan, 575 dmaengine_tx_status(sirfport->rx_dma_chan,
587 sirfport->rx_dma_items[sirfport->rx_issued].cookie, &tx_state); 576 sirfport->rx_dma_items[sirfport->rx_issued].cookie, &tx_state);
588 dmaengine_terminate_all(sirfport->rx_dma_chan); 577 dmaengine_terminate_all(sirfport->rx_dma_chan);
@@ -595,7 +584,6 @@ static void sirfsoc_uart_handle_rx_tmo(struct sirfsoc_uart_port *sirfport)
595 else 584 else
596 wr_regl(port, SIRFUART_INT_EN_CLR, 585 wr_regl(port, SIRFUART_INT_EN_CLR,
597 uint_en->sirfsoc_rx_timeout_en); 586 uint_en->sirfsoc_rx_timeout_en);
598 spin_unlock(&sirfport->rx_lock);
599 tasklet_schedule(&sirfport->rx_tmo_process_tasklet); 587 tasklet_schedule(&sirfport->rx_tmo_process_tasklet);
600} 588}
601 589
@@ -659,7 +647,6 @@ static irqreturn_t sirfsoc_uart_isr(int irq, void *dev_id)
659 intr_status &= port->read_status_mask; 647 intr_status &= port->read_status_mask;
660 uart_insert_char(port, intr_status, 648 uart_insert_char(port, intr_status,
661 uint_en->sirfsoc_rx_oflow_en, 0, flag); 649 uint_en->sirfsoc_rx_oflow_en, 0, flag);
662 tty_flip_buffer_push(&state->port);
663 } 650 }
664recv_char: 651recv_char:
665 if ((sirfport->uart_reg->uart_type == SIRF_REAL_UART) && 652 if ((sirfport->uart_reg->uart_type == SIRF_REAL_UART) &&
@@ -684,6 +671,9 @@ recv_char:
684 sirfsoc_uart_pio_rx_chars(port, 671 sirfsoc_uart_pio_rx_chars(port,
685 SIRFSOC_UART_IO_RX_MAX_CNT); 672 SIRFSOC_UART_IO_RX_MAX_CNT);
686 } 673 }
674 spin_unlock(&port->lock);
675 tty_flip_buffer_push(&state->port);
676 spin_lock(&port->lock);
687 if (intr_status & uint_st->sirfsoc_txfifo_empty) { 677 if (intr_status & uint_st->sirfsoc_txfifo_empty) {
688 if (sirfport->tx_dma_chan) 678 if (sirfport->tx_dma_chan)
689 sirfsoc_uart_tx_with_dma(sirfport); 679 sirfsoc_uart_tx_with_dma(sirfport);
@@ -702,6 +692,7 @@ recv_char:
702 } 692 }
703 } 693 }
704 spin_unlock(&port->lock); 694 spin_unlock(&port->lock);
695
705 return IRQ_HANDLED; 696 return IRQ_HANDLED;
706} 697}
707 698
@@ -713,7 +704,7 @@ static void sirfsoc_uart_rx_dma_complete_tl(unsigned long param)
713 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en; 704 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en;
714 unsigned long flags; 705 unsigned long flags;
715 struct dma_tx_state tx_state; 706 struct dma_tx_state tx_state;
716 spin_lock_irqsave(&sirfport->rx_lock, flags); 707 spin_lock_irqsave(&port->lock, flags);
717 while (DMA_COMPLETE == dmaengine_tx_status(sirfport->rx_dma_chan, 708 while (DMA_COMPLETE == dmaengine_tx_status(sirfport->rx_dma_chan,
718 sirfport->rx_dma_items[sirfport->rx_completed].cookie, &tx_state)) { 709 sirfport->rx_dma_items[sirfport->rx_completed].cookie, &tx_state)) {
719 sirfsoc_uart_insert_rx_buf_to_tty(sirfport, 710 sirfsoc_uart_insert_rx_buf_to_tty(sirfport,
@@ -726,17 +717,20 @@ static void sirfsoc_uart_rx_dma_complete_tl(unsigned long param)
726 sirfport->rx_completed++; 717 sirfport->rx_completed++;
727 sirfport->rx_completed %= SIRFSOC_RX_LOOP_BUF_CNT; 718 sirfport->rx_completed %= SIRFSOC_RX_LOOP_BUF_CNT;
728 } 719 }
729 spin_unlock_irqrestore(&sirfport->rx_lock, flags); 720 spin_unlock_irqrestore(&port->lock, flags);
721 tty_flip_buffer_push(&port->state->port);
730} 722}
731 723
732static void sirfsoc_uart_rx_dma_complete_callback(void *param) 724static void sirfsoc_uart_rx_dma_complete_callback(void *param)
733{ 725{
734 struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)param; 726 struct sirfsoc_uart_port *sirfport = (struct sirfsoc_uart_port *)param;
735 spin_lock(&sirfport->rx_lock); 727 unsigned long flags;
728
729 spin_lock_irqsave(&sirfport->port.lock, flags);
736 sirfport->rx_issued++; 730 sirfport->rx_issued++;
737 sirfport->rx_issued %= SIRFSOC_RX_LOOP_BUF_CNT; 731 sirfport->rx_issued %= SIRFSOC_RX_LOOP_BUF_CNT;
738 spin_unlock(&sirfport->rx_lock);
739 tasklet_schedule(&sirfport->rx_dma_complete_tasklet); 732 tasklet_schedule(&sirfport->rx_dma_complete_tasklet);
733 spin_unlock_irqrestore(&sirfport->port.lock, flags);
740} 734}
741 735
742/* submit rx dma task into dmaengine */ 736/* submit rx dma task into dmaengine */
@@ -745,18 +739,14 @@ static void sirfsoc_uart_start_next_rx_dma(struct uart_port *port)
745 struct sirfsoc_uart_port *sirfport = to_sirfport(port); 739 struct sirfsoc_uart_port *sirfport = to_sirfport(port);
746 struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg; 740 struct sirfsoc_register *ureg = &sirfport->uart_reg->uart_reg;
747 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en; 741 struct sirfsoc_int_en *uint_en = &sirfport->uart_reg->uart_int_en;
748 unsigned long flags;
749 int i; 742 int i;
750 spin_lock_irqsave(&sirfport->rx_lock, flags);
751 sirfport->rx_io_count = 0; 743 sirfport->rx_io_count = 0;
752 wr_regl(port, ureg->sirfsoc_rx_dma_io_ctrl, 744 wr_regl(port, ureg->sirfsoc_rx_dma_io_ctrl,
753 rd_regl(port, ureg->sirfsoc_rx_dma_io_ctrl) & 745 rd_regl(port, ureg->sirfsoc_rx_dma_io_ctrl) &
754 ~SIRFUART_IO_MODE); 746 ~SIRFUART_IO_MODE);
755 spin_unlock_irqrestore(&sirfport->rx_lock, flags);
756 for (i = 0; i < SIRFSOC_RX_LOOP_BUF_CNT; i++) 747 for (i = 0; i < SIRFSOC_RX_LOOP_BUF_CNT; i++)
757 sirfsoc_rx_submit_one_dma_desc(port, i); 748 sirfsoc_rx_submit_one_dma_desc(port, i);
758 sirfport->rx_completed = sirfport->rx_issued = 0; 749 sirfport->rx_completed = sirfport->rx_issued = 0;
759 spin_lock_irqsave(&sirfport->rx_lock, flags);
760 if (!sirfport->is_marco) 750 if (!sirfport->is_marco)
761 wr_regl(port, ureg->sirfsoc_int_en_reg, 751 wr_regl(port, ureg->sirfsoc_int_en_reg,
762 rd_regl(port, ureg->sirfsoc_int_en_reg) | 752 rd_regl(port, ureg->sirfsoc_int_en_reg) |
@@ -764,7 +754,6 @@ static void sirfsoc_uart_start_next_rx_dma(struct uart_port *port)
764 else 754 else
765 wr_regl(port, ureg->sirfsoc_int_en_reg, 755 wr_regl(port, ureg->sirfsoc_int_en_reg,
766 SIRFUART_RX_DMA_INT_EN(port, uint_en)); 756 SIRFUART_RX_DMA_INT_EN(port, uint_en));
767 spin_unlock_irqrestore(&sirfport->rx_lock, flags);
768} 757}
769 758
770static void sirfsoc_uart_start_rx(struct uart_port *port) 759static void sirfsoc_uart_start_rx(struct uart_port *port)
@@ -1228,7 +1217,7 @@ static void sirfsoc_uart_console_putchar(struct uart_port *port, int ch)
1228 while (rd_regl(port, 1217 while (rd_regl(port,
1229 ureg->sirfsoc_tx_fifo_status) & ufifo_st->ff_full(port->line)) 1218 ureg->sirfsoc_tx_fifo_status) & ufifo_st->ff_full(port->line))
1230 cpu_relax(); 1219 cpu_relax();
1231 wr_regb(port, ureg->sirfsoc_tx_fifo_data, ch); 1220 wr_regl(port, ureg->sirfsoc_tx_fifo_data, ch);
1232} 1221}
1233 1222
1234static void sirfsoc_uart_console_write(struct console *co, const char *s, 1223static void sirfsoc_uart_console_write(struct console *co, const char *s,
@@ -1369,8 +1358,6 @@ usp_no_flow_control:
1369 ret = -EFAULT; 1358 ret = -EFAULT;
1370 goto err; 1359 goto err;
1371 } 1360 }
1372 spin_lock_init(&sirfport->rx_lock);
1373 spin_lock_init(&sirfport->tx_lock);
1374 tasklet_init(&sirfport->rx_dma_complete_tasklet, 1361 tasklet_init(&sirfport->rx_dma_complete_tasklet,
1375 sirfsoc_uart_rx_dma_complete_tl, (unsigned long)sirfport); 1362 sirfsoc_uart_rx_dma_complete_tl, (unsigned long)sirfport);
1376 tasklet_init(&sirfport->rx_tmo_process_tasklet, 1363 tasklet_init(&sirfport->rx_tmo_process_tasklet,
diff --git a/drivers/tty/serial/sirfsoc_uart.h b/drivers/tty/serial/sirfsoc_uart.h
index 8a6eddad2f3c..69a62ebd3afc 100644
--- a/drivers/tty/serial/sirfsoc_uart.h
+++ b/drivers/tty/serial/sirfsoc_uart.h
@@ -424,8 +424,6 @@ struct sirfsoc_uart_port {
424 struct dma_chan *tx_dma_chan; 424 struct dma_chan *tx_dma_chan;
425 dma_addr_t tx_dma_addr; 425 dma_addr_t tx_dma_addr;
426 struct dma_async_tx_descriptor *tx_dma_desc; 426 struct dma_async_tx_descriptor *tx_dma_desc;
427 spinlock_t rx_lock;
428 spinlock_t tx_lock;
429 struct tasklet_struct rx_dma_complete_tasklet; 427 struct tasklet_struct rx_dma_complete_tasklet;
430 struct tasklet_struct rx_tmo_process_tasklet; 428 struct tasklet_struct rx_tmo_process_tasklet;
431 unsigned int rx_io_count; 429 unsigned int rx_io_count;
@@ -441,9 +439,7 @@ struct sirfsoc_uart_port {
441 439
442/* Register Access Control */ 440/* Register Access Control */
443#define portaddr(port, reg) ((port)->membase + (reg)) 441#define portaddr(port, reg) ((port)->membase + (reg))
444#define rd_regb(port, reg) (__raw_readb(portaddr(port, reg)))
445#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg))) 442#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg)))
446#define wr_regb(port, reg, val) __raw_writeb(val, portaddr(port, reg))
447#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg)) 443#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg))
448 444
449/* UART Port Mask */ 445/* UART Port Mask */
diff --git a/drivers/tty/serial/st-asc.c b/drivers/tty/serial/st-asc.c
index dd3a96e07026..c7f61ac27132 100644
--- a/drivers/tty/serial/st-asc.c
+++ b/drivers/tty/serial/st-asc.c
@@ -194,9 +194,9 @@ static inline u32 asc_txfifo_is_empty(struct uart_port *port)
194 return asc_in(port, ASC_STA) & ASC_STA_TE; 194 return asc_in(port, ASC_STA) & ASC_STA_TE;
195} 195}
196 196
197static inline int asc_txfifo_is_full(struct uart_port *port) 197static inline u32 asc_txfifo_is_half_empty(struct uart_port *port)
198{ 198{
199 return asc_in(port, ASC_STA) & ASC_STA_TF; 199 return asc_in(port, ASC_STA) & ASC_STA_THE;
200} 200}
201 201
202static inline const char *asc_port_name(struct uart_port *port) 202static inline const char *asc_port_name(struct uart_port *port)
@@ -628,7 +628,7 @@ static int asc_get_poll_char(struct uart_port *port)
628 628
629static void asc_put_poll_char(struct uart_port *port, unsigned char c) 629static void asc_put_poll_char(struct uart_port *port, unsigned char c)
630{ 630{
631 while (asc_txfifo_is_full(port)) 631 while (!asc_txfifo_is_half_empty(port))
632 cpu_relax(); 632 cpu_relax();
633 asc_out(port, ASC_TXBUF, c); 633 asc_out(port, ASC_TXBUF, c);
634} 634}
@@ -783,7 +783,7 @@ static void asc_console_putchar(struct uart_port *port, int ch)
783 unsigned int timeout = 1000000; 783 unsigned int timeout = 1000000;
784 784
785 /* Wait for upto 1 second in case flow control is stopping us. */ 785 /* Wait for upto 1 second in case flow control is stopping us. */
786 while (--timeout && asc_txfifo_is_full(port)) 786 while (--timeout && !asc_txfifo_is_half_empty(port))
787 udelay(1); 787 udelay(1);
788 788
789 asc_out(port, ASC_TXBUF, ch); 789 asc_out(port, ASC_TXBUF, ch);
diff --git a/drivers/tty/serial/tilegx.c b/drivers/tty/serial/tilegx.c
index f92d7e6bd876..613ccf09dc2a 100644
--- a/drivers/tty/serial/tilegx.c
+++ b/drivers/tty/serial/tilegx.c
@@ -359,8 +359,8 @@ static int tilegx_startup(struct uart_port *port)
359 } 359 }
360 360
361 /* Create our IRQs. */ 361 /* Create our IRQs. */
362 port->irq = create_irq(); 362 port->irq = irq_alloc_hwirq(-1);
363 if (port->irq < 0) 363 if (!port->irq)
364 goto err_uart_dest; 364 goto err_uart_dest;
365 tile_irq_activate(port->irq, TILE_IRQ_PERCPU); 365 tile_irq_activate(port->irq, TILE_IRQ_PERCPU);
366 366
@@ -395,7 +395,7 @@ static int tilegx_startup(struct uart_port *port)
395err_free_irq: 395err_free_irq:
396 free_irq(port->irq, port); 396 free_irq(port->irq, port);
397err_dest_irq: 397err_dest_irq:
398 destroy_irq(port->irq); 398 irq_free_hwirq(port->irq);
399err_uart_dest: 399err_uart_dest:
400 gxio_uart_destroy(context); 400 gxio_uart_destroy(context);
401 ret = -ENXIO; 401 ret = -ENXIO;
@@ -435,7 +435,7 @@ static void tilegx_shutdown(struct uart_port *port)
435 435
436 if (port->irq > 0) { 436 if (port->irq > 0) {
437 free_irq(port->irq, port); 437 free_irq(port->irq, port);
438 destroy_irq(port->irq); 438 irq_free_hwirq(port->irq);
439 port->irq = 0; 439 port->irq = 0;
440 } 440 }
441 441
diff --git a/drivers/tty/serial/uartlite.c b/drivers/tty/serial/uartlite.c
index 5f90ef24d475..dce27f34937e 100644
--- a/drivers/tty/serial/uartlite.c
+++ b/drivers/tty/serial/uartlite.c
@@ -418,14 +418,23 @@ static struct uart_ops ulite_ops = {
418#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE 418#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE
419static void ulite_console_wait_tx(struct uart_port *port) 419static void ulite_console_wait_tx(struct uart_port *port)
420{ 420{
421 int i;
422 u8 val; 421 u8 val;
423 422 unsigned long timeout;
424 /* Spin waiting for TX fifo to have space available */ 423
425 for (i = 0; i < 100000; i++) { 424 /*
425 * Spin waiting for TX fifo to have space available.
426 * When using the Microblaze Debug Module this can take up to 1s
427 */
428 timeout = jiffies + msecs_to_jiffies(1000);
429 while (1) {
426 val = uart_in32(ULITE_STATUS, port); 430 val = uart_in32(ULITE_STATUS, port);
427 if ((val & ULITE_STATUS_TXFULL) == 0) 431 if ((val & ULITE_STATUS_TXFULL) == 0)
428 break; 432 break;
433 if (time_after(jiffies, timeout)) {
434 dev_warn(port->dev,
435 "timeout waiting for TX buffer empty\n");
436 break;
437 }
429 cpu_relax(); 438 cpu_relax();
430 } 439 }
431} 440}
diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c
index f619ad5b5eae..8809775e2ba3 100644
--- a/drivers/tty/serial/xilinx_uartps.c
+++ b/drivers/tty/serial/xilinx_uartps.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * Xilinx PS UART driver 2 * Cadence UART driver (found in Xilinx Zynq)
3 * 3 *
4 * 2011 - 2013 (C) Xilinx Inc. 4 * 2011 - 2014 (C) Xilinx Inc.
5 * 5 *
6 * This program is free software; you can redistribute it 6 * This program is free software; you can redistribute it
7 * and/or modify it under the terms of the GNU General Public 7 * and/or modify it under the terms of the GNU General Public
@@ -9,6 +9,9 @@
9 * either version 2 of the License, or (at your option) any 9 * either version 2 of the License, or (at your option) any
10 * later version. 10 * later version.
11 * 11 *
12 * This driver has originally been pushed by Xilinx using a Zynq-branding. This
13 * still shows in the naming of this file, the kconfig symbols and some symbols
14 * in the code.
12 */ 15 */
13 16
14#if defined(CONFIG_SERIAL_XILINX_PS_UART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 17#if defined(CONFIG_SERIAL_XILINX_PS_UART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
@@ -28,16 +31,16 @@
28#include <linux/of.h> 31#include <linux/of.h>
29#include <linux/module.h> 32#include <linux/module.h>
30 33
31#define XUARTPS_TTY_NAME "ttyPS" 34#define CDNS_UART_TTY_NAME "ttyPS"
32#define XUARTPS_NAME "xuartps" 35#define CDNS_UART_NAME "xuartps"
33#define XUARTPS_MAJOR 0 /* use dynamic node allocation */ 36#define CDNS_UART_MAJOR 0 /* use dynamic node allocation */
34#define XUARTPS_MINOR 0 /* works best with devtmpfs */ 37#define CDNS_UART_MINOR 0 /* works best with devtmpfs */
35#define XUARTPS_NR_PORTS 2 38#define CDNS_UART_NR_PORTS 2
36#define XUARTPS_FIFO_SIZE 64 /* FIFO size */ 39#define CDNS_UART_FIFO_SIZE 64 /* FIFO size */
37#define XUARTPS_REGISTER_SPACE 0xFFF 40#define CDNS_UART_REGISTER_SPACE 0xFFF
38 41
39#define xuartps_readl(offset) ioread32(port->membase + offset) 42#define cdns_uart_readl(offset) ioread32(port->membase + offset)
40#define xuartps_writel(val, offset) iowrite32(val, port->membase + offset) 43#define cdns_uart_writel(val, offset) iowrite32(val, port->membase + offset)
41 44
42/* Rx Trigger level */ 45/* Rx Trigger level */
43static int rx_trigger_level = 56; 46static int rx_trigger_level = 56;
@@ -49,77 +52,62 @@ static int rx_timeout = 10;
49module_param(rx_timeout, uint, S_IRUGO); 52module_param(rx_timeout, uint, S_IRUGO);
50MODULE_PARM_DESC(rx_timeout, "Rx timeout, 1-255"); 53MODULE_PARM_DESC(rx_timeout, "Rx timeout, 1-255");
51 54
52/********************************Register Map********************************/ 55/* Register offsets for the UART. */
53/** UART 56#define CDNS_UART_CR_OFFSET 0x00 /* Control Register */
54 * 57#define CDNS_UART_MR_OFFSET 0x04 /* Mode Register */
55 * Register offsets for the UART. 58#define CDNS_UART_IER_OFFSET 0x08 /* Interrupt Enable */
56 * 59#define CDNS_UART_IDR_OFFSET 0x0C /* Interrupt Disable */
57 */ 60#define CDNS_UART_IMR_OFFSET 0x10 /* Interrupt Mask */
58#define XUARTPS_CR_OFFSET 0x00 /* Control Register [8:0] */ 61#define CDNS_UART_ISR_OFFSET 0x14 /* Interrupt Status */
59#define XUARTPS_MR_OFFSET 0x04 /* Mode Register [10:0] */ 62#define CDNS_UART_BAUDGEN_OFFSET 0x18 /* Baud Rate Generator */
60#define XUARTPS_IER_OFFSET 0x08 /* Interrupt Enable [10:0] */ 63#define CDNS_UART_RXTOUT_OFFSET 0x1C /* RX Timeout */
61#define XUARTPS_IDR_OFFSET 0x0C /* Interrupt Disable [10:0] */ 64#define CDNS_UART_RXWM_OFFSET 0x20 /* RX FIFO Trigger Level */
62#define XUARTPS_IMR_OFFSET 0x10 /* Interrupt Mask [10:0] */ 65#define CDNS_UART_MODEMCR_OFFSET 0x24 /* Modem Control */
63#define XUARTPS_ISR_OFFSET 0x14 /* Interrupt Status [10:0]*/ 66#define CDNS_UART_MODEMSR_OFFSET 0x28 /* Modem Status */
64#define XUARTPS_BAUDGEN_OFFSET 0x18 /* Baud Rate Generator [15:0] */ 67#define CDNS_UART_SR_OFFSET 0x2C /* Channel Status */
65#define XUARTPS_RXTOUT_OFFSET 0x1C /* RX Timeout [7:0] */ 68#define CDNS_UART_FIFO_OFFSET 0x30 /* FIFO */
66#define XUARTPS_RXWM_OFFSET 0x20 /* RX FIFO Trigger Level [5:0] */ 69#define CDNS_UART_BAUDDIV_OFFSET 0x34 /* Baud Rate Divider */
67#define XUARTPS_MODEMCR_OFFSET 0x24 /* Modem Control [5:0] */ 70#define CDNS_UART_FLOWDEL_OFFSET 0x38 /* Flow Delay */
68#define XUARTPS_MODEMSR_OFFSET 0x28 /* Modem Status [8:0] */ 71#define CDNS_UART_IRRX_PWIDTH_OFFSET 0x3C /* IR Min Received Pulse Width */
69#define XUARTPS_SR_OFFSET 0x2C /* Channel Status [11:0] */ 72#define CDNS_UART_IRTX_PWIDTH_OFFSET 0x40 /* IR Transmitted pulse Width */
70#define XUARTPS_FIFO_OFFSET 0x30 /* FIFO [15:0] or [7:0] */ 73#define CDNS_UART_TXWM_OFFSET 0x44 /* TX FIFO Trigger Level */
71#define XUARTPS_BAUDDIV_OFFSET 0x34 /* Baud Rate Divider [7:0] */ 74
72#define XUARTPS_FLOWDEL_OFFSET 0x38 /* Flow Delay [15:0] */ 75/* Control Register Bit Definitions */
73#define XUARTPS_IRRX_PWIDTH_OFFSET 0x3C /* IR Minimum Received Pulse 76#define CDNS_UART_CR_STOPBRK 0x00000100 /* Stop TX break */
74 Width [15:0] */ 77#define CDNS_UART_CR_STARTBRK 0x00000080 /* Set TX break */
75#define XUARTPS_IRTX_PWIDTH_OFFSET 0x40 /* IR Transmitted pulse 78#define CDNS_UART_CR_TX_DIS 0x00000020 /* TX disabled. */
76 Width [7:0] */ 79#define CDNS_UART_CR_TX_EN 0x00000010 /* TX enabled */
77#define XUARTPS_TXWM_OFFSET 0x44 /* TX FIFO Trigger Level [5:0] */ 80#define CDNS_UART_CR_RX_DIS 0x00000008 /* RX disabled. */
78 81#define CDNS_UART_CR_RX_EN 0x00000004 /* RX enabled */
79/** Control Register 82#define CDNS_UART_CR_TXRST 0x00000002 /* TX logic reset */
80 * 83#define CDNS_UART_CR_RXRST 0x00000001 /* RX logic reset */
81 * The Control register (CR) controls the major functions of the device. 84#define CDNS_UART_CR_RST_TO 0x00000040 /* Restart Timeout Counter */
82 * 85
83 * Control Register Bit Definitions 86/*
84 */ 87 * Mode Register:
85#define XUARTPS_CR_STOPBRK 0x00000100 /* Stop TX break */
86#define XUARTPS_CR_STARTBRK 0x00000080 /* Set TX break */
87#define XUARTPS_CR_TX_DIS 0x00000020 /* TX disabled. */
88#define XUARTPS_CR_TX_EN 0x00000010 /* TX enabled */
89#define XUARTPS_CR_RX_DIS 0x00000008 /* RX disabled. */
90#define XUARTPS_CR_RX_EN 0x00000004 /* RX enabled */
91#define XUARTPS_CR_TXRST 0x00000002 /* TX logic reset */
92#define XUARTPS_CR_RXRST 0x00000001 /* RX logic reset */
93#define XUARTPS_CR_RST_TO 0x00000040 /* Restart Timeout Counter */
94
95/** Mode Register
96 *
97 * The mode register (MR) defines the mode of transfer as well as the data 88 * The mode register (MR) defines the mode of transfer as well as the data
98 * format. If this register is modified during transmission or reception, 89 * format. If this register is modified during transmission or reception,
99 * data validity cannot be guaranteed. 90 * data validity cannot be guaranteed.
100 *
101 * Mode Register Bit Definitions
102 *
103 */ 91 */
104#define XUARTPS_MR_CLKSEL 0x00000001 /* Pre-scalar selection */ 92#define CDNS_UART_MR_CLKSEL 0x00000001 /* Pre-scalar selection */
105#define XUARTPS_MR_CHMODE_L_LOOP 0x00000200 /* Local loop back mode */ 93#define CDNS_UART_MR_CHMODE_L_LOOP 0x00000200 /* Local loop back mode */
106#define XUARTPS_MR_CHMODE_NORM 0x00000000 /* Normal mode */ 94#define CDNS_UART_MR_CHMODE_NORM 0x00000000 /* Normal mode */
107 95
108#define XUARTPS_MR_STOPMODE_2_BIT 0x00000080 /* 2 stop bits */ 96#define CDNS_UART_MR_STOPMODE_2_BIT 0x00000080 /* 2 stop bits */
109#define XUARTPS_MR_STOPMODE_1_BIT 0x00000000 /* 1 stop bit */ 97#define CDNS_UART_MR_STOPMODE_1_BIT 0x00000000 /* 1 stop bit */
110 98
111#define XUARTPS_MR_PARITY_NONE 0x00000020 /* No parity mode */ 99#define CDNS_UART_MR_PARITY_NONE 0x00000020 /* No parity mode */
112#define XUARTPS_MR_PARITY_MARK 0x00000018 /* Mark parity mode */ 100#define CDNS_UART_MR_PARITY_MARK 0x00000018 /* Mark parity mode */
113#define XUARTPS_MR_PARITY_SPACE 0x00000010 /* Space parity mode */ 101#define CDNS_UART_MR_PARITY_SPACE 0x00000010 /* Space parity mode */
114#define XUARTPS_MR_PARITY_ODD 0x00000008 /* Odd parity mode */ 102#define CDNS_UART_MR_PARITY_ODD 0x00000008 /* Odd parity mode */
115#define XUARTPS_MR_PARITY_EVEN 0x00000000 /* Even parity mode */ 103#define CDNS_UART_MR_PARITY_EVEN 0x00000000 /* Even parity mode */
116 104
117#define XUARTPS_MR_CHARLEN_6_BIT 0x00000006 /* 6 bits data */ 105#define CDNS_UART_MR_CHARLEN_6_BIT 0x00000006 /* 6 bits data */
118#define XUARTPS_MR_CHARLEN_7_BIT 0x00000004 /* 7 bits data */ 106#define CDNS_UART_MR_CHARLEN_7_BIT 0x00000004 /* 7 bits data */
119#define XUARTPS_MR_CHARLEN_8_BIT 0x00000000 /* 8 bits data */ 107#define CDNS_UART_MR_CHARLEN_8_BIT 0x00000000 /* 8 bits data */
120 108
121/** Interrupt Registers 109/*
122 * 110 * Interrupt Registers:
123 * Interrupt control logic uses the interrupt enable register (IER) and the 111 * Interrupt control logic uses the interrupt enable register (IER) and the
124 * interrupt disable register (IDR) to set the value of the bits in the 112 * interrupt disable register (IDR) to set the value of the bits in the
125 * interrupt mask register (IMR). The IMR determines whether to pass an 113 * interrupt mask register (IMR). The IMR determines whether to pass an
@@ -127,65 +115,65 @@ MODULE_PARM_DESC(rx_timeout, "Rx timeout, 1-255");
127 * Writing a 1 to IER Enables an interrupt, writing a 1 to IDR disables an 115 * Writing a 1 to IER Enables an interrupt, writing a 1 to IDR disables an
128 * interrupt. IMR and ISR are read only, and IER and IDR are write only. 116 * interrupt. IMR and ISR are read only, and IER and IDR are write only.
129 * Reading either IER or IDR returns 0x00. 117 * Reading either IER or IDR returns 0x00.
130 *
131 * All four registers have the same bit definitions. 118 * All four registers have the same bit definitions.
132 */ 119 */
133#define XUARTPS_IXR_TOUT 0x00000100 /* RX Timeout error interrupt */ 120#define CDNS_UART_IXR_TOUT 0x00000100 /* RX Timeout error interrupt */
134#define XUARTPS_IXR_PARITY 0x00000080 /* Parity error interrupt */ 121#define CDNS_UART_IXR_PARITY 0x00000080 /* Parity error interrupt */
135#define XUARTPS_IXR_FRAMING 0x00000040 /* Framing error interrupt */ 122#define CDNS_UART_IXR_FRAMING 0x00000040 /* Framing error interrupt */
136#define XUARTPS_IXR_OVERRUN 0x00000020 /* Overrun error interrupt */ 123#define CDNS_UART_IXR_OVERRUN 0x00000020 /* Overrun error interrupt */
137#define XUARTPS_IXR_TXFULL 0x00000010 /* TX FIFO Full interrupt */ 124#define CDNS_UART_IXR_TXFULL 0x00000010 /* TX FIFO Full interrupt */
138#define XUARTPS_IXR_TXEMPTY 0x00000008 /* TX FIFO empty interrupt */ 125#define CDNS_UART_IXR_TXEMPTY 0x00000008 /* TX FIFO empty interrupt */
139#define XUARTPS_ISR_RXEMPTY 0x00000002 /* RX FIFO empty interrupt */ 126#define CDNS_UART_ISR_RXEMPTY 0x00000002 /* RX FIFO empty interrupt */
140#define XUARTPS_IXR_RXTRIG 0x00000001 /* RX FIFO trigger interrupt */ 127#define CDNS_UART_IXR_RXTRIG 0x00000001 /* RX FIFO trigger interrupt */
141#define XUARTPS_IXR_RXFULL 0x00000004 /* RX FIFO full interrupt. */ 128#define CDNS_UART_IXR_RXFULL 0x00000004 /* RX FIFO full interrupt. */
142#define XUARTPS_IXR_RXEMPTY 0x00000002 /* RX FIFO empty interrupt. */ 129#define CDNS_UART_IXR_RXEMPTY 0x00000002 /* RX FIFO empty interrupt. */
143#define XUARTPS_IXR_MASK 0x00001FFF /* Valid bit mask */ 130#define CDNS_UART_IXR_MASK 0x00001FFF /* Valid bit mask */
144 131
145/* Goes in read_status_mask for break detection as the HW doesn't do it*/ 132/* Goes in read_status_mask for break detection as the HW doesn't do it*/
146#define XUARTPS_IXR_BRK 0x80000000 133#define CDNS_UART_IXR_BRK 0x80000000
147 134
148/** Channel Status Register 135/*
149 * 136 * Channel Status Register:
150 * The channel status register (CSR) is provided to enable the control logic 137 * The channel status register (CSR) is provided to enable the control logic
151 * to monitor the status of bits in the channel interrupt status register, 138 * to monitor the status of bits in the channel interrupt status register,
152 * even if these are masked out by the interrupt mask register. 139 * even if these are masked out by the interrupt mask register.
153 */ 140 */
154#define XUARTPS_SR_RXEMPTY 0x00000002 /* RX FIFO empty */ 141#define CDNS_UART_SR_RXEMPTY 0x00000002 /* RX FIFO empty */
155#define XUARTPS_SR_TXEMPTY 0x00000008 /* TX FIFO empty */ 142#define CDNS_UART_SR_TXEMPTY 0x00000008 /* TX FIFO empty */
156#define XUARTPS_SR_TXFULL 0x00000010 /* TX FIFO full */ 143#define CDNS_UART_SR_TXFULL 0x00000010 /* TX FIFO full */
157#define XUARTPS_SR_RXTRIG 0x00000001 /* Rx Trigger */ 144#define CDNS_UART_SR_RXTRIG 0x00000001 /* Rx Trigger */
158 145
159/* baud dividers min/max values */ 146/* baud dividers min/max values */
160#define XUARTPS_BDIV_MIN 4 147#define CDNS_UART_BDIV_MIN 4
161#define XUARTPS_BDIV_MAX 255 148#define CDNS_UART_BDIV_MAX 255
162#define XUARTPS_CD_MAX 65535 149#define CDNS_UART_CD_MAX 65535
163 150
164/** 151/**
165 * struct xuartps - device data 152 * struct cdns_uart - device data
166 * @port Pointer to the UART port 153 * @port: Pointer to the UART port
167 * @refclk Reference clock 154 * @uartclk: Reference clock
168 * @aperclk APB clock 155 * @pclk: APB clock
169 * @baud Current baud rate 156 * @baud: Current baud rate
170 * @clk_rate_change_nb Notifier block for clock changes 157 * @clk_rate_change_nb: Notifier block for clock changes
171 */ 158 */
172struct xuartps { 159struct cdns_uart {
173 struct uart_port *port; 160 struct uart_port *port;
174 struct clk *refclk; 161 struct clk *uartclk;
175 struct clk *aperclk; 162 struct clk *pclk;
176 unsigned int baud; 163 unsigned int baud;
177 struct notifier_block clk_rate_change_nb; 164 struct notifier_block clk_rate_change_nb;
178}; 165};
179#define to_xuartps(_nb) container_of(_nb, struct xuartps, clk_rate_change_nb); 166#define to_cdns_uart(_nb) container_of(_nb, struct cdns_uart, \
167 clk_rate_change_nb);
180 168
181/** 169/**
182 * xuartps_isr - Interrupt handler 170 * cdns_uart_isr - Interrupt handler
183 * @irq: Irq number 171 * @irq: Irq number
184 * @dev_id: Id of the port 172 * @dev_id: Id of the port
185 * 173 *
186 * Returns IRQHANDLED 174 * Return: IRQHANDLED
187 **/ 175 */
188static irqreturn_t xuartps_isr(int irq, void *dev_id) 176static irqreturn_t cdns_uart_isr(int irq, void *dev_id)
189{ 177{
190 struct uart_port *port = (struct uart_port *)dev_id; 178 struct uart_port *port = (struct uart_port *)dev_id;
191 unsigned long flags; 179 unsigned long flags;
@@ -198,43 +186,42 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
198 /* Read the interrupt status register to determine which 186 /* Read the interrupt status register to determine which
199 * interrupt(s) is/are active. 187 * interrupt(s) is/are active.
200 */ 188 */
201 isrstatus = xuartps_readl(XUARTPS_ISR_OFFSET); 189 isrstatus = cdns_uart_readl(CDNS_UART_ISR_OFFSET);
202 190
203 /* 191 /*
204 * There is no hardware break detection, so we interpret framing 192 * There is no hardware break detection, so we interpret framing
205 * error with all-zeros data as a break sequence. Most of the time, 193 * error with all-zeros data as a break sequence. Most of the time,
206 * there's another non-zero byte at the end of the sequence. 194 * there's another non-zero byte at the end of the sequence.
207 */ 195 */
208 196 if (isrstatus & CDNS_UART_IXR_FRAMING) {
209 if (isrstatus & XUARTPS_IXR_FRAMING) { 197 while (!(cdns_uart_readl(CDNS_UART_SR_OFFSET) &
210 while (!(xuartps_readl(XUARTPS_SR_OFFSET) & 198 CDNS_UART_SR_RXEMPTY)) {
211 XUARTPS_SR_RXEMPTY)) { 199 if (!cdns_uart_readl(CDNS_UART_FIFO_OFFSET)) {
212 if (!xuartps_readl(XUARTPS_FIFO_OFFSET)) { 200 port->read_status_mask |= CDNS_UART_IXR_BRK;
213 port->read_status_mask |= XUARTPS_IXR_BRK; 201 isrstatus &= ~CDNS_UART_IXR_FRAMING;
214 isrstatus &= ~XUARTPS_IXR_FRAMING;
215 } 202 }
216 } 203 }
217 xuartps_writel(XUARTPS_IXR_FRAMING, XUARTPS_ISR_OFFSET); 204 cdns_uart_writel(CDNS_UART_IXR_FRAMING, CDNS_UART_ISR_OFFSET);
218 } 205 }
219 206
220 /* drop byte with parity error if IGNPAR specified */ 207 /* drop byte with parity error if IGNPAR specified */
221 if (isrstatus & port->ignore_status_mask & XUARTPS_IXR_PARITY) 208 if (isrstatus & port->ignore_status_mask & CDNS_UART_IXR_PARITY)
222 isrstatus &= ~(XUARTPS_IXR_RXTRIG | XUARTPS_IXR_TOUT); 209 isrstatus &= ~(CDNS_UART_IXR_RXTRIG | CDNS_UART_IXR_TOUT);
223 210
224 isrstatus &= port->read_status_mask; 211 isrstatus &= port->read_status_mask;
225 isrstatus &= ~port->ignore_status_mask; 212 isrstatus &= ~port->ignore_status_mask;
226 213
227 if ((isrstatus & XUARTPS_IXR_TOUT) || 214 if ((isrstatus & CDNS_UART_IXR_TOUT) ||
228 (isrstatus & XUARTPS_IXR_RXTRIG)) { 215 (isrstatus & CDNS_UART_IXR_RXTRIG)) {
229 /* Receive Timeout Interrupt */ 216 /* Receive Timeout Interrupt */
230 while ((xuartps_readl(XUARTPS_SR_OFFSET) & 217 while ((cdns_uart_readl(CDNS_UART_SR_OFFSET) &
231 XUARTPS_SR_RXEMPTY) != XUARTPS_SR_RXEMPTY) { 218 CDNS_UART_SR_RXEMPTY) != CDNS_UART_SR_RXEMPTY) {
232 data = xuartps_readl(XUARTPS_FIFO_OFFSET); 219 data = cdns_uart_readl(CDNS_UART_FIFO_OFFSET);
233 220
234 /* Non-NULL byte after BREAK is garbage (99%) */ 221 /* Non-NULL byte after BREAK is garbage (99%) */
235 if (data && (port->read_status_mask & 222 if (data && (port->read_status_mask &
236 XUARTPS_IXR_BRK)) { 223 CDNS_UART_IXR_BRK)) {
237 port->read_status_mask &= ~XUARTPS_IXR_BRK; 224 port->read_status_mask &= ~CDNS_UART_IXR_BRK;
238 port->icount.brk++; 225 port->icount.brk++;
239 if (uart_handle_break(port)) 226 if (uart_handle_break(port))
240 continue; 227 continue;
@@ -258,16 +245,17 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
258 245
259 port->icount.rx++; 246 port->icount.rx++;
260 247
261 if (isrstatus & XUARTPS_IXR_PARITY) { 248 if (isrstatus & CDNS_UART_IXR_PARITY) {
262 port->icount.parity++; 249 port->icount.parity++;
263 status = TTY_PARITY; 250 status = TTY_PARITY;
264 } else if (isrstatus & XUARTPS_IXR_FRAMING) { 251 } else if (isrstatus & CDNS_UART_IXR_FRAMING) {
265 port->icount.frame++; 252 port->icount.frame++;
266 status = TTY_FRAME; 253 status = TTY_FRAME;
267 } else if (isrstatus & XUARTPS_IXR_OVERRUN) 254 } else if (isrstatus & CDNS_UART_IXR_OVERRUN) {
268 port->icount.overrun++; 255 port->icount.overrun++;
256 }
269 257
270 uart_insert_char(port, isrstatus, XUARTPS_IXR_OVERRUN, 258 uart_insert_char(port, isrstatus, CDNS_UART_IXR_OVERRUN,
271 data, status); 259 data, status);
272 } 260 }
273 spin_unlock(&port->lock); 261 spin_unlock(&port->lock);
@@ -276,10 +264,10 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
276 } 264 }
277 265
278 /* Dispatch an appropriate handler */ 266 /* Dispatch an appropriate handler */
279 if ((isrstatus & XUARTPS_IXR_TXEMPTY) == XUARTPS_IXR_TXEMPTY) { 267 if ((isrstatus & CDNS_UART_IXR_TXEMPTY) == CDNS_UART_IXR_TXEMPTY) {
280 if (uart_circ_empty(&port->state->xmit)) { 268 if (uart_circ_empty(&port->state->xmit)) {
281 xuartps_writel(XUARTPS_IXR_TXEMPTY, 269 cdns_uart_writel(CDNS_UART_IXR_TXEMPTY,
282 XUARTPS_IDR_OFFSET); 270 CDNS_UART_IDR_OFFSET);
283 } else { 271 } else {
284 numbytes = port->fifosize; 272 numbytes = port->fifosize;
285 /* Break if no more data available in the UART buffer */ 273 /* Break if no more data available in the UART buffer */
@@ -287,12 +275,12 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
287 if (uart_circ_empty(&port->state->xmit)) 275 if (uart_circ_empty(&port->state->xmit))
288 break; 276 break;
289 /* Get the data from the UART circular buffer 277 /* Get the data from the UART circular buffer
290 * and write it to the xuartps's TX_FIFO 278 * and write it to the cdns_uart's TX_FIFO
291 * register. 279 * register.
292 */ 280 */
293 xuartps_writel( 281 cdns_uart_writel(
294 port->state->xmit.buf[port->state->xmit. 282 port->state->xmit.buf[port->state->xmit.
295 tail], XUARTPS_FIFO_OFFSET); 283 tail], CDNS_UART_FIFO_OFFSET);
296 284
297 port->icount.tx++; 285 port->icount.tx++;
298 286
@@ -300,7 +288,7 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
300 * the buffer if it reaches limit. 288 * the buffer if it reaches limit.
301 */ 289 */
302 port->state->xmit.tail = 290 port->state->xmit.tail =
303 (port->state->xmit.tail + 1) & \ 291 (port->state->xmit.tail + 1) &
304 (UART_XMIT_SIZE - 1); 292 (UART_XMIT_SIZE - 1);
305 } 293 }
306 294
@@ -310,7 +298,7 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
310 } 298 }
311 } 299 }
312 300
313 xuartps_writel(isrstatus, XUARTPS_ISR_OFFSET); 301 cdns_uart_writel(isrstatus, CDNS_UART_ISR_OFFSET);
314 302
315 /* be sure to release the lock and tty before leaving */ 303 /* be sure to release the lock and tty before leaving */
316 spin_unlock_irqrestore(&port->lock, flags); 304 spin_unlock_irqrestore(&port->lock, flags);
@@ -319,13 +307,13 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
319} 307}
320 308
321/** 309/**
322 * xuartps_calc_baud_divs - Calculate baud rate divisors 310 * cdns_uart_calc_baud_divs - Calculate baud rate divisors
323 * @clk: UART module input clock 311 * @clk: UART module input clock
324 * @baud: Desired baud rate 312 * @baud: Desired baud rate
325 * @rbdiv: BDIV value (return value) 313 * @rbdiv: BDIV value (return value)
326 * @rcd: CD value (return value) 314 * @rcd: CD value (return value)
327 * @div8: Value for clk_sel bit in mod (return value) 315 * @div8: Value for clk_sel bit in mod (return value)
328 * Returns baud rate, requested baud when possible, or actual baud when there 316 * Return: baud rate, requested baud when possible, or actual baud when there
329 * was too much error, zero if no valid divisors are found. 317 * was too much error, zero if no valid divisors are found.
330 * 318 *
331 * Formula to obtain baud rate is 319 * Formula to obtain baud rate is
@@ -338,8 +326,8 @@ static irqreturn_t xuartps_isr(int irq, void *dev_id)
338 * baud rate generate register 326 * baud rate generate register
339 * baud rate clock divisor register 327 * baud rate clock divisor register
340 */ 328 */
341static unsigned int xuartps_calc_baud_divs(unsigned int clk, unsigned int baud, 329static unsigned int cdns_uart_calc_baud_divs(unsigned int clk,
342 u32 *rbdiv, u32 *rcd, int *div8) 330 unsigned int baud, u32 *rbdiv, u32 *rcd, int *div8)
343{ 331{
344 u32 cd, bdiv; 332 u32 cd, bdiv;
345 unsigned int calc_baud; 333 unsigned int calc_baud;
@@ -347,16 +335,16 @@ static unsigned int xuartps_calc_baud_divs(unsigned int clk, unsigned int baud,
347 unsigned int bauderror; 335 unsigned int bauderror;
348 unsigned int besterror = ~0; 336 unsigned int besterror = ~0;
349 337
350 if (baud < clk / ((XUARTPS_BDIV_MAX + 1) * XUARTPS_CD_MAX)) { 338 if (baud < clk / ((CDNS_UART_BDIV_MAX + 1) * CDNS_UART_CD_MAX)) {
351 *div8 = 1; 339 *div8 = 1;
352 clk /= 8; 340 clk /= 8;
353 } else { 341 } else {
354 *div8 = 0; 342 *div8 = 0;
355 } 343 }
356 344
357 for (bdiv = XUARTPS_BDIV_MIN; bdiv <= XUARTPS_BDIV_MAX; bdiv++) { 345 for (bdiv = CDNS_UART_BDIV_MIN; bdiv <= CDNS_UART_BDIV_MAX; bdiv++) {
358 cd = DIV_ROUND_CLOSEST(clk, baud * (bdiv + 1)); 346 cd = DIV_ROUND_CLOSEST(clk, baud * (bdiv + 1));
359 if (cd < 1 || cd > XUARTPS_CD_MAX) 347 if (cd < 1 || cd > CDNS_UART_CD_MAX)
360 continue; 348 continue;
361 349
362 calc_baud = clk / (cd * (bdiv + 1)); 350 calc_baud = clk / (cd * (bdiv + 1));
@@ -381,47 +369,47 @@ static unsigned int xuartps_calc_baud_divs(unsigned int clk, unsigned int baud,
381} 369}
382 370
383/** 371/**
384 * xuartps_set_baud_rate - Calculate and set the baud rate 372 * cdns_uart_set_baud_rate - Calculate and set the baud rate
385 * @port: Handle to the uart port structure 373 * @port: Handle to the uart port structure
386 * @baud: Baud rate to set 374 * @baud: Baud rate to set
387 * Returns baud rate, requested baud when possible, or actual baud when there 375 * Return: baud rate, requested baud when possible, or actual baud when there
388 * was too much error, zero if no valid divisors are found. 376 * was too much error, zero if no valid divisors are found.
389 */ 377 */
390static unsigned int xuartps_set_baud_rate(struct uart_port *port, 378static unsigned int cdns_uart_set_baud_rate(struct uart_port *port,
391 unsigned int baud) 379 unsigned int baud)
392{ 380{
393 unsigned int calc_baud; 381 unsigned int calc_baud;
394 u32 cd = 0, bdiv = 0; 382 u32 cd = 0, bdiv = 0;
395 u32 mreg; 383 u32 mreg;
396 int div8; 384 int div8;
397 struct xuartps *xuartps = port->private_data; 385 struct cdns_uart *cdns_uart = port->private_data;
398 386
399 calc_baud = xuartps_calc_baud_divs(port->uartclk, baud, &bdiv, &cd, 387 calc_baud = cdns_uart_calc_baud_divs(port->uartclk, baud, &bdiv, &cd,
400 &div8); 388 &div8);
401 389
402 /* Write new divisors to hardware */ 390 /* Write new divisors to hardware */
403 mreg = xuartps_readl(XUARTPS_MR_OFFSET); 391 mreg = cdns_uart_readl(CDNS_UART_MR_OFFSET);
404 if (div8) 392 if (div8)
405 mreg |= XUARTPS_MR_CLKSEL; 393 mreg |= CDNS_UART_MR_CLKSEL;
406 else 394 else
407 mreg &= ~XUARTPS_MR_CLKSEL; 395 mreg &= ~CDNS_UART_MR_CLKSEL;
408 xuartps_writel(mreg, XUARTPS_MR_OFFSET); 396 cdns_uart_writel(mreg, CDNS_UART_MR_OFFSET);
409 xuartps_writel(cd, XUARTPS_BAUDGEN_OFFSET); 397 cdns_uart_writel(cd, CDNS_UART_BAUDGEN_OFFSET);
410 xuartps_writel(bdiv, XUARTPS_BAUDDIV_OFFSET); 398 cdns_uart_writel(bdiv, CDNS_UART_BAUDDIV_OFFSET);
411 xuartps->baud = baud; 399 cdns_uart->baud = baud;
412 400
413 return calc_baud; 401 return calc_baud;
414} 402}
415 403
416#ifdef CONFIG_COMMON_CLK 404#ifdef CONFIG_COMMON_CLK
417/** 405/**
418 * xuartps_clk_notitifer_cb - Clock notifier callback 406 * cdns_uart_clk_notitifer_cb - Clock notifier callback
419 * @nb: Notifier block 407 * @nb: Notifier block
420 * @event: Notify event 408 * @event: Notify event
421 * @data: Notifier data 409 * @data: Notifier data
422 * Returns NOTIFY_OK on success, NOTIFY_BAD on error. 410 * Return: NOTIFY_OK or NOTIFY_DONE on success, NOTIFY_BAD on error.
423 */ 411 */
424static int xuartps_clk_notifier_cb(struct notifier_block *nb, 412static int cdns_uart_clk_notifier_cb(struct notifier_block *nb,
425 unsigned long event, void *data) 413 unsigned long event, void *data)
426{ 414{
427 u32 ctrl_reg; 415 u32 ctrl_reg;
@@ -429,35 +417,36 @@ static int xuartps_clk_notifier_cb(struct notifier_block *nb,
429 int locked = 0; 417 int locked = 0;
430 struct clk_notifier_data *ndata = data; 418 struct clk_notifier_data *ndata = data;
431 unsigned long flags = 0; 419 unsigned long flags = 0;
432 struct xuartps *xuartps = to_xuartps(nb); 420 struct cdns_uart *cdns_uart = to_cdns_uart(nb);
433 421
434 port = xuartps->port; 422 port = cdns_uart->port;
435 if (port->suspended) 423 if (port->suspended)
436 return NOTIFY_OK; 424 return NOTIFY_OK;
437 425
438 switch (event) { 426 switch (event) {
439 case PRE_RATE_CHANGE: 427 case PRE_RATE_CHANGE:
440 { 428 {
441 u32 bdiv; 429 u32 bdiv, cd;
442 u32 cd;
443 int div8; 430 int div8;
444 431
445 /* 432 /*
446 * Find out if current baud-rate can be achieved with new clock 433 * Find out if current baud-rate can be achieved with new clock
447 * frequency. 434 * frequency.
448 */ 435 */
449 if (!xuartps_calc_baud_divs(ndata->new_rate, xuartps->baud, 436 if (!cdns_uart_calc_baud_divs(ndata->new_rate, cdns_uart->baud,
450 &bdiv, &cd, &div8)) 437 &bdiv, &cd, &div8)) {
438 dev_warn(port->dev, "clock rate change rejected\n");
451 return NOTIFY_BAD; 439 return NOTIFY_BAD;
440 }
452 441
453 spin_lock_irqsave(&xuartps->port->lock, flags); 442 spin_lock_irqsave(&cdns_uart->port->lock, flags);
454 443
455 /* Disable the TX and RX to set baud rate */ 444 /* Disable the TX and RX to set baud rate */
456 xuartps_writel(xuartps_readl(XUARTPS_CR_OFFSET) | 445 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
457 (XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS), 446 ctrl_reg |= CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS;
458 XUARTPS_CR_OFFSET); 447 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
459 448
460 spin_unlock_irqrestore(&xuartps->port->lock, flags); 449 spin_unlock_irqrestore(&cdns_uart->port->lock, flags);
461 450
462 return NOTIFY_OK; 451 return NOTIFY_OK;
463 } 452 }
@@ -467,25 +456,25 @@ static int xuartps_clk_notifier_cb(struct notifier_block *nb,
467 * frequency. 456 * frequency.
468 */ 457 */
469 458
470 spin_lock_irqsave(&xuartps->port->lock, flags); 459 spin_lock_irqsave(&cdns_uart->port->lock, flags);
471 460
472 locked = 1; 461 locked = 1;
473 port->uartclk = ndata->new_rate; 462 port->uartclk = ndata->new_rate;
474 463
475 xuartps->baud = xuartps_set_baud_rate(xuartps->port, 464 cdns_uart->baud = cdns_uart_set_baud_rate(cdns_uart->port,
476 xuartps->baud); 465 cdns_uart->baud);
477 /* fall through */ 466 /* fall through */
478 case ABORT_RATE_CHANGE: 467 case ABORT_RATE_CHANGE:
479 if (!locked) 468 if (!locked)
480 spin_lock_irqsave(&xuartps->port->lock, flags); 469 spin_lock_irqsave(&cdns_uart->port->lock, flags);
481 470
482 /* Set TX/RX Reset */ 471 /* Set TX/RX Reset */
483 xuartps_writel(xuartps_readl(XUARTPS_CR_OFFSET) | 472 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
484 (XUARTPS_CR_TXRST | XUARTPS_CR_RXRST), 473 ctrl_reg |= CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST;
485 XUARTPS_CR_OFFSET); 474 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
486 475
487 while (xuartps_readl(XUARTPS_CR_OFFSET) & 476 while (cdns_uart_readl(CDNS_UART_CR_OFFSET) &
488 (XUARTPS_CR_TXRST | XUARTPS_CR_RXRST)) 477 (CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST))
489 cpu_relax(); 478 cpu_relax();
490 479
491 /* 480 /*
@@ -493,14 +482,13 @@ static int xuartps_clk_notifier_cb(struct notifier_block *nb,
493 * enable bit and RX enable bit to enable the transmitter and 482 * enable bit and RX enable bit to enable the transmitter and
494 * receiver. 483 * receiver.
495 */ 484 */
496 xuartps_writel(rx_timeout, XUARTPS_RXTOUT_OFFSET); 485 cdns_uart_writel(rx_timeout, CDNS_UART_RXTOUT_OFFSET);
497 ctrl_reg = xuartps_readl(XUARTPS_CR_OFFSET); 486 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
498 xuartps_writel( 487 ctrl_reg &= ~(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS);
499 (ctrl_reg & ~(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS)) | 488 ctrl_reg |= CDNS_UART_CR_TX_EN | CDNS_UART_CR_RX_EN;
500 (XUARTPS_CR_TX_EN | XUARTPS_CR_RX_EN), 489 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
501 XUARTPS_CR_OFFSET);
502 490
503 spin_unlock_irqrestore(&xuartps->port->lock, flags); 491 spin_unlock_irqrestore(&cdns_uart->port->lock, flags);
504 492
505 return NOTIFY_OK; 493 return NOTIFY_OK;
506 default: 494 default:
@@ -509,40 +497,36 @@ static int xuartps_clk_notifier_cb(struct notifier_block *nb,
509} 497}
510#endif 498#endif
511 499
512/*----------------------Uart Operations---------------------------*/
513
514/** 500/**
515 * xuartps_start_tx - Start transmitting bytes 501 * cdns_uart_start_tx - Start transmitting bytes
516 * @port: Handle to the uart port structure 502 * @port: Handle to the uart port structure
517 * 503 */
518 **/ 504static void cdns_uart_start_tx(struct uart_port *port)
519static void xuartps_start_tx(struct uart_port *port)
520{ 505{
521 unsigned int status, numbytes = port->fifosize; 506 unsigned int status, numbytes = port->fifosize;
522 507
523 if (uart_circ_empty(&port->state->xmit) || uart_tx_stopped(port)) 508 if (uart_circ_empty(&port->state->xmit) || uart_tx_stopped(port))
524 return; 509 return;
525 510
526 status = xuartps_readl(XUARTPS_CR_OFFSET); 511 status = cdns_uart_readl(CDNS_UART_CR_OFFSET);
527 /* Set the TX enable bit and clear the TX disable bit to enable the 512 /* Set the TX enable bit and clear the TX disable bit to enable the
528 * transmitter. 513 * transmitter.
529 */ 514 */
530 xuartps_writel((status & ~XUARTPS_CR_TX_DIS) | XUARTPS_CR_TX_EN, 515 cdns_uart_writel((status & ~CDNS_UART_CR_TX_DIS) | CDNS_UART_CR_TX_EN,
531 XUARTPS_CR_OFFSET); 516 CDNS_UART_CR_OFFSET);
532
533 while (numbytes-- && ((xuartps_readl(XUARTPS_SR_OFFSET)
534 & XUARTPS_SR_TXFULL)) != XUARTPS_SR_TXFULL) {
535 517
518 while (numbytes-- && ((cdns_uart_readl(CDNS_UART_SR_OFFSET) &
519 CDNS_UART_SR_TXFULL)) != CDNS_UART_SR_TXFULL) {
536 /* Break if no more data available in the UART buffer */ 520 /* Break if no more data available in the UART buffer */
537 if (uart_circ_empty(&port->state->xmit)) 521 if (uart_circ_empty(&port->state->xmit))
538 break; 522 break;
539 523
540 /* Get the data from the UART circular buffer and 524 /* Get the data from the UART circular buffer and
541 * write it to the xuartps's TX_FIFO register. 525 * write it to the cdns_uart's TX_FIFO register.
542 */ 526 */
543 xuartps_writel( 527 cdns_uart_writel(
544 port->state->xmit.buf[port->state->xmit.tail], 528 port->state->xmit.buf[port->state->xmit.tail],
545 XUARTPS_FIFO_OFFSET); 529 CDNS_UART_FIFO_OFFSET);
546 port->icount.tx++; 530 port->icount.tx++;
547 531
548 /* Adjust the tail of the UART buffer and wrap 532 /* Adjust the tail of the UART buffer and wrap
@@ -551,94 +535,90 @@ static void xuartps_start_tx(struct uart_port *port)
551 port->state->xmit.tail = (port->state->xmit.tail + 1) & 535 port->state->xmit.tail = (port->state->xmit.tail + 1) &
552 (UART_XMIT_SIZE - 1); 536 (UART_XMIT_SIZE - 1);
553 } 537 }
554 xuartps_writel(XUARTPS_IXR_TXEMPTY, XUARTPS_ISR_OFFSET); 538 cdns_uart_writel(CDNS_UART_IXR_TXEMPTY, CDNS_UART_ISR_OFFSET);
555 /* Enable the TX Empty interrupt */ 539 /* Enable the TX Empty interrupt */
556 xuartps_writel(XUARTPS_IXR_TXEMPTY, XUARTPS_IER_OFFSET); 540 cdns_uart_writel(CDNS_UART_IXR_TXEMPTY, CDNS_UART_IER_OFFSET);
557 541
558 if (uart_circ_chars_pending(&port->state->xmit) < WAKEUP_CHARS) 542 if (uart_circ_chars_pending(&port->state->xmit) < WAKEUP_CHARS)
559 uart_write_wakeup(port); 543 uart_write_wakeup(port);
560} 544}
561 545
562/** 546/**
563 * xuartps_stop_tx - Stop TX 547 * cdns_uart_stop_tx - Stop TX
564 * @port: Handle to the uart port structure 548 * @port: Handle to the uart port structure
565 * 549 */
566 **/ 550static void cdns_uart_stop_tx(struct uart_port *port)
567static void xuartps_stop_tx(struct uart_port *port)
568{ 551{
569 unsigned int regval; 552 unsigned int regval;
570 553
571 regval = xuartps_readl(XUARTPS_CR_OFFSET); 554 regval = cdns_uart_readl(CDNS_UART_CR_OFFSET);
572 regval |= XUARTPS_CR_TX_DIS; 555 regval |= CDNS_UART_CR_TX_DIS;
573 /* Disable the transmitter */ 556 /* Disable the transmitter */
574 xuartps_writel(regval, XUARTPS_CR_OFFSET); 557 cdns_uart_writel(regval, CDNS_UART_CR_OFFSET);
575} 558}
576 559
577/** 560/**
578 * xuartps_stop_rx - Stop RX 561 * cdns_uart_stop_rx - Stop RX
579 * @port: Handle to the uart port structure 562 * @port: Handle to the uart port structure
580 * 563 */
581 **/ 564static void cdns_uart_stop_rx(struct uart_port *port)
582static void xuartps_stop_rx(struct uart_port *port)
583{ 565{
584 unsigned int regval; 566 unsigned int regval;
585 567
586 regval = xuartps_readl(XUARTPS_CR_OFFSET); 568 regval = cdns_uart_readl(CDNS_UART_CR_OFFSET);
587 regval |= XUARTPS_CR_RX_DIS; 569 regval |= CDNS_UART_CR_RX_DIS;
588 /* Disable the receiver */ 570 /* Disable the receiver */
589 xuartps_writel(regval, XUARTPS_CR_OFFSET); 571 cdns_uart_writel(regval, CDNS_UART_CR_OFFSET);
590} 572}
591 573
592/** 574/**
593 * xuartps_tx_empty - Check whether TX is empty 575 * cdns_uart_tx_empty - Check whether TX is empty
594 * @port: Handle to the uart port structure 576 * @port: Handle to the uart port structure
595 * 577 *
596 * Returns TIOCSER_TEMT on success, 0 otherwise 578 * Return: TIOCSER_TEMT on success, 0 otherwise
597 **/ 579 */
598static unsigned int xuartps_tx_empty(struct uart_port *port) 580static unsigned int cdns_uart_tx_empty(struct uart_port *port)
599{ 581{
600 unsigned int status; 582 unsigned int status;
601 583
602 status = xuartps_readl(XUARTPS_ISR_OFFSET) & XUARTPS_IXR_TXEMPTY; 584 status = cdns_uart_readl(CDNS_UART_ISR_OFFSET) & CDNS_UART_IXR_TXEMPTY;
603 return status ? TIOCSER_TEMT : 0; 585 return status ? TIOCSER_TEMT : 0;
604} 586}
605 587
606/** 588/**
607 * xuartps_break_ctl - Based on the input ctl we have to start or stop 589 * cdns_uart_break_ctl - Based on the input ctl we have to start or stop
608 * transmitting char breaks 590 * transmitting char breaks
609 * @port: Handle to the uart port structure 591 * @port: Handle to the uart port structure
610 * @ctl: Value based on which start or stop decision is taken 592 * @ctl: Value based on which start or stop decision is taken
611 * 593 */
612 **/ 594static void cdns_uart_break_ctl(struct uart_port *port, int ctl)
613static void xuartps_break_ctl(struct uart_port *port, int ctl)
614{ 595{
615 unsigned int status; 596 unsigned int status;
616 unsigned long flags; 597 unsigned long flags;
617 598
618 spin_lock_irqsave(&port->lock, flags); 599 spin_lock_irqsave(&port->lock, flags);
619 600
620 status = xuartps_readl(XUARTPS_CR_OFFSET); 601 status = cdns_uart_readl(CDNS_UART_CR_OFFSET);
621 602
622 if (ctl == -1) 603 if (ctl == -1)
623 xuartps_writel(XUARTPS_CR_STARTBRK | status, 604 cdns_uart_writel(CDNS_UART_CR_STARTBRK | status,
624 XUARTPS_CR_OFFSET); 605 CDNS_UART_CR_OFFSET);
625 else { 606 else {
626 if ((status & XUARTPS_CR_STOPBRK) == 0) 607 if ((status & CDNS_UART_CR_STOPBRK) == 0)
627 xuartps_writel(XUARTPS_CR_STOPBRK | status, 608 cdns_uart_writel(CDNS_UART_CR_STOPBRK | status,
628 XUARTPS_CR_OFFSET); 609 CDNS_UART_CR_OFFSET);
629 } 610 }
630 spin_unlock_irqrestore(&port->lock, flags); 611 spin_unlock_irqrestore(&port->lock, flags);
631} 612}
632 613
633/** 614/**
634 * xuartps_set_termios - termios operations, handling data length, parity, 615 * cdns_uart_set_termios - termios operations, handling data length, parity,
635 * stop bits, flow control, baud rate 616 * stop bits, flow control, baud rate
636 * @port: Handle to the uart port structure 617 * @port: Handle to the uart port structure
637 * @termios: Handle to the input termios structure 618 * @termios: Handle to the input termios structure
638 * @old: Values of the previously saved termios structure 619 * @old: Values of the previously saved termios structure
639 * 620 */
640 **/ 621static void cdns_uart_set_termios(struct uart_port *port,
641static void xuartps_set_termios(struct uart_port *port,
642 struct ktermios *termios, struct ktermios *old) 622 struct ktermios *termios, struct ktermios *old)
643{ 623{
644 unsigned int cval = 0; 624 unsigned int cval = 0;
@@ -649,81 +629,79 @@ static void xuartps_set_termios(struct uart_port *port,
649 spin_lock_irqsave(&port->lock, flags); 629 spin_lock_irqsave(&port->lock, flags);
650 630
651 /* Empty the receive FIFO 1st before making changes */ 631 /* Empty the receive FIFO 1st before making changes */
652 while ((xuartps_readl(XUARTPS_SR_OFFSET) & 632 while ((cdns_uart_readl(CDNS_UART_SR_OFFSET) &
653 XUARTPS_SR_RXEMPTY) != XUARTPS_SR_RXEMPTY) { 633 CDNS_UART_SR_RXEMPTY) != CDNS_UART_SR_RXEMPTY) {
654 xuartps_readl(XUARTPS_FIFO_OFFSET); 634 cdns_uart_readl(CDNS_UART_FIFO_OFFSET);
655 } 635 }
656 636
657 /* Disable the TX and RX to set baud rate */ 637 /* Disable the TX and RX to set baud rate */
658 xuartps_writel(xuartps_readl(XUARTPS_CR_OFFSET) | 638 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
659 (XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS), 639 ctrl_reg |= CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS;
660 XUARTPS_CR_OFFSET); 640 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
661 641
662 /* 642 /*
663 * Min baud rate = 6bps and Max Baud Rate is 10Mbps for 100Mhz clk 643 * Min baud rate = 6bps and Max Baud Rate is 10Mbps for 100Mhz clk
664 * min and max baud should be calculated here based on port->uartclk. 644 * min and max baud should be calculated here based on port->uartclk.
665 * this way we get a valid baud and can safely call set_baud() 645 * this way we get a valid baud and can safely call set_baud()
666 */ 646 */
667 minbaud = port->uartclk / ((XUARTPS_BDIV_MAX + 1) * XUARTPS_CD_MAX * 8); 647 minbaud = port->uartclk /
668 maxbaud = port->uartclk / (XUARTPS_BDIV_MIN + 1); 648 ((CDNS_UART_BDIV_MAX + 1) * CDNS_UART_CD_MAX * 8);
649 maxbaud = port->uartclk / (CDNS_UART_BDIV_MIN + 1);
669 baud = uart_get_baud_rate(port, termios, old, minbaud, maxbaud); 650 baud = uart_get_baud_rate(port, termios, old, minbaud, maxbaud);
670 baud = xuartps_set_baud_rate(port, baud); 651 baud = cdns_uart_set_baud_rate(port, baud);
671 if (tty_termios_baud_rate(termios)) 652 if (tty_termios_baud_rate(termios))
672 tty_termios_encode_baud_rate(termios, baud, baud); 653 tty_termios_encode_baud_rate(termios, baud, baud);
673 654
674 /* 655 /* Update the per-port timeout. */
675 * Update the per-port timeout.
676 */
677 uart_update_timeout(port, termios->c_cflag, baud); 656 uart_update_timeout(port, termios->c_cflag, baud);
678 657
679 /* Set TX/RX Reset */ 658 /* Set TX/RX Reset */
680 xuartps_writel(xuartps_readl(XUARTPS_CR_OFFSET) | 659 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
681 (XUARTPS_CR_TXRST | XUARTPS_CR_RXRST), 660 ctrl_reg |= CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST;
682 XUARTPS_CR_OFFSET); 661 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
683 662
684 ctrl_reg = xuartps_readl(XUARTPS_CR_OFFSET); 663 /*
685 664 * Clear the RX disable and TX disable bits and then set the TX enable
686 /* Clear the RX disable and TX disable bits and then set the TX enable
687 * bit and RX enable bit to enable the transmitter and receiver. 665 * bit and RX enable bit to enable the transmitter and receiver.
688 */ 666 */
689 xuartps_writel( 667 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
690 (ctrl_reg & ~(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS)) 668 ctrl_reg &= ~(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS);
691 | (XUARTPS_CR_TX_EN | XUARTPS_CR_RX_EN), 669 ctrl_reg |= CDNS_UART_CR_TX_EN | CDNS_UART_CR_RX_EN;
692 XUARTPS_CR_OFFSET); 670 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
693 671
694 xuartps_writel(rx_timeout, XUARTPS_RXTOUT_OFFSET); 672 cdns_uart_writel(rx_timeout, CDNS_UART_RXTOUT_OFFSET);
695 673
696 port->read_status_mask = XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXTRIG | 674 port->read_status_mask = CDNS_UART_IXR_TXEMPTY | CDNS_UART_IXR_RXTRIG |
697 XUARTPS_IXR_OVERRUN | XUARTPS_IXR_TOUT; 675 CDNS_UART_IXR_OVERRUN | CDNS_UART_IXR_TOUT;
698 port->ignore_status_mask = 0; 676 port->ignore_status_mask = 0;
699 677
700 if (termios->c_iflag & INPCK) 678 if (termios->c_iflag & INPCK)
701 port->read_status_mask |= XUARTPS_IXR_PARITY | 679 port->read_status_mask |= CDNS_UART_IXR_PARITY |
702 XUARTPS_IXR_FRAMING; 680 CDNS_UART_IXR_FRAMING;
703 681
704 if (termios->c_iflag & IGNPAR) 682 if (termios->c_iflag & IGNPAR)
705 port->ignore_status_mask |= XUARTPS_IXR_PARITY | 683 port->ignore_status_mask |= CDNS_UART_IXR_PARITY |
706 XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVERRUN; 684 CDNS_UART_IXR_FRAMING | CDNS_UART_IXR_OVERRUN;
707 685
708 /* ignore all characters if CREAD is not set */ 686 /* ignore all characters if CREAD is not set */
709 if ((termios->c_cflag & CREAD) == 0) 687 if ((termios->c_cflag & CREAD) == 0)
710 port->ignore_status_mask |= XUARTPS_IXR_RXTRIG | 688 port->ignore_status_mask |= CDNS_UART_IXR_RXTRIG |
711 XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | 689 CDNS_UART_IXR_TOUT | CDNS_UART_IXR_PARITY |
712 XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVERRUN; 690 CDNS_UART_IXR_FRAMING | CDNS_UART_IXR_OVERRUN;
713 691
714 mode_reg = xuartps_readl(XUARTPS_MR_OFFSET); 692 mode_reg = cdns_uart_readl(CDNS_UART_MR_OFFSET);
715 693
716 /* Handling Data Size */ 694 /* Handling Data Size */
717 switch (termios->c_cflag & CSIZE) { 695 switch (termios->c_cflag & CSIZE) {
718 case CS6: 696 case CS6:
719 cval |= XUARTPS_MR_CHARLEN_6_BIT; 697 cval |= CDNS_UART_MR_CHARLEN_6_BIT;
720 break; 698 break;
721 case CS7: 699 case CS7:
722 cval |= XUARTPS_MR_CHARLEN_7_BIT; 700 cval |= CDNS_UART_MR_CHARLEN_7_BIT;
723 break; 701 break;
724 default: 702 default:
725 case CS8: 703 case CS8:
726 cval |= XUARTPS_MR_CHARLEN_8_BIT; 704 cval |= CDNS_UART_MR_CHARLEN_8_BIT;
727 termios->c_cflag &= ~CSIZE; 705 termios->c_cflag &= ~CSIZE;
728 termios->c_cflag |= CS8; 706 termios->c_cflag |= CS8;
729 break; 707 break;
@@ -731,134 +709,135 @@ static void xuartps_set_termios(struct uart_port *port,
731 709
732 /* Handling Parity and Stop Bits length */ 710 /* Handling Parity and Stop Bits length */
733 if (termios->c_cflag & CSTOPB) 711 if (termios->c_cflag & CSTOPB)
734 cval |= XUARTPS_MR_STOPMODE_2_BIT; /* 2 STOP bits */ 712 cval |= CDNS_UART_MR_STOPMODE_2_BIT; /* 2 STOP bits */
735 else 713 else
736 cval |= XUARTPS_MR_STOPMODE_1_BIT; /* 1 STOP bit */ 714 cval |= CDNS_UART_MR_STOPMODE_1_BIT; /* 1 STOP bit */
737 715
738 if (termios->c_cflag & PARENB) { 716 if (termios->c_cflag & PARENB) {
739 /* Mark or Space parity */ 717 /* Mark or Space parity */
740 if (termios->c_cflag & CMSPAR) { 718 if (termios->c_cflag & CMSPAR) {
741 if (termios->c_cflag & PARODD) 719 if (termios->c_cflag & PARODD)
742 cval |= XUARTPS_MR_PARITY_MARK; 720 cval |= CDNS_UART_MR_PARITY_MARK;
743 else 721 else
744 cval |= XUARTPS_MR_PARITY_SPACE; 722 cval |= CDNS_UART_MR_PARITY_SPACE;
745 } else { 723 } else {
746 if (termios->c_cflag & PARODD) 724 if (termios->c_cflag & PARODD)
747 cval |= XUARTPS_MR_PARITY_ODD; 725 cval |= CDNS_UART_MR_PARITY_ODD;
748 else 726 else
749 cval |= XUARTPS_MR_PARITY_EVEN; 727 cval |= CDNS_UART_MR_PARITY_EVEN;
750 } 728 }
751 } else { 729 } else {
752 cval |= XUARTPS_MR_PARITY_NONE; 730 cval |= CDNS_UART_MR_PARITY_NONE;
753 } 731 }
754 cval |= mode_reg & 1; 732 cval |= mode_reg & 1;
755 xuartps_writel(cval, XUARTPS_MR_OFFSET); 733 cdns_uart_writel(cval, CDNS_UART_MR_OFFSET);
756 734
757 spin_unlock_irqrestore(&port->lock, flags); 735 spin_unlock_irqrestore(&port->lock, flags);
758} 736}
759 737
760/** 738/**
761 * xuartps_startup - Called when an application opens a xuartps port 739 * cdns_uart_startup - Called when an application opens a cdns_uart port
762 * @port: Handle to the uart port structure 740 * @port: Handle to the uart port structure
763 * 741 *
764 * Returns 0 on success, negative error otherwise 742 * Return: 0 on success, negative errno otherwise
765 **/ 743 */
766static int xuartps_startup(struct uart_port *port) 744static int cdns_uart_startup(struct uart_port *port)
767{ 745{
768 unsigned int retval = 0, status = 0; 746 unsigned int retval = 0, status = 0;
769 747
770 retval = request_irq(port->irq, xuartps_isr, 0, XUARTPS_NAME, 748 retval = request_irq(port->irq, cdns_uart_isr, 0, CDNS_UART_NAME,
771 (void *)port); 749 (void *)port);
772 if (retval) 750 if (retval)
773 return retval; 751 return retval;
774 752
775 /* Disable the TX and RX */ 753 /* Disable the TX and RX */
776 xuartps_writel(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS, 754 cdns_uart_writel(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS,
777 XUARTPS_CR_OFFSET); 755 CDNS_UART_CR_OFFSET);
778 756
779 /* Set the Control Register with TX/RX Enable, TX/RX Reset, 757 /* Set the Control Register with TX/RX Enable, TX/RX Reset,
780 * no break chars. 758 * no break chars.
781 */ 759 */
782 xuartps_writel(XUARTPS_CR_TXRST | XUARTPS_CR_RXRST, 760 cdns_uart_writel(CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST,
783 XUARTPS_CR_OFFSET); 761 CDNS_UART_CR_OFFSET);
784 762
785 status = xuartps_readl(XUARTPS_CR_OFFSET); 763 status = cdns_uart_readl(CDNS_UART_CR_OFFSET);
786 764
787 /* Clear the RX disable and TX disable bits and then set the TX enable 765 /* Clear the RX disable and TX disable bits and then set the TX enable
788 * bit and RX enable bit to enable the transmitter and receiver. 766 * bit and RX enable bit to enable the transmitter and receiver.
789 */ 767 */
790 xuartps_writel((status & ~(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS)) 768 cdns_uart_writel((status & ~(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS))
791 | (XUARTPS_CR_TX_EN | XUARTPS_CR_RX_EN | 769 | (CDNS_UART_CR_TX_EN | CDNS_UART_CR_RX_EN |
792 XUARTPS_CR_STOPBRK), XUARTPS_CR_OFFSET); 770 CDNS_UART_CR_STOPBRK), CDNS_UART_CR_OFFSET);
793 771
794 /* Set the Mode Register with normal mode,8 data bits,1 stop bit, 772 /* Set the Mode Register with normal mode,8 data bits,1 stop bit,
795 * no parity. 773 * no parity.
796 */ 774 */
797 xuartps_writel(XUARTPS_MR_CHMODE_NORM | XUARTPS_MR_STOPMODE_1_BIT 775 cdns_uart_writel(CDNS_UART_MR_CHMODE_NORM | CDNS_UART_MR_STOPMODE_1_BIT
798 | XUARTPS_MR_PARITY_NONE | XUARTPS_MR_CHARLEN_8_BIT, 776 | CDNS_UART_MR_PARITY_NONE | CDNS_UART_MR_CHARLEN_8_BIT,
799 XUARTPS_MR_OFFSET); 777 CDNS_UART_MR_OFFSET);
800 778
801 /* 779 /*
802 * Set the RX FIFO Trigger level to use most of the FIFO, but it 780 * Set the RX FIFO Trigger level to use most of the FIFO, but it
803 * can be tuned with a module parameter 781 * can be tuned with a module parameter
804 */ 782 */
805 xuartps_writel(rx_trigger_level, XUARTPS_RXWM_OFFSET); 783 cdns_uart_writel(rx_trigger_level, CDNS_UART_RXWM_OFFSET);
806 784
807 /* 785 /*
808 * Receive Timeout register is enabled but it 786 * Receive Timeout register is enabled but it
809 * can be tuned with a module parameter 787 * can be tuned with a module parameter
810 */ 788 */
811 xuartps_writel(rx_timeout, XUARTPS_RXTOUT_OFFSET); 789 cdns_uart_writel(rx_timeout, CDNS_UART_RXTOUT_OFFSET);
812 790
813 /* Clear out any pending interrupts before enabling them */ 791 /* Clear out any pending interrupts before enabling them */
814 xuartps_writel(xuartps_readl(XUARTPS_ISR_OFFSET), XUARTPS_ISR_OFFSET); 792 cdns_uart_writel(cdns_uart_readl(CDNS_UART_ISR_OFFSET),
793 CDNS_UART_ISR_OFFSET);
815 794
816 /* Set the Interrupt Registers with desired interrupts */ 795 /* Set the Interrupt Registers with desired interrupts */
817 xuartps_writel(XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_PARITY | 796 cdns_uart_writel(CDNS_UART_IXR_TXEMPTY | CDNS_UART_IXR_PARITY |
818 XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVERRUN | 797 CDNS_UART_IXR_FRAMING | CDNS_UART_IXR_OVERRUN |
819 XUARTPS_IXR_RXTRIG | XUARTPS_IXR_TOUT, XUARTPS_IER_OFFSET); 798 CDNS_UART_IXR_RXTRIG | CDNS_UART_IXR_TOUT,
799 CDNS_UART_IER_OFFSET);
820 800
821 return retval; 801 return retval;
822} 802}
823 803
824/** 804/**
825 * xuartps_shutdown - Called when an application closes a xuartps port 805 * cdns_uart_shutdown - Called when an application closes a cdns_uart port
826 * @port: Handle to the uart port structure 806 * @port: Handle to the uart port structure
827 * 807 */
828 **/ 808static void cdns_uart_shutdown(struct uart_port *port)
829static void xuartps_shutdown(struct uart_port *port)
830{ 809{
831 int status; 810 int status;
832 811
833 /* Disable interrupts */ 812 /* Disable interrupts */
834 status = xuartps_readl(XUARTPS_IMR_OFFSET); 813 status = cdns_uart_readl(CDNS_UART_IMR_OFFSET);
835 xuartps_writel(status, XUARTPS_IDR_OFFSET); 814 cdns_uart_writel(status, CDNS_UART_IDR_OFFSET);
836 815
837 /* Disable the TX and RX */ 816 /* Disable the TX and RX */
838 xuartps_writel(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS, 817 cdns_uart_writel(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS,
839 XUARTPS_CR_OFFSET); 818 CDNS_UART_CR_OFFSET);
840 free_irq(port->irq, port); 819 free_irq(port->irq, port);
841} 820}
842 821
843/** 822/**
844 * xuartps_type - Set UART type to xuartps port 823 * cdns_uart_type - Set UART type to cdns_uart port
845 * @port: Handle to the uart port structure 824 * @port: Handle to the uart port structure
846 * 825 *
847 * Returns string on success, NULL otherwise 826 * Return: string on success, NULL otherwise
848 **/ 827 */
849static const char *xuartps_type(struct uart_port *port) 828static const char *cdns_uart_type(struct uart_port *port)
850{ 829{
851 return port->type == PORT_XUARTPS ? XUARTPS_NAME : NULL; 830 return port->type == PORT_XUARTPS ? CDNS_UART_NAME : NULL;
852} 831}
853 832
854/** 833/**
855 * xuartps_verify_port - Verify the port params 834 * cdns_uart_verify_port - Verify the port params
856 * @port: Handle to the uart port structure 835 * @port: Handle to the uart port structure
857 * @ser: Handle to the structure whose members are compared 836 * @ser: Handle to the structure whose members are compared
858 * 837 *
859 * Returns 0 if success otherwise -EINVAL 838 * Return: 0 on success, negative errno otherwise.
860 **/ 839 */
861static int xuartps_verify_port(struct uart_port *port, 840static int cdns_uart_verify_port(struct uart_port *port,
862 struct serial_struct *ser) 841 struct serial_struct *ser)
863{ 842{
864 if (ser->type != PORT_UNKNOWN && ser->type != PORT_XUARTPS) 843 if (ser->type != PORT_UNKNOWN && ser->type != PORT_XUARTPS)
@@ -875,187 +854,170 @@ static int xuartps_verify_port(struct uart_port *port,
875} 854}
876 855
877/** 856/**
878 * xuartps_request_port - Claim the memory region attached to xuartps port, 857 * cdns_uart_request_port - Claim the memory region attached to cdns_uart port,
879 * called when the driver adds a xuartps port via 858 * called when the driver adds a cdns_uart port via
880 * uart_add_one_port() 859 * uart_add_one_port()
881 * @port: Handle to the uart port structure 860 * @port: Handle to the uart port structure
882 * 861 *
883 * Returns 0, -ENOMEM if request fails 862 * Return: 0 on success, negative errno otherwise.
884 **/ 863 */
885static int xuartps_request_port(struct uart_port *port) 864static int cdns_uart_request_port(struct uart_port *port)
886{ 865{
887 if (!request_mem_region(port->mapbase, XUARTPS_REGISTER_SPACE, 866 if (!request_mem_region(port->mapbase, CDNS_UART_REGISTER_SPACE,
888 XUARTPS_NAME)) { 867 CDNS_UART_NAME)) {
889 return -ENOMEM; 868 return -ENOMEM;
890 } 869 }
891 870
892 port->membase = ioremap(port->mapbase, XUARTPS_REGISTER_SPACE); 871 port->membase = ioremap(port->mapbase, CDNS_UART_REGISTER_SPACE);
893 if (!port->membase) { 872 if (!port->membase) {
894 dev_err(port->dev, "Unable to map registers\n"); 873 dev_err(port->dev, "Unable to map registers\n");
895 release_mem_region(port->mapbase, XUARTPS_REGISTER_SPACE); 874 release_mem_region(port->mapbase, CDNS_UART_REGISTER_SPACE);
896 return -ENOMEM; 875 return -ENOMEM;
897 } 876 }
898 return 0; 877 return 0;
899} 878}
900 879
901/** 880/**
902 * xuartps_release_port - Release the memory region attached to a xuartps 881 * cdns_uart_release_port - Release UART port
903 * port, called when the driver removes a xuartps
904 * port via uart_remove_one_port().
905 * @port: Handle to the uart port structure 882 * @port: Handle to the uart port structure
906 * 883 *
907 **/ 884 * Release the memory region attached to a cdns_uart port. Called when the
908static void xuartps_release_port(struct uart_port *port) 885 * driver removes a cdns_uart port via uart_remove_one_port().
886 */
887static void cdns_uart_release_port(struct uart_port *port)
909{ 888{
910 release_mem_region(port->mapbase, XUARTPS_REGISTER_SPACE); 889 release_mem_region(port->mapbase, CDNS_UART_REGISTER_SPACE);
911 iounmap(port->membase); 890 iounmap(port->membase);
912 port->membase = NULL; 891 port->membase = NULL;
913} 892}
914 893
915/** 894/**
916 * xuartps_config_port - Configure xuartps, called when the driver adds a 895 * cdns_uart_config_port - Configure UART port
917 * xuartps port
918 * @port: Handle to the uart port structure 896 * @port: Handle to the uart port structure
919 * @flags: If any 897 * @flags: If any
920 * 898 */
921 **/ 899static void cdns_uart_config_port(struct uart_port *port, int flags)
922static void xuartps_config_port(struct uart_port *port, int flags)
923{ 900{
924 if (flags & UART_CONFIG_TYPE && xuartps_request_port(port) == 0) 901 if (flags & UART_CONFIG_TYPE && cdns_uart_request_port(port) == 0)
925 port->type = PORT_XUARTPS; 902 port->type = PORT_XUARTPS;
926} 903}
927 904
928/** 905/**
929 * xuartps_get_mctrl - Get the modem control state 906 * cdns_uart_get_mctrl - Get the modem control state
930 *
931 * @port: Handle to the uart port structure 907 * @port: Handle to the uart port structure
932 * 908 *
933 * Returns the modem control state 909 * Return: the modem control state
934 * 910 */
935 **/ 911static unsigned int cdns_uart_get_mctrl(struct uart_port *port)
936static unsigned int xuartps_get_mctrl(struct uart_port *port)
937{ 912{
938 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; 913 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
939} 914}
940 915
941static void xuartps_set_mctrl(struct uart_port *port, unsigned int mctrl) 916static void cdns_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
942{ 917{
943 /* N/A */ 918 /* N/A */
944} 919}
945 920
946static void xuartps_enable_ms(struct uart_port *port) 921static void cdns_uart_enable_ms(struct uart_port *port)
947{ 922{
948 /* N/A */ 923 /* N/A */
949} 924}
950 925
951#ifdef CONFIG_CONSOLE_POLL 926#ifdef CONFIG_CONSOLE_POLL
952static int xuartps_poll_get_char(struct uart_port *port) 927static int cdns_uart_poll_get_char(struct uart_port *port)
953{ 928{
954 u32 imr; 929 u32 imr;
955 int c; 930 int c;
956 931
957 /* Disable all interrupts */ 932 /* Disable all interrupts */
958 imr = xuartps_readl(XUARTPS_IMR_OFFSET); 933 imr = cdns_uart_readl(CDNS_UART_IMR_OFFSET);
959 xuartps_writel(imr, XUARTPS_IDR_OFFSET); 934 cdns_uart_writel(imr, CDNS_UART_IDR_OFFSET);
960 935
961 /* Check if FIFO is empty */ 936 /* Check if FIFO is empty */
962 if (xuartps_readl(XUARTPS_SR_OFFSET) & XUARTPS_SR_RXEMPTY) 937 if (cdns_uart_readl(CDNS_UART_SR_OFFSET) & CDNS_UART_SR_RXEMPTY)
963 c = NO_POLL_CHAR; 938 c = NO_POLL_CHAR;
964 else /* Read a character */ 939 else /* Read a character */
965 c = (unsigned char) xuartps_readl(XUARTPS_FIFO_OFFSET); 940 c = (unsigned char) cdns_uart_readl(CDNS_UART_FIFO_OFFSET);
966 941
967 /* Enable interrupts */ 942 /* Enable interrupts */
968 xuartps_writel(imr, XUARTPS_IER_OFFSET); 943 cdns_uart_writel(imr, CDNS_UART_IER_OFFSET);
969 944
970 return c; 945 return c;
971} 946}
972 947
973static void xuartps_poll_put_char(struct uart_port *port, unsigned char c) 948static void cdns_uart_poll_put_char(struct uart_port *port, unsigned char c)
974{ 949{
975 u32 imr; 950 u32 imr;
976 951
977 /* Disable all interrupts */ 952 /* Disable all interrupts */
978 imr = xuartps_readl(XUARTPS_IMR_OFFSET); 953 imr = cdns_uart_readl(CDNS_UART_IMR_OFFSET);
979 xuartps_writel(imr, XUARTPS_IDR_OFFSET); 954 cdns_uart_writel(imr, CDNS_UART_IDR_OFFSET);
980 955
981 /* Wait until FIFO is empty */ 956 /* Wait until FIFO is empty */
982 while (!(xuartps_readl(XUARTPS_SR_OFFSET) & XUARTPS_SR_TXEMPTY)) 957 while (!(cdns_uart_readl(CDNS_UART_SR_OFFSET) & CDNS_UART_SR_TXEMPTY))
983 cpu_relax(); 958 cpu_relax();
984 959
985 /* Write a character */ 960 /* Write a character */
986 xuartps_writel(c, XUARTPS_FIFO_OFFSET); 961 cdns_uart_writel(c, CDNS_UART_FIFO_OFFSET);
987 962
988 /* Wait until FIFO is empty */ 963 /* Wait until FIFO is empty */
989 while (!(xuartps_readl(XUARTPS_SR_OFFSET) & XUARTPS_SR_TXEMPTY)) 964 while (!(cdns_uart_readl(CDNS_UART_SR_OFFSET) & CDNS_UART_SR_TXEMPTY))
990 cpu_relax(); 965 cpu_relax();
991 966
992 /* Enable interrupts */ 967 /* Enable interrupts */
993 xuartps_writel(imr, XUARTPS_IER_OFFSET); 968 cdns_uart_writel(imr, CDNS_UART_IER_OFFSET);
994 969
995 return; 970 return;
996} 971}
997#endif 972#endif
998 973
999/** The UART operations structure 974static struct uart_ops cdns_uart_ops = {
1000 */ 975 .set_mctrl = cdns_uart_set_mctrl,
1001static struct uart_ops xuartps_ops = { 976 .get_mctrl = cdns_uart_get_mctrl,
1002 .set_mctrl = xuartps_set_mctrl, 977 .enable_ms = cdns_uart_enable_ms,
1003 .get_mctrl = xuartps_get_mctrl, 978 .start_tx = cdns_uart_start_tx,
1004 .enable_ms = xuartps_enable_ms, 979 .stop_tx = cdns_uart_stop_tx,
1005 980 .stop_rx = cdns_uart_stop_rx,
1006 .start_tx = xuartps_start_tx, /* Start transmitting */ 981 .tx_empty = cdns_uart_tx_empty,
1007 .stop_tx = xuartps_stop_tx, /* Stop transmission */ 982 .break_ctl = cdns_uart_break_ctl,
1008 .stop_rx = xuartps_stop_rx, /* Stop reception */ 983 .set_termios = cdns_uart_set_termios,
1009 .tx_empty = xuartps_tx_empty, /* Transmitter busy? */ 984 .startup = cdns_uart_startup,
1010 .break_ctl = xuartps_break_ctl, /* Start/stop 985 .shutdown = cdns_uart_shutdown,
1011 * transmitting break 986 .type = cdns_uart_type,
1012 */ 987 .verify_port = cdns_uart_verify_port,
1013 .set_termios = xuartps_set_termios, /* Set termios */ 988 .request_port = cdns_uart_request_port,
1014 .startup = xuartps_startup, /* App opens xuartps */ 989 .release_port = cdns_uart_release_port,
1015 .shutdown = xuartps_shutdown, /* App closes xuartps */ 990 .config_port = cdns_uart_config_port,
1016 .type = xuartps_type, /* Set UART type */
1017 .verify_port = xuartps_verify_port, /* Verification of port
1018 * params
1019 */
1020 .request_port = xuartps_request_port, /* Claim resources
1021 * associated with a
1022 * xuartps port
1023 */
1024 .release_port = xuartps_release_port, /* Release resources
1025 * associated with a
1026 * xuartps port
1027 */
1028 .config_port = xuartps_config_port, /* Configure when driver
1029 * adds a xuartps port
1030 */
1031#ifdef CONFIG_CONSOLE_POLL 991#ifdef CONFIG_CONSOLE_POLL
1032 .poll_get_char = xuartps_poll_get_char, 992 .poll_get_char = cdns_uart_poll_get_char,
1033 .poll_put_char = xuartps_poll_put_char, 993 .poll_put_char = cdns_uart_poll_put_char,
1034#endif 994#endif
1035}; 995};
1036 996
1037static struct uart_port xuartps_port[2]; 997static struct uart_port cdns_uart_port[2];
1038 998
1039/** 999/**
1040 * xuartps_get_port - Configure the port from the platform device resource 1000 * cdns_uart_get_port - Configure the port from platform device resource info
1041 * info 1001 * @id: Port id
1042 * 1002 *
1043 * Returns a pointer to a uart_port or NULL for failure 1003 * Return: a pointer to a uart_port or NULL for failure
1044 **/ 1004 */
1045static struct uart_port *xuartps_get_port(void) 1005static struct uart_port *cdns_uart_get_port(int id)
1046{ 1006{
1047 struct uart_port *port; 1007 struct uart_port *port;
1048 int id;
1049 1008
1050 /* Find the next unused port */ 1009 /* Try the given port id if failed use default method */
1051 for (id = 0; id < XUARTPS_NR_PORTS; id++) 1010 if (cdns_uart_port[id].mapbase != 0) {
1052 if (xuartps_port[id].mapbase == 0) 1011 /* Find the next unused port */
1053 break; 1012 for (id = 0; id < CDNS_UART_NR_PORTS; id++)
1013 if (cdns_uart_port[id].mapbase == 0)
1014 break;
1015 }
1054 1016
1055 if (id >= XUARTPS_NR_PORTS) 1017 if (id >= CDNS_UART_NR_PORTS)
1056 return NULL; 1018 return NULL;
1057 1019
1058 port = &xuartps_port[id]; 1020 port = &cdns_uart_port[id];
1059 1021
1060 /* At this point, we've got an empty uart_port struct, initialize it */ 1022 /* At this point, we've got an empty uart_port struct, initialize it */
1061 spin_lock_init(&port->lock); 1023 spin_lock_init(&port->lock);
@@ -1065,50 +1027,46 @@ static struct uart_port *xuartps_get_port(void)
1065 port->type = PORT_UNKNOWN; 1027 port->type = PORT_UNKNOWN;
1066 port->iotype = UPIO_MEM32; 1028 port->iotype = UPIO_MEM32;
1067 port->flags = UPF_BOOT_AUTOCONF; 1029 port->flags = UPF_BOOT_AUTOCONF;
1068 port->ops = &xuartps_ops; 1030 port->ops = &cdns_uart_ops;
1069 port->fifosize = XUARTPS_FIFO_SIZE; 1031 port->fifosize = CDNS_UART_FIFO_SIZE;
1070 port->line = id; 1032 port->line = id;
1071 port->dev = NULL; 1033 port->dev = NULL;
1072 return port; 1034 return port;
1073} 1035}
1074 1036
1075/*-----------------------Console driver operations--------------------------*/
1076
1077#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE 1037#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE
1078/** 1038/**
1079 * xuartps_console_wait_tx - Wait for the TX to be full 1039 * cdns_uart_console_wait_tx - Wait for the TX to be full
1080 * @port: Handle to the uart port structure 1040 * @port: Handle to the uart port structure
1081 * 1041 */
1082 **/ 1042static void cdns_uart_console_wait_tx(struct uart_port *port)
1083static void xuartps_console_wait_tx(struct uart_port *port)
1084{ 1043{
1085 while ((xuartps_readl(XUARTPS_SR_OFFSET) & XUARTPS_SR_TXEMPTY) 1044 while ((cdns_uart_readl(CDNS_UART_SR_OFFSET) & CDNS_UART_SR_TXEMPTY)
1086 != XUARTPS_SR_TXEMPTY) 1045 != CDNS_UART_SR_TXEMPTY)
1087 barrier(); 1046 barrier();
1088} 1047}
1089 1048
1090/** 1049/**
1091 * xuartps_console_putchar - write the character to the FIFO buffer 1050 * cdns_uart_console_putchar - write the character to the FIFO buffer
1092 * @port: Handle to the uart port structure 1051 * @port: Handle to the uart port structure
1093 * @ch: Character to be written 1052 * @ch: Character to be written
1094 * 1053 */
1095 **/ 1054static void cdns_uart_console_putchar(struct uart_port *port, int ch)
1096static void xuartps_console_putchar(struct uart_port *port, int ch)
1097{ 1055{
1098 xuartps_console_wait_tx(port); 1056 cdns_uart_console_wait_tx(port);
1099 xuartps_writel(ch, XUARTPS_FIFO_OFFSET); 1057 cdns_uart_writel(ch, CDNS_UART_FIFO_OFFSET);
1100} 1058}
1101 1059
1102/** 1060/**
1103 * xuartps_console_write - perform write operation 1061 * cdns_uart_console_write - perform write operation
1104 * @port: Handle to the uart port structure 1062 * @co: Console handle
1105 * @s: Pointer to character array 1063 * @s: Pointer to character array
1106 * @count: No of characters 1064 * @count: No of characters
1107 **/ 1065 */
1108static void xuartps_console_write(struct console *co, const char *s, 1066static void cdns_uart_console_write(struct console *co, const char *s,
1109 unsigned int count) 1067 unsigned int count)
1110{ 1068{
1111 struct uart_port *port = &xuartps_port[co->index]; 1069 struct uart_port *port = &cdns_uart_port[co->index];
1112 unsigned long flags; 1070 unsigned long flags;
1113 unsigned int imr, ctrl; 1071 unsigned int imr, ctrl;
1114 int locked = 1; 1072 int locked = 1;
@@ -1119,49 +1077,45 @@ static void xuartps_console_write(struct console *co, const char *s,
1119 spin_lock_irqsave(&port->lock, flags); 1077 spin_lock_irqsave(&port->lock, flags);
1120 1078
1121 /* save and disable interrupt */ 1079 /* save and disable interrupt */
1122 imr = xuartps_readl(XUARTPS_IMR_OFFSET); 1080 imr = cdns_uart_readl(CDNS_UART_IMR_OFFSET);
1123 xuartps_writel(imr, XUARTPS_IDR_OFFSET); 1081 cdns_uart_writel(imr, CDNS_UART_IDR_OFFSET);
1124 1082
1125 /* 1083 /*
1126 * Make sure that the tx part is enabled. Set the TX enable bit and 1084 * Make sure that the tx part is enabled. Set the TX enable bit and
1127 * clear the TX disable bit to enable the transmitter. 1085 * clear the TX disable bit to enable the transmitter.
1128 */ 1086 */
1129 ctrl = xuartps_readl(XUARTPS_CR_OFFSET); 1087 ctrl = cdns_uart_readl(CDNS_UART_CR_OFFSET);
1130 xuartps_writel((ctrl & ~XUARTPS_CR_TX_DIS) | XUARTPS_CR_TX_EN, 1088 cdns_uart_writel((ctrl & ~CDNS_UART_CR_TX_DIS) | CDNS_UART_CR_TX_EN,
1131 XUARTPS_CR_OFFSET); 1089 CDNS_UART_CR_OFFSET);
1132 1090
1133 uart_console_write(port, s, count, xuartps_console_putchar); 1091 uart_console_write(port, s, count, cdns_uart_console_putchar);
1134 xuartps_console_wait_tx(port); 1092 cdns_uart_console_wait_tx(port);
1135 1093
1136 xuartps_writel(ctrl, XUARTPS_CR_OFFSET); 1094 cdns_uart_writel(ctrl, CDNS_UART_CR_OFFSET);
1137 1095
1138 /* restore interrupt state, it seems like there may be a h/w bug 1096 /* restore interrupt state */
1139 * in that the interrupt enable register should not need to be 1097 cdns_uart_writel(imr, CDNS_UART_IER_OFFSET);
1140 * written based on the data sheet
1141 */
1142 xuartps_writel(~imr, XUARTPS_IDR_OFFSET);
1143 xuartps_writel(imr, XUARTPS_IER_OFFSET);
1144 1098
1145 if (locked) 1099 if (locked)
1146 spin_unlock_irqrestore(&port->lock, flags); 1100 spin_unlock_irqrestore(&port->lock, flags);
1147} 1101}
1148 1102
1149/** 1103/**
1150 * xuartps_console_setup - Initialize the uart to default config 1104 * cdns_uart_console_setup - Initialize the uart to default config
1151 * @co: Console handle 1105 * @co: Console handle
1152 * @options: Initial settings of uart 1106 * @options: Initial settings of uart
1153 * 1107 *
1154 * Returns 0, -ENODEV if no device 1108 * Return: 0 on success, negative errno otherwise.
1155 **/ 1109 */
1156static int __init xuartps_console_setup(struct console *co, char *options) 1110static int __init cdns_uart_console_setup(struct console *co, char *options)
1157{ 1111{
1158 struct uart_port *port = &xuartps_port[co->index]; 1112 struct uart_port *port = &cdns_uart_port[co->index];
1159 int baud = 9600; 1113 int baud = 9600;
1160 int bits = 8; 1114 int bits = 8;
1161 int parity = 'n'; 1115 int parity = 'n';
1162 int flow = 'n'; 1116 int flow = 'n';
1163 1117
1164 if (co->index < 0 || co->index >= XUARTPS_NR_PORTS) 1118 if (co->index < 0 || co->index >= CDNS_UART_NR_PORTS)
1165 return -EINVAL; 1119 return -EINVAL;
1166 1120
1167 if (!port->mapbase) { 1121 if (!port->mapbase) {
@@ -1175,55 +1129,53 @@ static int __init xuartps_console_setup(struct console *co, char *options)
1175 return uart_set_options(port, co, baud, parity, bits, flow); 1129 return uart_set_options(port, co, baud, parity, bits, flow);
1176} 1130}
1177 1131
1178static struct uart_driver xuartps_uart_driver; 1132static struct uart_driver cdns_uart_uart_driver;
1179 1133
1180static struct console xuartps_console = { 1134static struct console cdns_uart_console = {
1181 .name = XUARTPS_TTY_NAME, 1135 .name = CDNS_UART_TTY_NAME,
1182 .write = xuartps_console_write, 1136 .write = cdns_uart_console_write,
1183 .device = uart_console_device, 1137 .device = uart_console_device,
1184 .setup = xuartps_console_setup, 1138 .setup = cdns_uart_console_setup,
1185 .flags = CON_PRINTBUFFER, 1139 .flags = CON_PRINTBUFFER,
1186 .index = -1, /* Specified on the cmdline (e.g. console=ttyPS ) */ 1140 .index = -1, /* Specified on the cmdline (e.g. console=ttyPS ) */
1187 .data = &xuartps_uart_driver, 1141 .data = &cdns_uart_uart_driver,
1188}; 1142};
1189 1143
1190/** 1144/**
1191 * xuartps_console_init - Initialization call 1145 * cdns_uart_console_init - Initialization call
1192 * 1146 *
1193 * Returns 0 on success, negative error otherwise 1147 * Return: 0 on success, negative errno otherwise
1194 **/ 1148 */
1195static int __init xuartps_console_init(void) 1149static int __init cdns_uart_console_init(void)
1196{ 1150{
1197 register_console(&xuartps_console); 1151 register_console(&cdns_uart_console);
1198 return 0; 1152 return 0;
1199} 1153}
1200 1154
1201console_initcall(xuartps_console_init); 1155console_initcall(cdns_uart_console_init);
1202 1156
1203#endif /* CONFIG_SERIAL_XILINX_PS_UART_CONSOLE */ 1157#endif /* CONFIG_SERIAL_XILINX_PS_UART_CONSOLE */
1204 1158
1205/** Structure Definitions 1159static struct uart_driver cdns_uart_uart_driver = {
1206 */ 1160 .owner = THIS_MODULE,
1207static struct uart_driver xuartps_uart_driver = { 1161 .driver_name = CDNS_UART_NAME,
1208 .owner = THIS_MODULE, /* Owner */ 1162 .dev_name = CDNS_UART_TTY_NAME,
1209 .driver_name = XUARTPS_NAME, /* Driver name */ 1163 .major = CDNS_UART_MAJOR,
1210 .dev_name = XUARTPS_TTY_NAME, /* Node name */ 1164 .minor = CDNS_UART_MINOR,
1211 .major = XUARTPS_MAJOR, /* Major number */ 1165 .nr = CDNS_UART_NR_PORTS,
1212 .minor = XUARTPS_MINOR, /* Minor number */
1213 .nr = XUARTPS_NR_PORTS, /* Number of UART ports */
1214#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE 1166#ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE
1215 .cons = &xuartps_console, /* Console */ 1167 .cons = &cdns_uart_console,
1216#endif 1168#endif
1217}; 1169};
1218 1170
1219#ifdef CONFIG_PM_SLEEP 1171#ifdef CONFIG_PM_SLEEP
1220/** 1172/**
1221 * xuartps_suspend - suspend event 1173 * cdns_uart_suspend - suspend event
1222 * @device: Pointer to the device structure 1174 * @device: Pointer to the device structure
1223 * 1175 *
1224 * Returns 0 1176 * Return: 0
1225 */ 1177 */
1226static int xuartps_suspend(struct device *device) 1178static int cdns_uart_suspend(struct device *device)
1227{ 1179{
1228 struct uart_port *port = dev_get_drvdata(device); 1180 struct uart_port *port = dev_get_drvdata(device);
1229 struct tty_struct *tty; 1181 struct tty_struct *tty;
@@ -1242,23 +1194,24 @@ static int xuartps_suspend(struct device *device)
1242 * Call the API provided in serial_core.c file which handles 1194 * Call the API provided in serial_core.c file which handles
1243 * the suspend. 1195 * the suspend.
1244 */ 1196 */
1245 uart_suspend_port(&xuartps_uart_driver, port); 1197 uart_suspend_port(&cdns_uart_uart_driver, port);
1246 if (console_suspend_enabled && !may_wake) { 1198 if (console_suspend_enabled && !may_wake) {
1247 struct xuartps *xuartps = port->private_data; 1199 struct cdns_uart *cdns_uart = port->private_data;
1248 1200
1249 clk_disable(xuartps->refclk); 1201 clk_disable(cdns_uart->uartclk);
1250 clk_disable(xuartps->aperclk); 1202 clk_disable(cdns_uart->pclk);
1251 } else { 1203 } else {
1252 unsigned long flags = 0; 1204 unsigned long flags = 0;
1253 1205
1254 spin_lock_irqsave(&port->lock, flags); 1206 spin_lock_irqsave(&port->lock, flags);
1255 /* Empty the receive FIFO 1st before making changes */ 1207 /* Empty the receive FIFO 1st before making changes */
1256 while (!(xuartps_readl(XUARTPS_SR_OFFSET) & XUARTPS_SR_RXEMPTY)) 1208 while (!(cdns_uart_readl(CDNS_UART_SR_OFFSET) &
1257 xuartps_readl(XUARTPS_FIFO_OFFSET); 1209 CDNS_UART_SR_RXEMPTY))
1210 cdns_uart_readl(CDNS_UART_FIFO_OFFSET);
1258 /* set RX trigger level to 1 */ 1211 /* set RX trigger level to 1 */
1259 xuartps_writel(1, XUARTPS_RXWM_OFFSET); 1212 cdns_uart_writel(1, CDNS_UART_RXWM_OFFSET);
1260 /* disable RX timeout interrups */ 1213 /* disable RX timeout interrups */
1261 xuartps_writel(XUARTPS_IXR_TOUT, XUARTPS_IDR_OFFSET); 1214 cdns_uart_writel(CDNS_UART_IXR_TOUT, CDNS_UART_IDR_OFFSET);
1262 spin_unlock_irqrestore(&port->lock, flags); 1215 spin_unlock_irqrestore(&port->lock, flags);
1263 } 1216 }
1264 1217
@@ -1266,12 +1219,12 @@ static int xuartps_suspend(struct device *device)
1266} 1219}
1267 1220
1268/** 1221/**
1269 * xuartps_resume - Resume after a previous suspend 1222 * cdns_uart_resume - Resume after a previous suspend
1270 * @device: Pointer to the device structure 1223 * @device: Pointer to the device structure
1271 * 1224 *
1272 * Returns 0 1225 * Return: 0
1273 */ 1226 */
1274static int xuartps_resume(struct device *device) 1227static int cdns_uart_resume(struct device *device)
1275{ 1228{
1276 struct uart_port *port = dev_get_drvdata(device); 1229 struct uart_port *port = dev_get_drvdata(device);
1277 unsigned long flags = 0; 1230 unsigned long flags = 0;
@@ -1289,87 +1242,95 @@ static int xuartps_resume(struct device *device)
1289 } 1242 }
1290 1243
1291 if (console_suspend_enabled && !may_wake) { 1244 if (console_suspend_enabled && !may_wake) {
1292 struct xuartps *xuartps = port->private_data; 1245 struct cdns_uart *cdns_uart = port->private_data;
1293 1246
1294 clk_enable(xuartps->aperclk); 1247 clk_enable(cdns_uart->pclk);
1295 clk_enable(xuartps->refclk); 1248 clk_enable(cdns_uart->uartclk);
1296 1249
1297 spin_lock_irqsave(&port->lock, flags); 1250 spin_lock_irqsave(&port->lock, flags);
1298 1251
1299 /* Set TX/RX Reset */ 1252 /* Set TX/RX Reset */
1300 xuartps_writel(xuartps_readl(XUARTPS_CR_OFFSET) | 1253 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
1301 (XUARTPS_CR_TXRST | XUARTPS_CR_RXRST), 1254 ctrl_reg |= CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST;
1302 XUARTPS_CR_OFFSET); 1255 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
1303 while (xuartps_readl(XUARTPS_CR_OFFSET) & 1256 while (cdns_uart_readl(CDNS_UART_CR_OFFSET) &
1304 (XUARTPS_CR_TXRST | XUARTPS_CR_RXRST)) 1257 (CDNS_UART_CR_TXRST | CDNS_UART_CR_RXRST))
1305 cpu_relax(); 1258 cpu_relax();
1306 1259
1307 /* restore rx timeout value */ 1260 /* restore rx timeout value */
1308 xuartps_writel(rx_timeout, XUARTPS_RXTOUT_OFFSET); 1261 cdns_uart_writel(rx_timeout, CDNS_UART_RXTOUT_OFFSET);
1309 /* Enable Tx/Rx */ 1262 /* Enable Tx/Rx */
1310 ctrl_reg = xuartps_readl(XUARTPS_CR_OFFSET); 1263 ctrl_reg = cdns_uart_readl(CDNS_UART_CR_OFFSET);
1311 xuartps_writel( 1264 ctrl_reg &= ~(CDNS_UART_CR_TX_DIS | CDNS_UART_CR_RX_DIS);
1312 (ctrl_reg & ~(XUARTPS_CR_TX_DIS | XUARTPS_CR_RX_DIS)) | 1265 ctrl_reg |= CDNS_UART_CR_TX_EN | CDNS_UART_CR_RX_EN;
1313 (XUARTPS_CR_TX_EN | XUARTPS_CR_RX_EN), 1266 cdns_uart_writel(ctrl_reg, CDNS_UART_CR_OFFSET);
1314 XUARTPS_CR_OFFSET);
1315 1267
1316 spin_unlock_irqrestore(&port->lock, flags); 1268 spin_unlock_irqrestore(&port->lock, flags);
1317 } else { 1269 } else {
1318 spin_lock_irqsave(&port->lock, flags); 1270 spin_lock_irqsave(&port->lock, flags);
1319 /* restore original rx trigger level */ 1271 /* restore original rx trigger level */
1320 xuartps_writel(rx_trigger_level, XUARTPS_RXWM_OFFSET); 1272 cdns_uart_writel(rx_trigger_level, CDNS_UART_RXWM_OFFSET);
1321 /* enable RX timeout interrupt */ 1273 /* enable RX timeout interrupt */
1322 xuartps_writel(XUARTPS_IXR_TOUT, XUARTPS_IER_OFFSET); 1274 cdns_uart_writel(CDNS_UART_IXR_TOUT, CDNS_UART_IER_OFFSET);
1323 spin_unlock_irqrestore(&port->lock, flags); 1275 spin_unlock_irqrestore(&port->lock, flags);
1324 } 1276 }
1325 1277
1326 return uart_resume_port(&xuartps_uart_driver, port); 1278 return uart_resume_port(&cdns_uart_uart_driver, port);
1327} 1279}
1328#endif /* ! CONFIG_PM_SLEEP */ 1280#endif /* ! CONFIG_PM_SLEEP */
1329 1281
1330static SIMPLE_DEV_PM_OPS(xuartps_dev_pm_ops, xuartps_suspend, xuartps_resume); 1282static SIMPLE_DEV_PM_OPS(cdns_uart_dev_pm_ops, cdns_uart_suspend,
1283 cdns_uart_resume);
1331 1284
1332/* ---------------------------------------------------------------------
1333 * Platform bus binding
1334 */
1335/** 1285/**
1336 * xuartps_probe - Platform driver probe 1286 * cdns_uart_probe - Platform driver probe
1337 * @pdev: Pointer to the platform device structure 1287 * @pdev: Pointer to the platform device structure
1338 * 1288 *
1339 * Returns 0 on success, negative error otherwise 1289 * Return: 0 on success, negative errno otherwise
1340 **/ 1290 */
1341static int xuartps_probe(struct platform_device *pdev) 1291static int cdns_uart_probe(struct platform_device *pdev)
1342{ 1292{
1343 int rc; 1293 int rc, id;
1344 struct uart_port *port; 1294 struct uart_port *port;
1345 struct resource *res, *res2; 1295 struct resource *res, *res2;
1346 struct xuartps *xuartps_data; 1296 struct cdns_uart *cdns_uart_data;
1347 1297
1348 xuartps_data = devm_kzalloc(&pdev->dev, sizeof(*xuartps_data), 1298 cdns_uart_data = devm_kzalloc(&pdev->dev, sizeof(*cdns_uart_data),
1349 GFP_KERNEL); 1299 GFP_KERNEL);
1350 if (!xuartps_data) 1300 if (!cdns_uart_data)
1351 return -ENOMEM; 1301 return -ENOMEM;
1352 1302
1353 xuartps_data->aperclk = devm_clk_get(&pdev->dev, "aper_clk"); 1303 cdns_uart_data->pclk = devm_clk_get(&pdev->dev, "pclk");
1354 if (IS_ERR(xuartps_data->aperclk)) { 1304 if (IS_ERR(cdns_uart_data->pclk)) {
1355 dev_err(&pdev->dev, "aper_clk clock not found.\n"); 1305 cdns_uart_data->pclk = devm_clk_get(&pdev->dev, "aper_clk");
1356 return PTR_ERR(xuartps_data->aperclk); 1306 if (!IS_ERR(cdns_uart_data->pclk))
1307 dev_err(&pdev->dev, "clock name 'aper_clk' is deprecated.\n");
1357 } 1308 }
1358 xuartps_data->refclk = devm_clk_get(&pdev->dev, "ref_clk"); 1309 if (IS_ERR(cdns_uart_data->pclk)) {
1359 if (IS_ERR(xuartps_data->refclk)) { 1310 dev_err(&pdev->dev, "pclk clock not found.\n");
1360 dev_err(&pdev->dev, "ref_clk clock not found.\n"); 1311 return PTR_ERR(cdns_uart_data->pclk);
1361 return PTR_ERR(xuartps_data->refclk);
1362 } 1312 }
1363 1313
1364 rc = clk_prepare_enable(xuartps_data->aperclk); 1314 cdns_uart_data->uartclk = devm_clk_get(&pdev->dev, "uart_clk");
1315 if (IS_ERR(cdns_uart_data->uartclk)) {
1316 cdns_uart_data->uartclk = devm_clk_get(&pdev->dev, "ref_clk");
1317 if (!IS_ERR(cdns_uart_data->uartclk))
1318 dev_err(&pdev->dev, "clock name 'ref_clk' is deprecated.\n");
1319 }
1320 if (IS_ERR(cdns_uart_data->uartclk)) {
1321 dev_err(&pdev->dev, "uart_clk clock not found.\n");
1322 return PTR_ERR(cdns_uart_data->uartclk);
1323 }
1324
1325 rc = clk_prepare_enable(cdns_uart_data->pclk);
1365 if (rc) { 1326 if (rc) {
1366 dev_err(&pdev->dev, "Unable to enable APER clock.\n"); 1327 dev_err(&pdev->dev, "Unable to enable pclk clock.\n");
1367 return rc; 1328 return rc;
1368 } 1329 }
1369 rc = clk_prepare_enable(xuartps_data->refclk); 1330 rc = clk_prepare_enable(cdns_uart_data->uartclk);
1370 if (rc) { 1331 if (rc) {
1371 dev_err(&pdev->dev, "Unable to enable device clock.\n"); 1332 dev_err(&pdev->dev, "Unable to enable device clock.\n");
1372 goto err_out_clk_dis_aper; 1333 goto err_out_clk_dis_pclk;
1373 } 1334 }
1374 1335
1375 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1336 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1385,15 +1346,19 @@ static int xuartps_probe(struct platform_device *pdev)
1385 } 1346 }
1386 1347
1387#ifdef CONFIG_COMMON_CLK 1348#ifdef CONFIG_COMMON_CLK
1388 xuartps_data->clk_rate_change_nb.notifier_call = 1349 cdns_uart_data->clk_rate_change_nb.notifier_call =
1389 xuartps_clk_notifier_cb; 1350 cdns_uart_clk_notifier_cb;
1390 if (clk_notifier_register(xuartps_data->refclk, 1351 if (clk_notifier_register(cdns_uart_data->uartclk,
1391 &xuartps_data->clk_rate_change_nb)) 1352 &cdns_uart_data->clk_rate_change_nb))
1392 dev_warn(&pdev->dev, "Unable to register clock notifier.\n"); 1353 dev_warn(&pdev->dev, "Unable to register clock notifier.\n");
1393#endif 1354#endif
1355 /* Look for a serialN alias */
1356 id = of_alias_get_id(pdev->dev.of_node, "serial");
1357 if (id < 0)
1358 id = 0;
1394 1359
1395 /* Initialize the port structure */ 1360 /* Initialize the port structure */
1396 port = xuartps_get_port(); 1361 port = cdns_uart_get_port(id);
1397 1362
1398 if (!port) { 1363 if (!port) {
1399 dev_err(&pdev->dev, "Cannot get uart_port structure\n"); 1364 dev_err(&pdev->dev, "Cannot get uart_port structure\n");
@@ -1407,11 +1372,11 @@ static int xuartps_probe(struct platform_device *pdev)
1407 port->mapbase = res->start; 1372 port->mapbase = res->start;
1408 port->irq = res2->start; 1373 port->irq = res2->start;
1409 port->dev = &pdev->dev; 1374 port->dev = &pdev->dev;
1410 port->uartclk = clk_get_rate(xuartps_data->refclk); 1375 port->uartclk = clk_get_rate(cdns_uart_data->uartclk);
1411 port->private_data = xuartps_data; 1376 port->private_data = cdns_uart_data;
1412 xuartps_data->port = port; 1377 cdns_uart_data->port = port;
1413 platform_set_drvdata(pdev, port); 1378 platform_set_drvdata(pdev, port);
1414 rc = uart_add_one_port(&xuartps_uart_driver, port); 1379 rc = uart_add_one_port(&cdns_uart_uart_driver, port);
1415 if (rc) { 1380 if (rc) {
1416 dev_err(&pdev->dev, 1381 dev_err(&pdev->dev,
1417 "uart_add_one_port() failed; err=%i\n", rc); 1382 "uart_add_one_port() failed; err=%i\n", rc);
@@ -1422,103 +1387,89 @@ static int xuartps_probe(struct platform_device *pdev)
1422 1387
1423err_out_notif_unreg: 1388err_out_notif_unreg:
1424#ifdef CONFIG_COMMON_CLK 1389#ifdef CONFIG_COMMON_CLK
1425 clk_notifier_unregister(xuartps_data->refclk, 1390 clk_notifier_unregister(cdns_uart_data->uartclk,
1426 &xuartps_data->clk_rate_change_nb); 1391 &cdns_uart_data->clk_rate_change_nb);
1427#endif 1392#endif
1428err_out_clk_disable: 1393err_out_clk_disable:
1429 clk_disable_unprepare(xuartps_data->refclk); 1394 clk_disable_unprepare(cdns_uart_data->uartclk);
1430err_out_clk_dis_aper: 1395err_out_clk_dis_pclk:
1431 clk_disable_unprepare(xuartps_data->aperclk); 1396 clk_disable_unprepare(cdns_uart_data->pclk);
1432 1397
1433 return rc; 1398 return rc;
1434} 1399}
1435 1400
1436/** 1401/**
1437 * xuartps_remove - called when the platform driver is unregistered 1402 * cdns_uart_remove - called when the platform driver is unregistered
1438 * @pdev: Pointer to the platform device structure 1403 * @pdev: Pointer to the platform device structure
1439 * 1404 *
1440 * Returns 0 on success, negative error otherwise 1405 * Return: 0 on success, negative errno otherwise
1441 **/ 1406 */
1442static int xuartps_remove(struct platform_device *pdev) 1407static int cdns_uart_remove(struct platform_device *pdev)
1443{ 1408{
1444 struct uart_port *port = platform_get_drvdata(pdev); 1409 struct uart_port *port = platform_get_drvdata(pdev);
1445 struct xuartps *xuartps_data = port->private_data; 1410 struct cdns_uart *cdns_uart_data = port->private_data;
1446 int rc; 1411 int rc;
1447 1412
1448 /* Remove the xuartps port from the serial core */ 1413 /* Remove the cdns_uart port from the serial core */
1449#ifdef CONFIG_COMMON_CLK 1414#ifdef CONFIG_COMMON_CLK
1450 clk_notifier_unregister(xuartps_data->refclk, 1415 clk_notifier_unregister(cdns_uart_data->uartclk,
1451 &xuartps_data->clk_rate_change_nb); 1416 &cdns_uart_data->clk_rate_change_nb);
1452#endif 1417#endif
1453 rc = uart_remove_one_port(&xuartps_uart_driver, port); 1418 rc = uart_remove_one_port(&cdns_uart_uart_driver, port);
1454 port->mapbase = 0; 1419 port->mapbase = 0;
1455 clk_disable_unprepare(xuartps_data->refclk); 1420 clk_disable_unprepare(cdns_uart_data->uartclk);
1456 clk_disable_unprepare(xuartps_data->aperclk); 1421 clk_disable_unprepare(cdns_uart_data->pclk);
1457 return rc; 1422 return rc;
1458} 1423}
1459 1424
1460/* Match table for of_platform binding */ 1425/* Match table for of_platform binding */
1461static struct of_device_id xuartps_of_match[] = { 1426static struct of_device_id cdns_uart_of_match[] = {
1462 { .compatible = "xlnx,xuartps", }, 1427 { .compatible = "xlnx,xuartps", },
1428 { .compatible = "cdns,uart-r1p8", },
1463 {} 1429 {}
1464}; 1430};
1465MODULE_DEVICE_TABLE(of, xuartps_of_match); 1431MODULE_DEVICE_TABLE(of, cdns_uart_of_match);
1466 1432
1467static struct platform_driver xuartps_platform_driver = { 1433static struct platform_driver cdns_uart_platform_driver = {
1468 .probe = xuartps_probe, /* Probe method */ 1434 .probe = cdns_uart_probe,
1469 .remove = xuartps_remove, /* Detach method */ 1435 .remove = cdns_uart_remove,
1470 .driver = { 1436 .driver = {
1471 .owner = THIS_MODULE, 1437 .owner = THIS_MODULE,
1472 .name = XUARTPS_NAME, /* Driver name */ 1438 .name = CDNS_UART_NAME,
1473 .of_match_table = xuartps_of_match, 1439 .of_match_table = cdns_uart_of_match,
1474 .pm = &xuartps_dev_pm_ops, 1440 .pm = &cdns_uart_dev_pm_ops,
1475 }, 1441 },
1476}; 1442};
1477 1443
1478/* --------------------------------------------------------------------- 1444static int __init cdns_uart_init(void)
1479 * Module Init and Exit
1480 */
1481/**
1482 * xuartps_init - Initial driver registration call
1483 *
1484 * Returns whether the registration was successful or not
1485 **/
1486static int __init xuartps_init(void)
1487{ 1445{
1488 int retval = 0; 1446 int retval = 0;
1489 1447
1490 /* Register the xuartps driver with the serial core */ 1448 /* Register the cdns_uart driver with the serial core */
1491 retval = uart_register_driver(&xuartps_uart_driver); 1449 retval = uart_register_driver(&cdns_uart_uart_driver);
1492 if (retval) 1450 if (retval)
1493 return retval; 1451 return retval;
1494 1452
1495 /* Register the platform driver */ 1453 /* Register the platform driver */
1496 retval = platform_driver_register(&xuartps_platform_driver); 1454 retval = platform_driver_register(&cdns_uart_platform_driver);
1497 if (retval) 1455 if (retval)
1498 uart_unregister_driver(&xuartps_uart_driver); 1456 uart_unregister_driver(&cdns_uart_uart_driver);
1499 1457
1500 return retval; 1458 return retval;
1501} 1459}
1502 1460
1503/** 1461static void __exit cdns_uart_exit(void)
1504 * xuartps_exit - Driver unregistration call
1505 **/
1506static void __exit xuartps_exit(void)
1507{ 1462{
1508 /* The order of unregistration is important. Unregister the
1509 * UART driver before the platform driver crashes the system.
1510 */
1511
1512 /* Unregister the platform driver */ 1463 /* Unregister the platform driver */
1513 platform_driver_unregister(&xuartps_platform_driver); 1464 platform_driver_unregister(&cdns_uart_platform_driver);
1514 1465
1515 /* Unregister the xuartps driver */ 1466 /* Unregister the cdns_uart driver */
1516 uart_unregister_driver(&xuartps_uart_driver); 1467 uart_unregister_driver(&cdns_uart_uart_driver);
1517} 1468}
1518 1469
1519module_init(xuartps_init); 1470module_init(cdns_uart_init);
1520module_exit(xuartps_exit); 1471module_exit(cdns_uart_exit);
1521 1472
1522MODULE_DESCRIPTION("Driver for PS UART"); 1473MODULE_DESCRIPTION("Driver for Cadence UART");
1523MODULE_AUTHOR("Xilinx Inc."); 1474MODULE_AUTHOR("Xilinx Inc.");
1524MODULE_LICENSE("GPL"); 1475MODULE_LICENSE("GPL");
diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c
index ce396ecdf412..454b65898e2c 100644
--- a/drivers/tty/sysrq.c
+++ b/drivers/tty/sysrq.c
@@ -46,6 +46,7 @@
46#include <linux/jiffies.h> 46#include <linux/jiffies.h>
47#include <linux/syscalls.h> 47#include <linux/syscalls.h>
48#include <linux/of.h> 48#include <linux/of.h>
49#include <linux/rcupdate.h>
49 50
50#include <asm/ptrace.h> 51#include <asm/ptrace.h>
51#include <asm/irq_regs.h> 52#include <asm/irq_regs.h>
@@ -88,7 +89,7 @@ static void sysrq_handle_loglevel(int key)
88 int i; 89 int i;
89 90
90 i = key - '0'; 91 i = key - '0';
91 console_loglevel = 7; 92 console_loglevel = CONSOLE_LOGLEVEL_DEFAULT;
92 printk("Loglevel set to %d\n", i); 93 printk("Loglevel set to %d\n", i);
93 console_loglevel = i; 94 console_loglevel = i;
94} 95}
@@ -343,7 +344,7 @@ static void send_sig_all(int sig)
343static void sysrq_handle_term(int key) 344static void sysrq_handle_term(int key)
344{ 345{
345 send_sig_all(SIGTERM); 346 send_sig_all(SIGTERM);
346 console_loglevel = 8; 347 console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
347} 348}
348static struct sysrq_key_op sysrq_term_op = { 349static struct sysrq_key_op sysrq_term_op = {
349 .handler = sysrq_handle_term, 350 .handler = sysrq_handle_term,
@@ -387,7 +388,7 @@ static struct sysrq_key_op sysrq_thaw_op = {
387static void sysrq_handle_kill(int key) 388static void sysrq_handle_kill(int key)
388{ 389{
389 send_sig_all(SIGKILL); 390 send_sig_all(SIGKILL);
390 console_loglevel = 8; 391 console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
391} 392}
392static struct sysrq_key_op sysrq_kill_op = { 393static struct sysrq_key_op sysrq_kill_op = {
393 .handler = sysrq_handle_kill, 394 .handler = sysrq_handle_kill,
@@ -510,9 +511,9 @@ void __handle_sysrq(int key, bool check_mask)
510 struct sysrq_key_op *op_p; 511 struct sysrq_key_op *op_p;
511 int orig_log_level; 512 int orig_log_level;
512 int i; 513 int i;
513 unsigned long flags;
514 514
515 spin_lock_irqsave(&sysrq_key_table_lock, flags); 515 rcu_sysrq_start();
516 rcu_read_lock();
516 /* 517 /*
517 * Raise the apparent loglevel to maximum so that the sysrq header 518 * Raise the apparent loglevel to maximum so that the sysrq header
518 * is shown to provide the user with positive feedback. We do not 519 * is shown to provide the user with positive feedback. We do not
@@ -520,7 +521,7 @@ void __handle_sysrq(int key, bool check_mask)
520 * routing in the consumers of /proc/kmsg. 521 * routing in the consumers of /proc/kmsg.
521 */ 522 */
522 orig_log_level = console_loglevel; 523 orig_log_level = console_loglevel;
523 console_loglevel = 7; 524 console_loglevel = CONSOLE_LOGLEVEL_DEFAULT;
524 printk(KERN_INFO "SysRq : "); 525 printk(KERN_INFO "SysRq : ");
525 526
526 op_p = __sysrq_get_key_op(key); 527 op_p = __sysrq_get_key_op(key);
@@ -554,7 +555,8 @@ void __handle_sysrq(int key, bool check_mask)
554 printk("\n"); 555 printk("\n");
555 console_loglevel = orig_log_level; 556 console_loglevel = orig_log_level;
556 } 557 }
557 spin_unlock_irqrestore(&sysrq_key_table_lock, flags); 558 rcu_read_unlock();
559 rcu_sysrq_end();
558} 560}
559 561
560void handle_sysrq(int key) 562void handle_sysrq(int key)
@@ -1043,16 +1045,23 @@ static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
1043 struct sysrq_key_op *remove_op_p) 1045 struct sysrq_key_op *remove_op_p)
1044{ 1046{
1045 int retval; 1047 int retval;
1046 unsigned long flags;
1047 1048
1048 spin_lock_irqsave(&sysrq_key_table_lock, flags); 1049 spin_lock(&sysrq_key_table_lock);
1049 if (__sysrq_get_key_op(key) == remove_op_p) { 1050 if (__sysrq_get_key_op(key) == remove_op_p) {
1050 __sysrq_put_key_op(key, insert_op_p); 1051 __sysrq_put_key_op(key, insert_op_p);
1051 retval = 0; 1052 retval = 0;
1052 } else { 1053 } else {
1053 retval = -1; 1054 retval = -1;
1054 } 1055 }
1055 spin_unlock_irqrestore(&sysrq_key_table_lock, flags); 1056 spin_unlock(&sysrq_key_table_lock);
1057
1058 /*
1059 * A concurrent __handle_sysrq either got the old op or the new op.
1060 * Wait for it to go away before returning, so the code for an old
1061 * op is not freed (eg. on module unload) while it is in use.
1062 */
1063 synchronize_rcu();
1064
1056 return retval; 1065 return retval;
1057} 1066}
1058 1067
diff --git a/drivers/tty/vt/consolemap.c b/drivers/tty/vt/consolemap.c
index 2978ca596a7f..610b720d3b91 100644
--- a/drivers/tty/vt/consolemap.c
+++ b/drivers/tty/vt/consolemap.c
@@ -179,7 +179,6 @@ struct uni_pagedir {
179 unsigned long sum; 179 unsigned long sum;
180 unsigned char *inverse_translations[4]; 180 unsigned char *inverse_translations[4];
181 u16 *inverse_trans_unicode; 181 u16 *inverse_trans_unicode;
182 int readonly;
183}; 182};
184 183
185static struct uni_pagedir *dflt; 184static struct uni_pagedir *dflt;
@@ -262,7 +261,7 @@ u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode)
262 int m; 261 int m;
263 if (glyph < 0 || glyph >= MAX_GLYPH) 262 if (glyph < 0 || glyph >= MAX_GLYPH)
264 return 0; 263 return 0;
265 else if (!(p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc)) 264 else if (!(p = *conp->vc_uni_pagedir_loc))
266 return glyph; 265 return glyph;
267 else if (use_unicode) { 266 else if (use_unicode) {
268 if (!p->inverse_trans_unicode) 267 if (!p->inverse_trans_unicode)
@@ -287,7 +286,7 @@ static void update_user_maps(void)
287 for (i = 0; i < MAX_NR_CONSOLES; i++) { 286 for (i = 0; i < MAX_NR_CONSOLES; i++) {
288 if (!vc_cons_allocated(i)) 287 if (!vc_cons_allocated(i))
289 continue; 288 continue;
290 p = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc; 289 p = *vc_cons[i].d->vc_uni_pagedir_loc;
291 if (p && p != q) { 290 if (p && p != q) {
292 set_inverse_transl(vc_cons[i].d, p, USER_MAP); 291 set_inverse_transl(vc_cons[i].d, p, USER_MAP);
293 set_inverse_trans_unicode(vc_cons[i].d, p); 292 set_inverse_trans_unicode(vc_cons[i].d, p);
@@ -418,10 +417,10 @@ void con_free_unimap(struct vc_data *vc)
418{ 417{
419 struct uni_pagedir *p; 418 struct uni_pagedir *p;
420 419
421 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 420 p = *vc->vc_uni_pagedir_loc;
422 if (!p) 421 if (!p)
423 return; 422 return;
424 *vc->vc_uni_pagedir_loc = 0; 423 *vc->vc_uni_pagedir_loc = NULL;
425 if (--p->refcount) 424 if (--p->refcount)
426 return; 425 return;
427 con_release_unimap(p); 426 con_release_unimap(p);
@@ -436,7 +435,7 @@ static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
436 for (i = 0; i < MAX_NR_CONSOLES; i++) { 435 for (i = 0; i < MAX_NR_CONSOLES; i++) {
437 if (!vc_cons_allocated(i)) 436 if (!vc_cons_allocated(i))
438 continue; 437 continue;
439 q = (struct uni_pagedir *)*vc_cons[i].d->vc_uni_pagedir_loc; 438 q = *vc_cons[i].d->vc_uni_pagedir_loc;
440 if (!q || q == p || q->sum != p->sum) 439 if (!q || q == p || q->sum != p->sum)
441 continue; 440 continue;
442 for (j = 0; j < 32; j++) { 441 for (j = 0; j < 32; j++) {
@@ -459,7 +458,7 @@ static int con_unify_unimap(struct vc_data *conp, struct uni_pagedir *p)
459 } 458 }
460 if (j == 32) { 459 if (j == 32) {
461 q->refcount++; 460 q->refcount++;
462 *conp->vc_uni_pagedir_loc = (unsigned long)q; 461 *conp->vc_uni_pagedir_loc = q;
463 con_release_unimap(p); 462 con_release_unimap(p);
464 kfree(p); 463 kfree(p);
465 return 1; 464 return 1;
@@ -500,10 +499,7 @@ static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
500{ 499{
501 struct uni_pagedir *p, *q; 500 struct uni_pagedir *p, *q;
502 501
503 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 502 p = *vc->vc_uni_pagedir_loc;
504 if (p && p->readonly)
505 return -EIO;
506
507 if (!p || --p->refcount) { 503 if (!p || --p->refcount) {
508 q = kzalloc(sizeof(*p), GFP_KERNEL); 504 q = kzalloc(sizeof(*p), GFP_KERNEL);
509 if (!q) { 505 if (!q) {
@@ -512,7 +508,7 @@ static int con_do_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
512 return -ENOMEM; 508 return -ENOMEM;
513 } 509 }
514 q->refcount=1; 510 q->refcount=1;
515 *vc->vc_uni_pagedir_loc = (unsigned long)q; 511 *vc->vc_uni_pagedir_loc = q;
516 } else { 512 } else {
517 if (p == dflt) dflt = NULL; 513 if (p == dflt) dflt = NULL;
518 p->refcount++; 514 p->refcount++;
@@ -536,19 +532,13 @@ int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
536 int err = 0, err1, i; 532 int err = 0, err1, i;
537 struct uni_pagedir *p, *q; 533 struct uni_pagedir *p, *q;
538 534
535 if (!ct)
536 return 0;
537
539 console_lock(); 538 console_lock();
540 539
541 /* Save original vc_unipagdir_loc in case we allocate a new one */ 540 /* Save original vc_unipagdir_loc in case we allocate a new one */
542 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 541 p = *vc->vc_uni_pagedir_loc;
543 if (p->readonly) {
544 console_unlock();
545 return -EIO;
546 }
547
548 if (!ct) {
549 console_unlock();
550 return 0;
551 }
552 542
553 if (p->refcount > 1) { 543 if (p->refcount > 1) {
554 int j, k; 544 int j, k;
@@ -564,7 +554,7 @@ int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
564 * Since refcount was > 1, con_clear_unimap() allocated a 554 * Since refcount was > 1, con_clear_unimap() allocated a
565 * a new uni_pagedir for this vc. Re: p != q 555 * a new uni_pagedir for this vc. Re: p != q
566 */ 556 */
567 q = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 557 q = *vc->vc_uni_pagedir_loc;
568 558
569 /* 559 /*
570 * uni_pgdir is a 32*32*64 table with rows allocated 560 * uni_pgdir is a 32*32*64 table with rows allocated
@@ -586,7 +576,7 @@ int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
586 err1 = con_insert_unipair(q, l, p2[k]); 576 err1 = con_insert_unipair(q, l, p2[k]);
587 if (err1) { 577 if (err1) {
588 p->refcount++; 578 p->refcount++;
589 *vc->vc_uni_pagedir_loc = (unsigned long)p; 579 *vc->vc_uni_pagedir_loc = p;
590 con_release_unimap(q); 580 con_release_unimap(q);
591 kfree(q); 581 kfree(q);
592 console_unlock(); 582 console_unlock();
@@ -655,12 +645,12 @@ int con_set_default_unimap(struct vc_data *vc)
655 struct uni_pagedir *p; 645 struct uni_pagedir *p;
656 646
657 if (dflt) { 647 if (dflt) {
658 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 648 p = *vc->vc_uni_pagedir_loc;
659 if (p == dflt) 649 if (p == dflt)
660 return 0; 650 return 0;
661 651
662 dflt->refcount++; 652 dflt->refcount++;
663 *vc->vc_uni_pagedir_loc = (unsigned long)dflt; 653 *vc->vc_uni_pagedir_loc = dflt;
664 if (p && !--p->refcount) { 654 if (p && !--p->refcount) {
665 con_release_unimap(p); 655 con_release_unimap(p);
666 kfree(p); 656 kfree(p);
@@ -674,7 +664,7 @@ int con_set_default_unimap(struct vc_data *vc)
674 if (err) 664 if (err)
675 return err; 665 return err;
676 666
677 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 667 p = *vc->vc_uni_pagedir_loc;
678 q = dfont_unitable; 668 q = dfont_unitable;
679 669
680 for (i = 0; i < 256; i++) 670 for (i = 0; i < 256; i++)
@@ -685,7 +675,7 @@ int con_set_default_unimap(struct vc_data *vc)
685 } 675 }
686 676
687 if (con_unify_unimap(vc, p)) { 677 if (con_unify_unimap(vc, p)) {
688 dflt = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 678 dflt = *vc->vc_uni_pagedir_loc;
689 return err; 679 return err;
690 } 680 }
691 681
@@ -713,9 +703,9 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
713 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc) 703 if (*dst_vc->vc_uni_pagedir_loc == *src_vc->vc_uni_pagedir_loc)
714 return 0; 704 return 0;
715 con_free_unimap(dst_vc); 705 con_free_unimap(dst_vc);
716 q = (struct uni_pagedir *)*src_vc->vc_uni_pagedir_loc; 706 q = *src_vc->vc_uni_pagedir_loc;
717 q->refcount++; 707 q->refcount++;
718 *dst_vc->vc_uni_pagedir_loc = (long)q; 708 *dst_vc->vc_uni_pagedir_loc = q;
719 return 0; 709 return 0;
720} 710}
721EXPORT_SYMBOL(con_copy_unimap); 711EXPORT_SYMBOL(con_copy_unimap);
@@ -737,7 +727,7 @@ int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct uni
737 727
738 ect = 0; 728 ect = 0;
739 if (*vc->vc_uni_pagedir_loc) { 729 if (*vc->vc_uni_pagedir_loc) {
740 p = (struct uni_pagedir *)*vc->vc_uni_pagedir_loc; 730 p = *vc->vc_uni_pagedir_loc;
741 for (i = 0; i < 32; i++) 731 for (i = 0; i < 32; i++)
742 if ((p1 = p->uni_pgdir[i])) 732 if ((p1 = p->uni_pgdir[i]))
743 for (j = 0; j < 32; j++) 733 for (j = 0; j < 32; j++)
@@ -810,7 +800,7 @@ conv_uni_to_pc(struct vc_data *conp, long ucs)
810 if (!*conp->vc_uni_pagedir_loc) 800 if (!*conp->vc_uni_pagedir_loc)
811 return -3; 801 return -3;
812 802
813 p = (struct uni_pagedir *)*conp->vc_uni_pagedir_loc; 803 p = *conp->vc_uni_pagedir_loc;
814 if ((p1 = p->uni_pgdir[ucs >> 11]) && 804 if ((p1 = p->uni_pgdir[ucs >> 11]) &&
815 (p2 = p1[(ucs >> 6) & 0x1f]) && 805 (p2 = p1[(ucs >> 6) & 0x1f]) &&
816 (h = p2[ucs & 0x3f]) < MAX_GLYPH) 806 (h = p2[ucs & 0x3f]) < MAX_GLYPH)
diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index 3ad0b61e35b4..5e0f6ff2e2f5 100644
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -735,7 +735,7 @@ static void visual_init(struct vc_data *vc, int num, int init)
735 vc->vc_num = num; 735 vc->vc_num = num;
736 vc->vc_display_fg = &master_display_fg; 736 vc->vc_display_fg = &master_display_fg;
737 vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir; 737 vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
738 vc->vc_uni_pagedir = 0; 738 vc->vc_uni_pagedir = NULL;
739 vc->vc_hi_font_mask = 0; 739 vc->vc_hi_font_mask = 0;
740 vc->vc_complement_mask = 0; 740 vc->vc_complement_mask = 0;
741 vc->vc_can_do_color = 0; 741 vc->vc_can_do_color = 0;
@@ -1231,6 +1231,52 @@ static void default_attr(struct vc_data *vc)
1231 vc->vc_color = vc->vc_def_color; 1231 vc->vc_color = vc->vc_def_color;
1232} 1232}
1233 1233
1234struct rgb { u8 r; u8 g; u8 b; };
1235
1236struct rgb rgb_from_256(int i)
1237{
1238 struct rgb c;
1239 if (i < 8) { /* Standard colours. */
1240 c.r = i&1 ? 0xaa : 0x00;
1241 c.g = i&2 ? 0xaa : 0x00;
1242 c.b = i&4 ? 0xaa : 0x00;
1243 } else if (i < 16) {
1244 c.r = i&1 ? 0xff : 0x55;
1245 c.g = i&2 ? 0xff : 0x55;
1246 c.b = i&4 ? 0xff : 0x55;
1247 } else if (i < 232) { /* 6x6x6 colour cube. */
1248 c.r = (i - 16) / 36 * 85 / 2;
1249 c.g = (i - 16) / 6 % 6 * 85 / 2;
1250 c.b = (i - 16) % 6 * 85 / 2;
1251 } else /* Grayscale ramp. */
1252 c.r = c.g = c.b = i * 10 - 2312;
1253 return c;
1254}
1255
1256static void rgb_foreground(struct vc_data *vc, struct rgb c)
1257{
1258 u8 hue, max = c.r;
1259 if (c.g > max)
1260 max = c.g;
1261 if (c.b > max)
1262 max = c.b;
1263 hue = (c.r > max/2 ? 4 : 0)
1264 | (c.g > max/2 ? 2 : 0)
1265 | (c.b > max/2 ? 1 : 0);
1266 if (hue == 7 && max <= 0x55)
1267 hue = 0, vc->vc_intensity = 2;
1268 else
1269 vc->vc_intensity = (max > 0xaa) + 1;
1270 vc->vc_color = (vc->vc_color & 0xf0) | hue;
1271}
1272
1273static void rgb_background(struct vc_data *vc, struct rgb c)
1274{
1275 /* For backgrounds, err on the dark side. */
1276 vc->vc_color = (vc->vc_color & 0x0f)
1277 | (c.r&0x80) >> 1 | (c.g&0x80) >> 2 | (c.b&0x80) >> 3;
1278}
1279
1234/* console_lock is held */ 1280/* console_lock is held */
1235static void csi_m(struct vc_data *vc) 1281static void csi_m(struct vc_data *vc)
1236{ 1282{
@@ -1302,8 +1348,7 @@ static void csi_m(struct vc_data *vc)
1302 case 27: 1348 case 27:
1303 vc->vc_reverse = 0; 1349 vc->vc_reverse = 0;
1304 break; 1350 break;
1305 case 38: 1351 case 38: /* ITU T.416
1306 case 48: /* ITU T.416
1307 * Higher colour modes. 1352 * Higher colour modes.
1308 * They break the usual properties of SGR codes 1353 * They break the usual properties of SGR codes
1309 * and thus need to be detected and ignored by 1354 * and thus need to be detected and ignored by
@@ -1315,15 +1360,41 @@ static void csi_m(struct vc_data *vc)
1315 i++; 1360 i++;
1316 if (i > vc->vc_npar) 1361 if (i > vc->vc_npar)
1317 break; 1362 break;
1318 if (vc->vc_par[i] == 5) /* 256 colours */ 1363 if (vc->vc_par[i] == 5 && /* 256 colours */
1319 i++; /* ubiquitous */ 1364 i < vc->vc_npar) { /* ubiquitous */
1320 else if (vc->vc_par[i] == 2) /* 24 bit colours */ 1365 i++;
1321 i += 3; /* extremely rare */ 1366 rgb_foreground(vc,
1367 rgb_from_256(vc->vc_par[i]));
1368 } else if (vc->vc_par[i] == 2 && /* 24 bit */
1369 i <= vc->vc_npar + 3) {/* extremely rare */
1370 struct rgb c = {r:vc->vc_par[i+1],
1371 g:vc->vc_par[i+2],
1372 b:vc->vc_par[i+3]};
1373 rgb_foreground(vc, c);
1374 i += 3;
1375 }
1322 /* Subcommands 3 (CMY) and 4 (CMYK) are so insane 1376 /* Subcommands 3 (CMY) and 4 (CMYK) are so insane
1323 * that detecting them is not worth the few extra 1377 * there's no point in supporting them.
1324 * bytes of kernel's size.
1325 */ 1378 */
1326 break; 1379 break;
1380 case 48:
1381 i++;
1382 if (i > vc->vc_npar)
1383 break;
1384 if (vc->vc_par[i] == 5 && /* 256 colours */
1385 i < vc->vc_npar) {
1386 i++;
1387 rgb_background(vc,
1388 rgb_from_256(vc->vc_par[i]));
1389 } else if (vc->vc_par[i] == 2 && /* 24 bit */
1390 i <= vc->vc_npar + 3) {
1391 struct rgb c = {r:vc->vc_par[i+1],
1392 g:vc->vc_par[i+2],
1393 b:vc->vc_par[i+3]};
1394 rgb_background(vc, c);
1395 i += 3;
1396 }
1397 break;
1327 case 39: 1398 case 39:
1328 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0); 1399 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
1329 break; 1400 break;
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-11 08:19:20 -0500