drivers/staging/android/ram_console.c - nest-cam/v350/linux - Git at Google

 /* 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 <linux/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,
 };

 void ram_console_enable_console(int enabled)
 {
 	if (enabled)
 		ram_console.flags |= CON_ENABLED;
 	else
 		ram_console.flags &= ~CON_ENABLED;
 }

 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);

 	if (ram_console_buffer_size > buffer_size) {
 		pr_err("ram_console: buffer %p, invalid size %zu, "
 		       "datasize %zu\n", buffer, buffer_size,
 		       ram_console_buffer_size);
 		return 0;
 	}

 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
 	ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
 						ECC_BLOCK_SIZE) + 1) * ECC_SIZE;

 	if (ram_console_buffer_size > buffer_size) {
 		pr_err("ram_console: buffer %p, invalid size %zu, "
 		       "non-ecc datasize %zu\n",
 		       buffer, buffer_size, ram_console_buffer_size);
 		return 0;
 	}

 	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 %zx, size %zx\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 const 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
 postcore_initcall(ram_console_module_init);
 #endif
 late_initcall(ram_console_late_init);
	/* 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 <linux/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,
	};

	void ram_console_enable_console(int enabled)
	{
	if (enabled)
	ram_console.flags \|= CON_ENABLED;
	else
	ram_console.flags &= ~CON_ENABLED;
	}

	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);

	if (ram_console_buffer_size > buffer_size) {
	pr_err("ram_console: buffer %p, invalid size %zu, "
	"datasize %zu\n", buffer, buffer_size,
	ram_console_buffer_size);
	return 0;
	}

	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
	ECC_BLOCK_SIZE) + 1) * ECC_SIZE;

	if (ram_console_buffer_size > buffer_size) {
	pr_err("ram_console: buffer %p, invalid size %zu, "
	"non-ecc datasize %zu\n",
	buffer, buffer_size, ram_console_buffer_size);
	return 0;
	}

	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 %zx, size %zx\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 const 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
	postcore_initcall(ram_console_module_init);
	#endif
	late_initcall(ram_console_late_init);