evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert "armv6 dcc tty driver"

Browse source 
This reverts commit 97312429c2.

Drop AOSP's "armv6 dcc tty driver" in favor of upstream DCC driver for
ARMv6/v7 16c63f8ea4 (drivers: char: hvc: add arm JTAG DCC console
support) and for ARMv8 4cad4c57e0 (ARM64: TTY: hvc_dcc: Add support
for ARM64 dcc).

Change-Id: I0ca651ef2d854fff03cee070524fe1e3971b6d8f
Signed-off-by: Amit Pundir <amit.pundir@linaro.org>
This commit is contained in:
Amit Pundir 2016-05-26 12:58:21 +05:30
parent e4d3d42ae0
commit 6c27fa13e8
3 changed files with 0 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/char/Kconfig
View file

@ -588,10 +588,6 @@ config DEVPORT
depends on ISA || PCI
default y
config DCC_TTY
tristate "DCC tty driver"
depends on ARM
source "drivers/s390/char/Kconfig"
config TILE_SROM

1
drivers/char/Makefile
View file

@ -53,7 +53,6 @@ obj-$(CONFIG_PCMCIA) += pcmcia/
obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o
obj-$(CONFIG_TCG_TPM) += tpm/
obj-$(CONFIG_DCC_TTY) += dcc_tty.o
obj-$(CONFIG_PS3_FLASH) += ps3flash.o
obj-$(CONFIG_JS_RTC) += js-rtc.o

326
drivers/char/dcc_tty.c
View file

