xref: /linux/drivers/tty/goldfish.c (revision fd639726bf15fca8ee1a00dce8e0096d0ad9bd18) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2007 Google, Inc.
4  * Copyright (C) 2012 Intel, Inc.
5  * Copyright (C) 2017 Imagination Technologies Ltd.
6  */
7 
8 #include <linux/console.h>
9 #include <linux/interrupt.h>
10 #include <linux/platform_device.h>
11 #include <linux/tty.h>
12 #include <linux/tty_flip.h>
13 #include <linux/slab.h>
14 #include <linux/io.h>
15 #include <linux/module.h>
16 #include <linux/goldfish.h>
17 #include <linux/mm.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/serial_core.h>
20 
21 /* Goldfish tty register's offsets */
22 #define	GOLDFISH_TTY_REG_BYTES_READY	0x04
23 #define	GOLDFISH_TTY_REG_CMD		0x08
24 #define	GOLDFISH_TTY_REG_DATA_PTR	0x10
25 #define	GOLDFISH_TTY_REG_DATA_LEN	0x14
26 #define	GOLDFISH_TTY_REG_DATA_PTR_HIGH	0x18
27 #define	GOLDFISH_TTY_REG_VERSION	0x20
28 
29 /* Goldfish tty commands */
30 #define	GOLDFISH_TTY_CMD_INT_DISABLE	0
31 #define	GOLDFISH_TTY_CMD_INT_ENABLE	1
32 #define	GOLDFISH_TTY_CMD_WRITE_BUFFER	2
33 #define	GOLDFISH_TTY_CMD_READ_BUFFER	3
34 
35 struct goldfish_tty {
36 	struct tty_port port;
37 	spinlock_t lock;
38 	void __iomem *base;
39 	u32 irq;
40 	int opencount;
41 	struct console console;
42 	u32 version;
43 	struct device *dev;
44 };
45 
46 static DEFINE_MUTEX(goldfish_tty_lock);
47 static struct tty_driver *goldfish_tty_driver;
48 static u32 goldfish_tty_line_count = 8;
49 static u32 goldfish_tty_current_line_count;
50 static struct goldfish_tty *goldfish_ttys;
51 
52 static void do_rw_io(struct goldfish_tty *qtty,
53 		     unsigned long address,
54 		     unsigned int count,
55 		     int is_write)
56 {
57 	unsigned long irq_flags;
58 	void __iomem *base = qtty->base;
59 
60 	spin_lock_irqsave(&qtty->lock, irq_flags);
61 	gf_write_ptr((void *)address, base + GOLDFISH_TTY_REG_DATA_PTR,
62 		     base + GOLDFISH_TTY_REG_DATA_PTR_HIGH);
63 	writel(count, base + GOLDFISH_TTY_REG_DATA_LEN);
64 
65 	if (is_write)
66 		writel(GOLDFISH_TTY_CMD_WRITE_BUFFER,
67 		       base + GOLDFISH_TTY_REG_CMD);
68 	else
69 		writel(GOLDFISH_TTY_CMD_READ_BUFFER,
70 		       base + GOLDFISH_TTY_REG_CMD);
71 
72 	spin_unlock_irqrestore(&qtty->lock, irq_flags);
73 }
74 
75 static void goldfish_tty_rw(struct goldfish_tty *qtty,
76 			    unsigned long addr,
77 			    unsigned int count,
78 			    int is_write)
79 {
80 	dma_addr_t dma_handle;
81 	enum dma_data_direction dma_dir;
82 
83 	dma_dir = (is_write ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
84 	if (qtty->version > 0) {
85 		/*
86 		 * Goldfish TTY for Ranchu platform uses
87 		 * physical addresses and DMA for read/write operations
88 		 */
89 		unsigned long addr_end = addr + count;
90 
91 		while (addr < addr_end) {
92 			unsigned long pg_end = (addr & PAGE_MASK) + PAGE_SIZE;
93 			unsigned long next =
94 					pg_end < addr_end ? pg_end : addr_end;
95 			unsigned long avail = next - addr;
96 
97 			/*
98 			 * Map the buffer's virtual address to the DMA address
99 			 * so the buffer can be accessed by the device.
100 			 */
101 			dma_handle = dma_map_single(qtty->dev, (void *)addr,
102 						    avail, dma_dir);
103 
104 			if (dma_mapping_error(qtty->dev, dma_handle)) {
105 				dev_err(qtty->dev, "tty: DMA mapping error.\n");
106 				return;
107 			}
108 			do_rw_io(qtty, dma_handle, avail, is_write);
109 
110 			/*
111 			 * Unmap the previously mapped region after
112 			 * the completion of the read/write operation.
113 			 */
114 			dma_unmap_single(qtty->dev, dma_handle, avail, dma_dir);
115 
116 			addr += avail;
117 		}
118 	} else {
119 		/*
120 		 * Old style Goldfish TTY used on the Goldfish platform
121 		 * uses virtual addresses.
122 		 */
123 		do_rw_io(qtty, addr, count, is_write);
124 	}
125 }
126 
127 static void goldfish_tty_do_write(int line, const char *buf,
128 				  unsigned int count)
129 {
130 	struct goldfish_tty *qtty = &goldfish_ttys[line];
131 	unsigned long address = (unsigned long)(void *)buf;
132 
133 	goldfish_tty_rw(qtty, address, count, 1);
134 }
135 
136 static irqreturn_t goldfish_tty_interrupt(int irq, void *dev_id)
137 {
138 	struct goldfish_tty *qtty = dev_id;
139 	void __iomem *base = qtty->base;
140 	unsigned long address;
141 	unsigned char *buf;
142 	u32 count;
143 
144 	count = readl(base + GOLDFISH_TTY_REG_BYTES_READY);
145 	if (count == 0)
146 		return IRQ_NONE;
147 
148 	count = tty_prepare_flip_string(&qtty->port, &buf, count);
149 
150 	address = (unsigned long)(void *)buf;
151 	goldfish_tty_rw(qtty, address, count, 0);
152 
153 	tty_schedule_flip(&qtty->port);
154 	return IRQ_HANDLED;
155 }
156 
157 static int goldfish_tty_activate(struct tty_port *port, struct tty_struct *tty)
158 {
159 	struct goldfish_tty *qtty = container_of(port, struct goldfish_tty,
160 									port);
161 	writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_REG_CMD);
162 	return 0;
163 }
164 
165 static void goldfish_tty_shutdown(struct tty_port *port)
166 {
167 	struct goldfish_tty *qtty = container_of(port, struct goldfish_tty,
168 									port);
169 	writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_REG_CMD);
170 }
171 
172 static int goldfish_tty_open(struct tty_struct *tty, struct file *filp)
173 {
174 	struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
175 	return tty_port_open(&qtty->port, tty, filp);
176 }
177 
178 static void goldfish_tty_close(struct tty_struct *tty, struct file *filp)
179 {
180 	tty_port_close(tty->port, tty, filp);
181 }
182 
183 static void goldfish_tty_hangup(struct tty_struct *tty)
184 {
185 	tty_port_hangup(tty->port);
186 }
187 
188 static int goldfish_tty_write(struct tty_struct *tty, const unsigned char *buf,
189 								int count)
190 {
191 	goldfish_tty_do_write(tty->index, buf, count);
192 	return count;
193 }
194 
195 static int goldfish_tty_write_room(struct tty_struct *tty)
196 {
197 	return 0x10000;
198 }
199 
200 static int goldfish_tty_chars_in_buffer(struct tty_struct *tty)
201 {
202 	struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
203 	void __iomem *base = qtty->base;
204 	return readl(base + GOLDFISH_TTY_REG_BYTES_READY);
205 }
206 
207 static void goldfish_tty_console_write(struct console *co, const char *b,
208 								unsigned count)
209 {
210 	goldfish_tty_do_write(co->index, b, count);
211 }
212 
213 static struct tty_driver *goldfish_tty_console_device(struct console *c,
214 								int *index)
215 {
216 	*index = c->index;
217 	return goldfish_tty_driver;
218 }
219 
220 static int goldfish_tty_console_setup(struct console *co, char *options)
221 {
222 	if ((unsigned)co->index >= goldfish_tty_line_count)
223 		return -ENODEV;
224 	if (!goldfish_ttys[co->index].base)
225 		return -ENODEV;
226 	return 0;
227 }
228 
229 static const struct tty_port_operations goldfish_port_ops = {
230 	.activate = goldfish_tty_activate,
231 	.shutdown = goldfish_tty_shutdown
232 };
233 
234 static const struct tty_operations goldfish_tty_ops = {
235 	.open = goldfish_tty_open,
236 	.close = goldfish_tty_close,
237 	.hangup = goldfish_tty_hangup,
238 	.write = goldfish_tty_write,
239 	.write_room = goldfish_tty_write_room,
240 	.chars_in_buffer = goldfish_tty_chars_in_buffer,
241 };
242 
243 static int goldfish_tty_create_driver(void)
244 {
245 	int ret;
246 	struct tty_driver *tty;
247 
248 	goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) *
249 				goldfish_tty_line_count, GFP_KERNEL);
250 	if (goldfish_ttys == NULL) {
251 		ret = -ENOMEM;
252 		goto err_alloc_goldfish_ttys_failed;
253 	}
254 	tty = alloc_tty_driver(goldfish_tty_line_count);
255 	if (tty == NULL) {
256 		ret = -ENOMEM;
257 		goto err_alloc_tty_driver_failed;
258 	}
259 	tty->driver_name = "goldfish";
260 	tty->name = "ttyGF";
261 	tty->type = TTY_DRIVER_TYPE_SERIAL;
262 	tty->subtype = SERIAL_TYPE_NORMAL;
263 	tty->init_termios = tty_std_termios;
264 	tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
265 						TTY_DRIVER_DYNAMIC_DEV;
266 	tty_set_operations(tty, &goldfish_tty_ops);
267 	ret = tty_register_driver(tty);
268 	if (ret)
269 		goto err_tty_register_driver_failed;
270 
271 	goldfish_tty_driver = tty;
272 	return 0;
273 
274 err_tty_register_driver_failed:
275 	put_tty_driver(tty);
276 err_alloc_tty_driver_failed:
277 	kfree(goldfish_ttys);
278 	goldfish_ttys = NULL;
279 err_alloc_goldfish_ttys_failed:
280 	return ret;
281 }
282 
283 static void goldfish_tty_delete_driver(void)
284 {
285 	tty_unregister_driver(goldfish_tty_driver);
286 	put_tty_driver(goldfish_tty_driver);
287 	goldfish_tty_driver = NULL;
288 	kfree(goldfish_ttys);
289 	goldfish_ttys = NULL;
290 }
291 
292 static int goldfish_tty_probe(struct platform_device *pdev)
293 {
294 	struct goldfish_tty *qtty;
295 	int ret = -ENODEV;
296 	struct resource *r;
297 	struct device *ttydev;
298 	void __iomem *base;
299 	u32 irq;
300 	unsigned int line;
301 
302 	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
303 	if (!r) {
304 		pr_err("goldfish_tty: No MEM resource available!\n");
305 		return -ENOMEM;
306 	}
307 
308 	base = ioremap(r->start, 0x1000);
309 	if (!base) {
310 		pr_err("goldfish_tty: Unable to ioremap base!\n");
311 		return -ENOMEM;
312 	}
313 
314 	r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
315 	if (!r) {
316 		pr_err("goldfish_tty: No IRQ resource available!\n");
317 		goto err_unmap;
318 	}
319 
320 	irq = r->start;
321 
322 	mutex_lock(&goldfish_tty_lock);
323 
324 	if (pdev->id == PLATFORM_DEVID_NONE)
325 		line = goldfish_tty_current_line_count;
326 	else
327 		line = pdev->id;
328 
329 	if (line >= goldfish_tty_line_count) {
330 		pr_err("goldfish_tty: Reached maximum tty number of %d.\n",
331 		       goldfish_tty_current_line_count);
332 		ret = -ENOMEM;
333 		goto err_unlock;
334 	}
335 
336 	if (goldfish_tty_current_line_count == 0) {
337 		ret = goldfish_tty_create_driver();
338 		if (ret)
339 			goto err_unlock;
340 	}
341 	goldfish_tty_current_line_count++;
342 
343 	qtty = &goldfish_ttys[line];
344 	spin_lock_init(&qtty->lock);
345 	tty_port_init(&qtty->port);
346 	qtty->port.ops = &goldfish_port_ops;
347 	qtty->base = base;
348 	qtty->irq = irq;
349 	qtty->dev = &pdev->dev;
350 
351 	/*
352 	 * Goldfish TTY device used by the Goldfish emulator
353 	 * should identify itself with 0, forcing the driver
354 	 * to use virtual addresses. Goldfish TTY device
355 	 * on Ranchu emulator (qemu2) returns 1 here and
356 	 * driver will use physical addresses.
357 	 */
358 	qtty->version = readl(base + GOLDFISH_TTY_REG_VERSION);
359 
360 	/*
361 	 * Goldfish TTY device on Ranchu emulator (qemu2)
362 	 * will use DMA for read/write IO operations.
363 	 */
364 	if (qtty->version > 0) {
365 		/*
366 		 * Initialize dma_mask to 32-bits.
367 		 */
368 		if (!pdev->dev.dma_mask)
369 			pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
370 		ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
371 		if (ret) {
372 			dev_err(&pdev->dev, "No suitable DMA available.\n");
373 			goto err_dec_line_count;
374 		}
375 	}
376 
377 	writel(GOLDFISH_TTY_CMD_INT_DISABLE, base + GOLDFISH_TTY_REG_CMD);
378 
379 	ret = request_irq(irq, goldfish_tty_interrupt, IRQF_SHARED,
380 			  "goldfish_tty", qtty);
381 	if (ret) {
382 		pr_err("goldfish_tty: No IRQ available!\n");
383 		goto err_dec_line_count;
384 	}
385 
386 	ttydev = tty_port_register_device(&qtty->port, goldfish_tty_driver,
387 					  line, &pdev->dev);
388 	if (IS_ERR(ttydev)) {
389 		ret = PTR_ERR(ttydev);
390 		goto err_tty_register_device_failed;
391 	}
392 
393 	strcpy(qtty->console.name, "ttyGF");
394 	qtty->console.write = goldfish_tty_console_write;
395 	qtty->console.device = goldfish_tty_console_device;
396 	qtty->console.setup = goldfish_tty_console_setup;
397 	qtty->console.flags = CON_PRINTBUFFER;
398 	qtty->console.index = line;
399 	register_console(&qtty->console);
400 	platform_set_drvdata(pdev, qtty);
401 
402 	mutex_unlock(&goldfish_tty_lock);
403 	return 0;
404 
405 err_tty_register_device_failed:
406 	free_irq(irq, qtty);
407 err_dec_line_count:
408 	goldfish_tty_current_line_count--;
409 	if (goldfish_tty_current_line_count == 0)
410 		goldfish_tty_delete_driver();
411 err_unlock:
412 	mutex_unlock(&goldfish_tty_lock);
413 err_unmap:
414 	iounmap(base);
415 	return ret;
416 }
417 
418 static int goldfish_tty_remove(struct platform_device *pdev)
419 {
420 	struct goldfish_tty *qtty = platform_get_drvdata(pdev);
421 
422 	mutex_lock(&goldfish_tty_lock);
423 
424 	unregister_console(&qtty->console);
425 	tty_unregister_device(goldfish_tty_driver, qtty->console.index);
426 	iounmap(qtty->base);
427 	qtty->base = NULL;
428 	free_irq(qtty->irq, pdev);
429 	goldfish_tty_current_line_count--;
430 	if (goldfish_tty_current_line_count == 0)
431 		goldfish_tty_delete_driver();
432 	mutex_unlock(&goldfish_tty_lock);
433 	return 0;
434 }
435 
436 static void gf_early_console_putchar(struct uart_port *port, int ch)
437 {
438 	__raw_writel(ch, port->membase);
439 }
440 
441 static void gf_early_write(struct console *con, const char *s, unsigned int n)
442 {
443 	struct earlycon_device *dev = con->data;
444 
445 	uart_console_write(&dev->port, s, n, gf_early_console_putchar);
446 }
447 
448 static int __init gf_earlycon_setup(struct earlycon_device *device,
449 				    const char *opt)
450 {
451 	if (!device->port.membase)
452 		return -ENODEV;
453 
454 	device->con->write = gf_early_write;
455 	return 0;
456 }
457 
458 OF_EARLYCON_DECLARE(early_gf_tty, "google,goldfish-tty", gf_earlycon_setup);
459 
460 static const struct of_device_id goldfish_tty_of_match[] = {
461 	{ .compatible = "google,goldfish-tty", },
462 	{},
463 };
464 
465 MODULE_DEVICE_TABLE(of, goldfish_tty_of_match);
466 
467 static struct platform_driver goldfish_tty_platform_driver = {
468 	.probe = goldfish_tty_probe,
469 	.remove = goldfish_tty_remove,
470 	.driver = {
471 		.name = "goldfish_tty",
472 		.of_match_table = goldfish_tty_of_match,
473 	}
474 };
475 
476 module_platform_driver(goldfish_tty_platform_driver);
477 
478 MODULE_LICENSE("GPL v2");
479