--- /dev/null
+From 4ff5a10b94c0c41088c8bbfa5be1ebab3822371b Mon Sep 17 00:00:00 2001
+From: =?utf-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@google.com>
+Date: Fri, 29 Jun 2007 21:41:20 -0700
+Subject: [PATCH 122/134] [ARM] goldfish: tty: Adding tty driver for goldfish.
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: Mike A. Chan <mikechan@google.com>
+Signed-off-by: Arve Hjønnevåg <arve@android.com>
+---
+ drivers/char/Kconfig | 6 +
+ drivers/char/Makefile | 1 +
+ drivers/char/goldfish_tty.c | 323 +++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 330 insertions(+), 0 deletions(-)
+ create mode 100644 drivers/char/goldfish_tty.c
+
+--- a/drivers/char/Kconfig
++++ b/drivers/char/Kconfig
+@@ -1106,6 +1106,12 @@ config DEVPORT
+ depends on ISA || PCI
+ default y
+
++config GOLDFISH_TTY
++ tristate "Goldfish TTY Driver"
++ default n
++ help
++ TTY driver for Goldfish Virtual Platform.
++
+ source "drivers/s390/char/Kconfig"
+
+ endmenu
+--- a/drivers/char/Makefile
++++ b/drivers/char/Makefile
+@@ -98,6 +98,7 @@ obj-$(CONFIG_GPIO_DEVICE) += gpio_dev.o
+ obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
+ obj-$(CONFIG_GPIO_TB0219) += tb0219.o
+ obj-$(CONFIG_TELCLOCK) += tlclk.o
++obj-$(CONFIG_GOLDFISH_TTY) += goldfish_tty.o
+
+ obj-$(CONFIG_MWAVE) += mwave/
+ obj-$(CONFIG_AGP) += agp/
+--- /dev/null
++++ b/drivers/char/goldfish_tty.c
+@@ -0,0 +1,323 @@
++/* drivers/char/goldfish_tty.c
++**
++** Copyright (C) 2007 Google, 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 <mach/hardware.h>
++#include <asm/io.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 {
++ spinlock_t lock;
++ uint32_t base;
++ uint32_t irq;
++ int opencount;
++ struct tty_struct *tty;
++ struct console console;
++};
++
++static DEFINE_MUTEX(goldfish_tty_lock);
++static struct tty_driver *goldfish_tty_driver;
++static uint32_t goldfish_tty_line_count = 8;
++static uint32_t 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];
++ uint32_t base = qtty->base;
++ spin_lock_irqsave(&qtty->lock, irq_flags);
++ writel(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];
++ uint32_t base = qtty->base;
++ unsigned long irq_flags;
++ unsigned char *buf;
++ uint32_t count;
++
++ count = readl(base + GOLDFISH_TTY_BYTES_READY);
++ if(count == 0) {
++ return IRQ_NONE;
++ }
++ count = tty_prepare_flip_string(qtty->tty, &buf, count);
++ spin_lock_irqsave(&qtty->lock, irq_flags);
++ writel(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(qtty->tty);
++ return IRQ_HANDLED;
++}
++
++static int goldfish_tty_open(struct tty_struct * tty, struct file * filp)
++{
++ int ret;
++ struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
++
++ mutex_lock(&goldfish_tty_lock);
++ if(qtty->tty == NULL || qtty->tty == tty) {
++ if(qtty->opencount++ == 0) {
++ qtty->tty = tty;
++ writel(GOLDFISH_TTY_CMD_INT_ENABLE, qtty->base + GOLDFISH_TTY_CMD);
++ }
++ ret = 0;
++ }
++ else
++ ret = -EBUSY;
++ mutex_unlock(&goldfish_tty_lock);
++ return ret;
++}
++
++static void goldfish_tty_close(struct tty_struct * tty, struct file * filp)
++{
++ struct goldfish_tty *qtty = &goldfish_ttys[tty->index];
++
++ mutex_lock(&goldfish_tty_lock);
++ if(qtty->tty == tty) {
++ if(--qtty->opencount == 0) {
++ writel(GOLDFISH_TTY_CMD_INT_DISABLE, qtty->base + GOLDFISH_TTY_CMD);
++ qtty->tty = NULL;
++ }
++ }
++ mutex_unlock(&goldfish_tty_lock);
++}
++
++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];
++ uint32_t 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_operations goldfish_tty_ops = {
++ .open = goldfish_tty_open,
++ .close = goldfish_tty_close,
++ .write = goldfish_tty_write,
++ .write_room = goldfish_tty_write_room,
++ .chars_in_buffer = goldfish_tty_chars_in_buffer,
++};
++
++static int __devinit 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 = "ttyS";
++ 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 __devinit goldfish_tty_probe(struct platform_device *pdev)
++{
++ int ret;
++ int i;
++ struct resource *r;
++ struct device *ttydev;
++ uint32_t base;
++ uint32_t irq;
++
++ r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++ if(r == NULL)
++ return -EINVAL;
++ base = IO_ADDRESS(r->start - IO_START);
++ r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
++ if(r == NULL)
++ return -EINVAL;
++ irq = r->start;
++
++ if(pdev->id >= goldfish_tty_line_count)
++ return -EINVAL;
++
++ 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++;
++
++ spin_lock_init(&goldfish_ttys[pdev->id].lock);
++ goldfish_ttys[pdev->id].base = base;
++ goldfish_ttys[pdev->id].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_register_device(goldfish_tty_driver, pdev->id, NULL);
++ if(IS_ERR(ttydev)) {
++ ret = PTR_ERR(ttydev);
++ goto err_tty_register_device_failed;
++ }
++
++ strcpy(goldfish_ttys[pdev->id].console.name, "ttyS");
++ goldfish_ttys[pdev->id].console.write = goldfish_tty_console_write;
++ goldfish_ttys[pdev->id].console.device = goldfish_tty_console_device;
++ goldfish_ttys[pdev->id].console.setup = goldfish_tty_console_setup;
++ goldfish_ttys[pdev->id].console.flags = CON_PRINTBUFFER;
++ goldfish_ttys[pdev->id].console.index = pdev->id;
++ register_console(&goldfish_ttys[pdev->id].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);
++ return ret;
++}
++
++static int __devexit goldfish_tty_remove(struct platform_device *pdev)
++{
++ mutex_lock(&goldfish_tty_lock);
++ unregister_console(&goldfish_ttys[pdev->id].console);
++ tty_unregister_device(goldfish_tty_driver, pdev->id);
++ goldfish_ttys[pdev->id].base = 0;
++ free_irq(goldfish_ttys[pdev->id].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 = __devexit_p(goldfish_tty_remove),
++ .driver = {
++ .name = "goldfish_tty"
++ }
++};
++
++static int __init goldfish_tty_init(void)
++{
++ return platform_driver_register(&goldfish_tty_platform_driver);
++}
++
++static void __exit goldfish_tty_exit(void)
++{
++ platform_driver_unregister(&goldfish_tty_platform_driver);
++}
++
++module_init(goldfish_tty_init);
++module_exit(goldfish_tty_exit);
projects / openwrt / svn-archive / archive.git / blobdiff