goldfish: tty driver

This provides a console driver for the Goldfish virtual platform. The original
is from Arve with changes from Jun Nakajima and Tom Keel. This has been then
been ported to the current kernel and to the tty port mechanism by Alan Cox.
In the process it gained proper POSIX semantics and vhangup works. The default
name is not ttyS as this belongs to the 8250 driver. Instead ttyGFx is now used.

In the normal usage case the first port serves as a kernel logging console and
the second one carries various other data streams for the emulation.

Signed-off-by: Arve Hjønnevåg <arve@google.com>
[Cleaned up to handle x86]
Signed-off-by: Sheng Yang <sheng@linux.intel.com>
Signed-off-by: Yunhong Jiang <yunhong.jiang@intel.com>
Signed-off-by: Xiaohui Xin <xiaohui.xin@intel.com>
Signed-off-by: Jun Nakajima <jun.nakajima@intel.com>
Signed-off-by: Bruce Beare <bruce.j.beare@intel.com>
[Moved to 3.7 and chunks rewritten to use tty_port layer]
Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 333 insertions, 0 deletions

diff --git a/drivers/tty/goldfish.c b/drivers/tty/goldfish.c
new file mode 100644
index 000000000000..e2ccb6daa6c5
--- /dev/null
+++ b/drivers/tty/goldfish.c
@@ -0,0 +1,333 @@
+/*
+ * Copyright (C) 2007 Google, Inc.
+ * Copyright (C) 2012 Intel, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/console.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/module.h>
+
+enum {
+        GOLDFISH_TTY_PUT_CHAR       = 0x00,
+        GOLDFISH_TTY_BYTES_READY    = 0x04,
+        GOLDFISH_TTY_CMD            = 0x08,
+
+        GOLDFISH_TTY_DATA_PTR       = 0x10,
+        GOLDFISH_TTY_DATA_LEN       = 0x14,
+
+        GOLDFISH_TTY_CMD_INT_DISABLE    = 0,
+        GOLDFISH_TTY_CMD_INT_ENABLE     = 1,
+        GOLDFISH_TTY_CMD_WRITE_BUFFER   = 2,
+        GOLDFISH_TTY_CMD_READ_BUFFER    = 3,
+};
+
+struct goldfish_tty {
+        struct tty_port port;
+        spinlock_t lock;
+        void __iomem *base;
+        u32 irq;
+        int opencount;
+        struct console console;
+};
+
+static DEFINE_MUTEX(goldfish_tty_lock);
+static struct tty_driver *goldfish_tty_driver;
+static u32 goldfish_tty_line_count = 8;
+static u32 goldfish_tty_current_line_count;
+static struct goldfish_tty *goldfish_ttys;
+
+static void goldfish_tty_do_write(int line, const char *buf, unsigned count)
+{
+        unsigned long irq_flags;
+        struct goldfish_tty *qtty = &goldfish_ttys[line];
+        void __iomem *base = qtty->base;
+        spin_lock_irqsave(&qtty->lock, irq_flags);
+        writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR);
+        writel(count, base + GOLDFISH_TTY_DATA_LEN);
+        writel(GOLDFISH_TTY_CMD_WRITE_BUFFER, base + GOLDFISH_TTY_CMD);
+        spin_unlock_irqrestore(&qtty->lock, irq_flags);
+}
+
+static irqreturn_t goldfish_tty_interrupt(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct goldfish_tty *qtty = &goldfish_ttys[pdev->id];
+        void __iomem *base = qtty->base;
+        unsigned long irq_flags;
+        unsigned char *buf;
+        u32 count;
+        struct tty_struct *tty;
+
+        count = readl(base + GOLDFISH_TTY_BYTES_READY);
+        if(count == 0)
+                return IRQ_NONE;
+
+        tty = tty_port_tty_get(&qtty->port);
+        if (tty) {
+                count = tty_prepare_flip_string(tty, &buf, count);
+                spin_lock_irqsave(&qtty->lock, irq_flags);
+                writel((u32)buf, base + GOLDFISH_TTY_DATA_PTR);
+                writel(count, base + GOLDFISH_TTY_DATA_LEN);
+                writel(GOLDFISH_TTY_CMD_READ_BUFFER, base + GOLDFISH_TTY_CMD);
+                spin_unlock_irqrestore(&qtty->lock, irq_flags);
+                tty_schedule_flip(tty);
+                tty_kref_put(tty);
+        }
+        return IRQ_HANDLED;
+}
+
+static int goldfish_tty_activate(struct tty_port *port, struct tty_struct *tty)
+{
+        struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port);
+        writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_CMD);
+        return 0;
+}
+
+static void goldfish_tty_shutdown(struct tty_port *port)
+{
+        struct goldfish_tty *qtty = container_of(port, struct goldfish_tty, port);
+        writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_CMD);
+}
+
+static int goldfish_tty_open(struct tty_struct * tty, struct file * filp)
+{
+        struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
+        return tty_port_open(&qtty->port, tty, filp);
+}
+
+static void goldfish_tty_close(struct tty_struct * tty, struct file * filp)
+{
+        tty_port_close(tty->port, tty, filp);
+}
+
+static void goldfish_tty_hangup(struct tty_struct *tty)
+{
+        tty_port_hangup(tty->port);
+}
+
+static int goldfish_tty_write(struct tty_struct * tty, const unsigned char *buf, int count)
+{
+        goldfish_tty_do_write(tty->index, buf, count);
+        return count;
+}
+
+static int goldfish_tty_write_room(struct tty_struct *tty)
+{
+        return 0x10000;
+}
+
+static int goldfish_tty_chars_in_buffer(struct tty_struct *tty)
+{
+        struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
+        void __iomem *base = qtty->base;
+        return readl(base + GOLDFISH_TTY_BYTES_READY);
+}
+
+static void goldfish_tty_console_write(struct console *co, const char *b, unsigned count)
+{
+        goldfish_tty_do_write(co->index, b, count);
+}
+
+static struct tty_driver *goldfish_tty_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return goldfish_tty_driver;
+}
+
+static int goldfish_tty_console_setup(struct console *co, char *options)
+{
+        if((unsigned)co->index > goldfish_tty_line_count)
+                return -ENODEV;
+        if(goldfish_ttys[co->index].base == 0)
+                return -ENODEV;
+        return 0;
+}
+
+static struct tty_port_operations goldfish_port_ops = {
+        .activate = goldfish_tty_activate,
+        .shutdown = goldfish_tty_shutdown
+};
+
+static struct tty_operations goldfish_tty_ops = {
+        .open = goldfish_tty_open,
+        .close = goldfish_tty_close,
+        .hangup = goldfish_tty_hangup,
+        .write = goldfish_tty_write,
+        .write_room = goldfish_tty_write_room,
+        .chars_in_buffer = goldfish_tty_chars_in_buffer,
+};
+
+static int goldfish_tty_create_driver(void)
+{
+        int ret;
+        struct tty_driver *tty;
+
+        goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) * goldfish_tty_line_count, GFP_KERNEL);
+        if(goldfish_ttys == NULL) {
+                ret = -ENOMEM;
+                goto err_alloc_goldfish_ttys_failed;
+        }
+        tty = alloc_tty_driver(goldfish_tty_line_count);
+        if(tty == NULL) {
+                ret = -ENOMEM;
+                goto err_alloc_tty_driver_failed;
+        }
+        tty->driver_name = "goldfish";
+        tty->name = "ttyGF";
+        tty->type = TTY_DRIVER_TYPE_SERIAL;
+        tty->subtype = SERIAL_TYPE_NORMAL;
+        tty->init_termios = tty_std_termios;
+        tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        tty_set_operations(tty, &goldfish_tty_ops);
+        ret = tty_register_driver(tty);
+        if(ret)
+                goto err_tty_register_driver_failed;
+
+        goldfish_tty_driver = tty;
+        return 0;
+
+err_tty_register_driver_failed:
+        put_tty_driver(tty);
+err_alloc_tty_driver_failed:
+        kfree(goldfish_ttys);
+        goldfish_ttys = NULL;
+err_alloc_goldfish_ttys_failed:
+        return ret;
+}
+
+static void goldfish_tty_delete_driver(void)
+{
+        tty_unregister_driver(goldfish_tty_driver);
+        put_tty_driver(goldfish_tty_driver);
+        goldfish_tty_driver = NULL;
+        kfree(goldfish_ttys);
+        goldfish_ttys = NULL;
+}
+
+static int goldfish_tty_probe(struct platform_device *pdev)
+{
+        struct goldfish_tty *qtty;
+        int ret = -EINVAL;
+        int i;
+        struct resource *r;
+        struct device *ttydev;
+        void __iomem *base;
+        u32 irq;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if(r == NULL)
+                return -EINVAL;
+
+        base = ioremap(r->start, 0x1000);
+        if (base == NULL)
+                pr_err("goldfish_tty: unable to remap base\n");
+
+        r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if(r == NULL)
+                goto err_unmap;
+
+        irq = r->start;
+
+        if(pdev->id >= goldfish_tty_line_count)
+                goto err_unmap;
+
+        mutex_lock(&goldfish_tty_lock);
+        if(goldfish_tty_current_line_count == 0) {
+                ret = goldfish_tty_create_driver();
+                if(ret)
+                        goto err_create_driver_failed;
+        }
+        goldfish_tty_current_line_count++;
+
+        qtty = &goldfish_ttys[pdev->id];
+        spin_lock_init(&qtty->lock);
+        tty_port_init(&qtty->port);
+        qtty->port.ops = &goldfish_port_ops;
+        qtty->base = base;
+        qtty->irq = irq;
+
+        writel(GOLDFISH_TTY_CMD_INT_DISABLE, base + GOLDFISH_TTY_CMD);
+
+        ret = request_irq(irq, goldfish_tty_interrupt, IRQF_SHARED, "goldfish_tty", pdev);
+        if(ret)
+                goto err_request_irq_failed;
+
+
+        ttydev = tty_port_register_device(&qtty->port, goldfish_tty_driver,
+                                                        pdev->id, &pdev->dev);
+        if(IS_ERR(ttydev)) {
+                ret = PTR_ERR(ttydev);
+                goto err_tty_register_device_failed;
+        }
+
+        strcpy(qtty->console.name, "ttyGF");
+        qtty->console.write = goldfish_tty_console_write;
+        qtty->console.device = goldfish_tty_console_device;
+        qtty->console.setup = goldfish_tty_console_setup;
+        qtty->console.flags = CON_PRINTBUFFER;
+        qtty->console.index = pdev->id;
+        register_console(&qtty->console);
+
+        mutex_unlock(&goldfish_tty_lock);
+        return 0;
+
+        tty_unregister_device(goldfish_tty_driver, i);
+err_tty_register_device_failed:
+        free_irq(irq, pdev);
+err_request_irq_failed:
+        goldfish_tty_current_line_count--;
+        if(goldfish_tty_current_line_count == 0)
+                goldfish_tty_delete_driver();
+err_create_driver_failed:
+        mutex_unlock(&goldfish_tty_lock);
+err_unmap:
+        iounmap(base);
+        return ret;
+}
+
+static int goldfish_tty_remove(struct platform_device *pdev)
+{
+        struct goldfish_tty *qtty;
+
+        mutex_lock(&goldfish_tty_lock);
+
+        qtty = &goldfish_ttys[pdev->id];
+        unregister_console(&qtty->console);
+        tty_unregister_device(goldfish_tty_driver, pdev->id);
+        iounmap(qtty->base);
+        qtty->base = 0;
+        free_irq(qtty->irq, pdev);
+        goldfish_tty_current_line_count--;
+        if(goldfish_tty_current_line_count == 0)
+                goldfish_tty_delete_driver();
+        mutex_unlock(&goldfish_tty_lock);
+        return 0;
+}
+
+static struct platform_driver goldfish_tty_platform_driver = {
+        .probe = goldfish_tty_probe,
+        .remove = goldfish_tty_remove,
+        .driver = {
+                .name = "goldfish_tty"
+        }
+};
+
+module_platform_driver(goldfish_tty_platform_driver);
+
+MODULE_LICENSE("GPL v2");