Staging: android: add ram_console driver

	tristate "Android log driver"

	default n

config ANDROID_RAM_CONSOLE

	bool "Android RAM buffer console"

	default n

config ANDROID_RAM_CONSOLE_ENABLE_VERBOSE

	bool "Enable verbose console messages on Android RAM console"

	default y

	depends on ANDROID_RAM_CONSOLE

menuconfig ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	bool "Android RAM Console Enable error correction"

	default n

	depends on ANDROID_RAM_CONSOLE

	select REED_SOLOMON

	select REED_SOLOMON_ENC8

	select REED_SOLOMON_DEC8

if ANDROID_RAM_CONSOLE_ERROR_CORRECTION

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_DATA_SIZE

	int "Android RAM Console Data data size"

	default 128

	help

	  Must be a power of 2.

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_ECC_SIZE

	int "Android RAM Console ECC size"

	default 16

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE

	int "Android RAM Console Symbol size"

	default 8

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_POLYNOMIAL

	hex "Android RAM Console Polynomial"

	default 0x19 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 4)

	default 0x29 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 5)

	default 0x61 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 6)

	default 0x89 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 7)

	default 0x11d if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 8)

endif # ANDROID_RAM_CONSOLE_ERROR_CORRECTION

config ANDROID_RAM_CONSOLE_EARLY_INIT

	bool "Start Android RAM console early"

	default n

	depends on ANDROID_RAM_CONSOLE

config ANDROID_RAM_CONSOLE_EARLY_ADDR

	hex "Android RAM console virtual address"

	default 0

	depends on ANDROID_RAM_CONSOLE_EARLY_INIT

config ANDROID_RAM_CONSOLE_EARLY_SIZE

	hex "Android RAM console buffer size"

	default 0

	depends on ANDROID_RAM_CONSOLE_EARLY_INIT

endmenu

obj-$(CONFIG_ANDROID)			+= android.o

obj-$(CONFIG_ANDROID_BINDER_IPC)	+= binder.o

obj-$(CONFIG_ANDROID_LOGGER)		+= logger.o

obj-$(CONFIG_ANDROID_RAM_CONSOLE)	+= ram_console.o

/* drivers/android/ram_console.c

 *

 * Copyright (C) 2007-2008 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/module.h>

#include <linux/platform_device.h>

#include <linux/proc_fs.h>

#include <linux/string.h>

#include <linux/uaccess.h>

#include <asm/io.h>

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

#include <linux/rslib.h>

#endif

struct ram_console_buffer {

	uint32_t    sig;

	uint32_t    start;

	uint32_t    size;

	uint8_t     data[0];

};

#define RAM_CONSOLE_SIG (0x43474244) /* DBGC */

#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT

static char __initdata

	ram_console_old_log_init_buffer[CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE];

#endif

static char *ram_console_old_log;

static size_t ram_console_old_log_size;

static struct ram_console_buffer *ram_console_buffer;

static size_t ram_console_buffer_size;

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

static char *ram_console_par_buffer;

static struct rs_control *ram_console_rs_decoder;

static int ram_console_corrected_bytes;

static int ram_console_bad_blocks;

#define ECC_BLOCK_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_DATA_SIZE

#define ECC_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_ECC_SIZE

#define ECC_SYMSIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE

#define ECC_POLY CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_POLYNOMIAL

#endif

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

static void ram_console_encode_rs8(uint8_t *data, size_t len, uint8_t *ecc)

{

	int i;

	uint16_t par[ECC_SIZE];

	/* Initialize the parity buffer */

	memset(par, 0, sizeof(par));

	encode_rs8(ram_console_rs_decoder, data, len, par, 0);

	for (i = 0; i < ECC_SIZE; i++)

		ecc[i] = par[i];

}

static int ram_console_decode_rs8(void *data, size_t len, uint8_t *ecc)

{

	int i;

	uint16_t par[ECC_SIZE];

	for (i = 0; i < ECC_SIZE; i++)

		par[i] = ecc[i];

	return decode_rs8(ram_console_rs_decoder, data, par, len,

				NULL, 0, NULL, 0, NULL);

}

#endif

static void ram_console_update(const char *s, unsigned int count)