@ -1,326 +0,0 @@
/* drivers/char/dcc_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/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/console.h>
#include <linux/hrtimer.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
MODULE_DESCRIPTION("DCC TTY Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");
static spinlock_t g_dcc_tty_lock = SPIN_LOCK_UNLOCKED;
static struct hrtimer g_dcc_timer;
static char g_dcc_buffer[16];
static int g_dcc_buffer_head;
static int g_dcc_buffer_count;
static unsigned g_dcc_write_delay_usecs = 1;
static struct tty_driver *g_dcc_tty_driver;
static struct tty_struct *g_dcc_tty;
static int g_dcc_tty_open_count;
static void dcc_poll_locked(void)
{
char ch;
int rch;
int written;
while (g_dcc_buffer_count) {
ch = g_dcc_buffer[g_dcc_buffer_head];
asm(
"mrc 14, 0, r15, c0, c1, 0\n"
"mcrcc 14, 0, %1, c0, c5, 0\n"
"movcc %0, #1\n"
"movcs %0, #0\n"
: "=r" (written)
: "r" (ch)
);
if (written) {
if (ch == '\n')
g_dcc_buffer[g_dcc_buffer_head] = '\r';
else {
g_dcc_buffer_head = (g_dcc_buffer_head + 1) % ARRAY_SIZE(g_dcc_buffer);
g_dcc_buffer_count--;
if (g_dcc_tty)
tty_wakeup(g_dcc_tty);
}
g_dcc_write_delay_usecs = 1;
} else {
if (g_dcc_write_delay_usecs > 0x100)
break;
g_dcc_write_delay_usecs <<= 1;
udelay(g_dcc_write_delay_usecs);
}
}
if (g_dcc_tty && !test_bit(TTY_THROTTLED, &g_dcc_tty->flags)) {
asm(
"mrc 14, 0, %0, c0, c1, 0\n"
"tst %0, #(1 << 30)\n"
"moveq %0, #-1\n"
"mrcne 14, 0, %0, c0, c5, 0\n"
: "=r" (rch)
);
if (rch >= 0) {
ch = rch;
tty_insert_flip_string(g_dcc_tty, &ch, 1);
tty_flip_buffer_push(g_dcc_tty);
}
}
if (g_dcc_buffer_count)
hrtimer_start(&g_dcc_timer, ktime_set(0, g_dcc_write_delay_usecs * NSEC_PER_USEC), HRTIMER_MODE_REL);
else
hrtimer_start(&g_dcc_timer, ktime_set(0, 20 * NSEC_PER_MSEC), HRTIMER_MODE_REL);
}
static int dcc_tty_open(struct tty_struct * tty, struct file * filp)
{
int ret;
unsigned long irq_flags;
spin_lock_irqsave(&g_dcc_tty_lock, irq_flags);
if (g_dcc_tty == NULL || g_dcc_tty == tty) {
g_dcc_tty = tty;
g_dcc_tty_open_count++;
ret = 0;
} else
ret = -EBUSY;
spin_unlock_irqrestore(&g_dcc_tty_lock, irq_flags);
printk("dcc_tty_open, tty %p, f_flags %x, returned %d\n", tty, filp->f_flags, ret);
return ret;
}
static void dcc_tty_close(struct tty_struct * tty, struct file * filp)
{
printk("dcc_tty_close, tty %p, f_flags %x\n", tty, filp->f_flags);
if (g_dcc_tty == tty) {
if (--g_dcc_tty_open_count == 0)
g_dcc_tty = NULL;
}
}
static int dcc_write(const unsigned char *buf_start, int count)
{
const unsigned char *buf = buf_start;
unsigned long irq_flags;
int copy_len;
int space_left;
int tail;
if (count < 1)
return 0;
spin_lock_irqsave(&g_dcc_tty_lock, irq_flags);
do {
tail = (g_dcc_buffer_head + g_dcc_buffer_count) % ARRAY_SIZE(g_dcc_buffer);
copy_len = ARRAY_SIZE(g_dcc_buffer) - tail;
space_left = ARRAY_SIZE(g_dcc_buffer) - g_dcc_buffer_count;
if (copy_len > space_left)
copy_len = space_left;
if (copy_len > count)
copy_len = count;
memcpy(&g_dcc_buffer[tail], buf, copy_len);
g_dcc_buffer_count += copy_len;
buf += copy_len;
count -= copy_len;
if (copy_len < count && copy_len < space_left) {
space_left -= copy_len;
copy_len = count;
if (copy_len > space_left) {
copy_len = space_left;
}
memcpy(g_dcc_buffer, buf, copy_len);
buf += copy_len;
count -= copy_len;
g_dcc_buffer_count += copy_len;
}
dcc_poll_locked();
space_left = ARRAY_SIZE(g_dcc_buffer) - g_dcc_buffer_count;
} while(count && space_left);
spin_unlock_irqrestore(&g_dcc_tty_lock, irq_flags);
return buf - buf_start;
}
static int dcc_tty_write(struct tty_struct * tty, const unsigned char *buf, int count)
{
int ret;
/* printk("dcc_tty_write %p, %d\n", buf, count); */
ret = dcc_write(buf, count);
if (ret != count)
printk("dcc_tty_write %p, %d, returned %d\n", buf, count, ret);
return ret;
}
static int dcc_tty_write_room(struct tty_struct *tty)
{
int space_left;
unsigned long irq_flags;
spin_lock_irqsave(&g_dcc_tty_lock, irq_flags);
space_left = ARRAY_SIZE(g_dcc_buffer) - g_dcc_buffer_count;
spin_unlock_irqrestore(&g_dcc_tty_lock, irq_flags);
return space_left;
}
static int dcc_tty_chars_in_buffer(struct tty_struct *tty)
{
int ret;
asm(
"mrc 14, 0, %0, c0, c1, 0\n"
"mov %0, %0, LSR #30\n"
"and %0, %0, #1\n"
: "=r" (ret)
);
return ret;
}
static void dcc_tty_unthrottle(struct tty_struct * tty)
{
unsigned long irq_flags;
spin_lock_irqsave(&g_dcc_tty_lock, irq_flags);
dcc_poll_locked();
spin_unlock_irqrestore(&g_dcc_tty_lock, irq_flags);
}
static enum hrtimer_restart dcc_tty_timer_func(struct hrtimer *timer)
{
unsigned long irq_flags;
spin_lock_irqsave(&g_dcc_tty_lock, irq_flags);
dcc_poll_locked();
spin_unlock_irqrestore(&g_dcc_tty_lock, irq_flags);
return HRTIMER_NORESTART;
}
void dcc_console_write(struct console *co, const char *b, unsigned count)
{
#if 1
dcc_write(b, count);
#else
/* blocking printk */
while (count > 0) {
int written;
written = dcc_write(b, count);
if (written) {
b += written;
count -= written;
}
}
#endif
}
static struct tty_driver *dcc_console_device(struct console *c, int *index)
{
*index = 0;
return g_dcc_tty_driver;
}
static int __init dcc_console_setup(struct console *co, char *options)
{
if (co->index != 0)
return -ENODEV;
return 0;
}
static struct console dcc_console =
{
.name = "ttyDCC",
.write = dcc_console_write,
.device = dcc_console_device,
.setup = dcc_console_setup,
.flags = CON_PRINTBUFFER,
.index = -1,
};
static struct tty_operations dcc_tty_ops = {
.open = dcc_tty_open,
.close = dcc_tty_close,
.write = dcc_tty_write,
.write_room = dcc_tty_write_room,
.chars_in_buffer = dcc_tty_chars_in_buffer,
.unthrottle = dcc_tty_unthrottle,
};
static int __init dcc_tty_init(void)
{
int ret;
hrtimer_init(&g_dcc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
g_dcc_timer.function = dcc_tty_timer_func;
g_dcc_tty_driver = alloc_tty_driver(1);
if (!g_dcc_tty_driver) {
printk(KERN_ERR "dcc_tty_probe: alloc_tty_driver failed\n");
ret = -ENOMEM;
goto err_alloc_tty_driver_failed;
}
g_dcc_tty_driver->owner = THIS_MODULE;
g_dcc_tty_driver->driver_name = "dcc";
g_dcc_tty_driver->name = "ttyDCC";
g_dcc_tty_driver->major = 0; // auto assign
g_dcc_tty_driver->minor_start = 0;
g_dcc_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
g_dcc_tty_driver->subtype = SERIAL_TYPE_NORMAL;
g_dcc_tty_driver->init_termios = tty_std_termios;
g_dcc_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
tty_set_operations(g_dcc_tty_driver, &dcc_tty_ops);
ret = tty_register_driver(g_dcc_tty_driver);
if (ret) {
printk(KERN_ERR "dcc_tty_probe: tty_register_driver failed, %d\n", ret);
goto err_tty_register_driver_failed;
}
tty_register_device(g_dcc_tty_driver, 0, NULL);
register_console(&dcc_console);
hrtimer_start(&g_dcc_timer, ktime_set(0, 0), HRTIMER_MODE_REL);
return 0;
err_tty_register_driver_failed:
put_tty_driver(g_dcc_tty_driver);
g_dcc_tty_driver = NULL;
err_alloc_tty_driver_failed:
return ret;
}
static void __exit dcc_tty_exit(void)
{
int ret;
tty_unregister_device(g_dcc_tty_driver, 0);
ret = tty_unregister_driver(g_dcc_tty_driver);
if (ret < 0) {
printk(KERN_ERR "dcc_tty_remove: tty_unregister_driver failed, %d\n", ret);
} else {
put_tty_driver(g_dcc_tty_driver);
}
g_dcc_tty_driver = NULL;
}
module_init(dcc_tty_init);
module_exit(dcc_tty_exit);