{

	struct ram_console_buffer *buffer = ram_console_buffer;

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	uint8_t *buffer_end = buffer->data + ram_console_buffer_size;

	uint8_t *block;

	uint8_t *par;

	int size = ECC_BLOCK_SIZE;

#endif

	memcpy(buffer->data + buffer->start, s, count);

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	block = buffer->data + (buffer->start & ~(ECC_BLOCK_SIZE - 1));

	par = ram_console_par_buffer +

	      (buffer->start / ECC_BLOCK_SIZE) * ECC_SIZE;

	do {

		if (block + ECC_BLOCK_SIZE > buffer_end)

			size = buffer_end - block;

		ram_console_encode_rs8(block, size, par);

		block += ECC_BLOCK_SIZE;

		par += ECC_SIZE;

	} while (block < buffer->data + buffer->start + count);

#endif

}

static void ram_console_update_header(void)

{

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	struct ram_console_buffer *buffer = ram_console_buffer;

	uint8_t *par;

	par = ram_console_par_buffer +

	      DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;

	ram_console_encode_rs8((uint8_t *)buffer, sizeof(*buffer), par);

#endif

}

static void

ram_console_write(struct console *console, const char *s, unsigned int count)

{

	int rem;

	struct ram_console_buffer *buffer = ram_console_buffer;

	if (count > ram_console_buffer_size) {

		s += count - ram_console_buffer_size;

		count = ram_console_buffer_size;

	}

	rem = ram_console_buffer_size - buffer->start;

	if (rem < count) {

		ram_console_update(s, rem);

		s += rem;

		count -= rem;

		buffer->start = 0;

		buffer->size = ram_console_buffer_size;

	}

	ram_console_update(s, count);

	buffer->start += count;

	if (buffer->size < ram_console_buffer_size)

		buffer->size += count;

	ram_console_update_header();

}

static struct console ram_console = {

	.name	= "ram",

	.write	= ram_console_write,

	.flags	= CON_PRINTBUFFER | CON_ENABLED,

	.index	= -1,

};

static void __init

ram_console_save_old(struct ram_console_buffer *buffer, char *dest)

{

	size_t old_log_size = buffer->size;

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	uint8_t *block;

	uint8_t *par;

	char strbuf[80];

	int strbuf_len;

	block = buffer->data;

	par = ram_console_par_buffer;

	while (block < buffer->data + buffer->size) {

		int numerr;

		int size = ECC_BLOCK_SIZE;

		if (block + size > buffer->data + ram_console_buffer_size)

			size = buffer->data + ram_console_buffer_size - block;

		numerr = ram_console_decode_rs8(block, size, par);

		if (numerr > 0) {

#if 0

			printk(KERN_INFO "ram_console: error in block %p, %d\n",

			       block, numerr);

#endif

			ram_console_corrected_bytes += numerr;

		} else if (numerr < 0) {

#if 0

			printk(KERN_INFO "ram_console: uncorrectable error in "

			       "block %p\n", block);

#endif

			ram_console_bad_blocks++;

		}

		block += ECC_BLOCK_SIZE;

		par += ECC_SIZE;

	}

	if (ram_console_corrected_bytes || ram_console_bad_blocks)

		strbuf_len = snprintf(strbuf, sizeof(strbuf),

			"\n%d Corrected bytes, %d unrecoverable blocks\n",

			ram_console_corrected_bytes, ram_console_bad_blocks);

	else

		strbuf_len = snprintf(strbuf, sizeof(strbuf),

				      "\nNo errors detected\n");

	if (strbuf_len >= sizeof(strbuf))

		strbuf_len = sizeof(strbuf) - 1;

	old_log_size += strbuf_len;

#endif

	if (dest == NULL) {

		dest = kmalloc(old_log_size, GFP_KERNEL);

		if (dest == NULL) {

			printk(KERN_ERR

			       "ram_console: failed to allocate buffer\n");

			return;

		}

	}

	ram_console_old_log = dest;

	ram_console_old_log_size = old_log_size;

	memcpy(ram_console_old_log,

	       &buffer->data[buffer->start], buffer->size - buffer->start);

	memcpy(ram_console_old_log + buffer->size - buffer->start,

	       &buffer->data[0], buffer->start);

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	memcpy(ram_console_old_log + old_log_size - strbuf_len,

	       strbuf, strbuf_len);

#endif

}

static int __init ram_console_init(struct ram_console_buffer *buffer,

				   size_t buffer_size, char *old_buf)

{

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	int numerr;

	uint8_t *par;

#endif

	ram_console_buffer = buffer;

	ram_console_buffer_size =

		buffer_size - sizeof(struct ram_console_buffer);

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION

	ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,

						ECC_BLOCK_SIZE) + 1) * ECC_SIZE;

	ram_console_par_buffer = buffer->data + ram_console_buffer_size;

	/* first consecutive root is 0

	 * primitive element to generate roots = 1

	 */

	ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);

	if (ram_console_rs_decoder == NULL) {

		printk(KERN_INFO "ram_console: init_rs failed\n");

		return 0;

	}

	ram_console_corrected_bytes = 0;

	ram_console_bad_blocks = 0;

	par = ram_console_par_buffer +

	      DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;

	numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);

	if (numerr > 0) {

		printk(KERN_INFO "ram_console: error in header, %d\n", numerr);

		ram_console_corrected_bytes += numerr;

	} else if (numerr < 0) {

		printk(KERN_INFO

		       "ram_console: uncorrectable error in header\n");

		ram_console_bad_blocks++;

	}

#endif

	if (buffer->sig == RAM_CONSOLE_SIG) {

		if (buffer->size > ram_console_buffer_size

		    || buffer->start > buffer->size)

			printk(KERN_INFO "ram_console: found existing invalid "

			       "buffer, size %d, start %d\n",

			       buffer->size, buffer->start);

		else {

			printk(KERN_INFO "ram_console: found existing buffer, "

			       "size %d, start %d\n",

			       buffer->size, buffer->start);

			ram_console_save_old(buffer, old_buf);

		}

	} else {

		printk(KERN_INFO "ram_console: no valid data in buffer "

		       "(sig = 0x%08x)\n", buffer->sig);

	}

	buffer->sig = RAM_CONSOLE_SIG;

	buffer->start = 0;

	buffer->size = 0;

	register_console(&ram_console);

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE

	console_verbose();

#endif

	return 0;

}

#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT

static int __init ram_console_early_init(void)

{

	return ram_console_init((struct ram_console_buffer *)

		CONFIG_ANDROID_RAM_CONSOLE_EARLY_ADDR,

		CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE,

		ram_console_old_log_init_buffer);

}

#else

static int ram_console_driver_probe(struct platform_device *pdev)

{

	struct resource *res = pdev->resource;

	size_t start;

	size_t buffer_size;

	void *buffer;

	if (res == NULL || pdev->num_resources != 1 ||

	    !(res->flags & IORESOURCE_MEM)) {

		printk(KERN_ERR "ram_console: invalid resource, %p %d flags "

		       "%lx\n", res, pdev->num_resources, res ? res->flags : 0);

		return -ENXIO;

	}

	buffer_size = res->end - res->start + 1;

	start = res->start;

	printk(KERN_INFO "ram_console: got buffer at %x, size %x\n",

	       start, buffer_size);

	buffer = ioremap(res->start, buffer_size);

	if (buffer == NULL) {

		printk(KERN_ERR "ram_console: failed to map memory\n");

		return -ENOMEM;

	}

	return ram_console_init(buffer, buffer_size, NULL/* allocate */);

}

static struct platform_driver ram_console_driver = {

	.probe = ram_console_driver_probe,

	.driver		= {

		.name	= "ram_console",

	},

};

static int __init ram_console_module_init(void)

{

	int err;

	err = platform_driver_register(&ram_console_driver);

	return err;

}

#endif

static ssize_t ram_console_read_old(struct file *file, char __user *buf,

				    size_t len, loff_t *offset)

{

	loff_t pos = *offset;

	ssize_t count;

	if (pos >= ram_console_old_log_size)

		return 0;

	count = min(len, (size_t)(ram_console_old_log_size - pos));

	if (copy_to_user(buf, ram_console_old_log + pos, count))

		return -EFAULT;

	*offset += count;

	return count;

}

static struct file_operations ram_console_file_ops = {

	.owner = THIS_MODULE,

	.read = ram_console_read_old,

};

static int __init ram_console_late_init(void)

{

	struct proc_dir_entry *entry;

	if (ram_console_old_log == NULL)

		return 0;

#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT

	ram_console_old_log = kmalloc(ram_console_old_log_size, GFP_KERNEL);

	if (ram_console_old_log == NULL) {

		printk(KERN_ERR

		       "ram_console: failed to allocate buffer for old log\n");

		ram_console_old_log_size = 0;

		return 0;

	}

	memcpy(ram_console_old_log,

	       ram_console_old_log_init_buffer, ram_console_old_log_size);

#endif

	entry = create_proc_entry("last_kmsg", S_IFREG | S_IRUGO, NULL);

	if (!entry) {

		printk(KERN_ERR "ram_console: failed to create proc entry\n");

		kfree(ram_console_old_log);

		ram_console_old_log = NULL;

		return 0;

	}

	entry->proc_fops = &ram_console_file_ops;

	entry->size = ram_console_old_log_size;

	return 0;

}

#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT

console_initcall(ram_console_early_init);

#else

module_init(ram_console_module_init);

#endif

late_initcall(ram_console_late_init);