[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / android / ram_console.c

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

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
module_init(ram_console_module_init);
#endif
late_initcall(ram_console_late_init);
Commit	Line	Data
adc567e8 AH	1	/* drivers/android/ram_console.c
	2	*
	3	* Copyright (C) 2007-2008 Google, Inc.
	4	*
	5	* This software is licensed under the terms of the GNU General Public
	6	* License version 2, as published by the Free Software Foundation, and
	7	* may be copied, distributed, and modified under those terms.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	*/
	15
	16	#include <linux/console.h>
	17	#include <linux/init.h>
	18	#include <linux/module.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/proc_fs.h>
	21	#include <linux/string.h>
	22	#include <linux/uaccess.h>
e93daf9f	23	#include <linux/io.h>
adc567e8 AH	24
	25	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	26	#include <linux/rslib.h>
	27	#endif
	28
	29	struct ram_console_buffer {
	30	uint32_t sig;
	31	uint32_t start;
	32	uint32_t size;
	33	uint8_t data[0];
	34	};
	35
	36	#define RAM_CONSOLE_SIG (0x43474244) /* DBGC */
	37
	38	#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
	39	static char __initdata
	40	ram_console_old_log_init_buffer[CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE];
	41	#endif
	42	static char *ram_console_old_log;
	43	static size_t ram_console_old_log_size;
	44
	45	static struct ram_console_buffer *ram_console_buffer;
	46	static size_t ram_console_buffer_size;
	47	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	48	static char *ram_console_par_buffer;
	49	static struct rs_control *ram_console_rs_decoder;
	50	static int ram_console_corrected_bytes;
	51	static int ram_console_bad_blocks;
	52	#define ECC_BLOCK_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_DATA_SIZE
	53	#define ECC_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_ECC_SIZE
	54	#define ECC_SYMSIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE
	55	#define ECC_POLY CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_POLYNOMIAL
	56	#endif
	57
	58	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	59	static void ram_console_encode_rs8(uint8_t data, size_t len, uint8_t ecc)
	60	{
	61	int i;
	62	uint16_t par[ECC_SIZE];
	63	/* Initialize the parity buffer */
	64	memset(par, 0, sizeof(par));
	65	encode_rs8(ram_console_rs_decoder, data, len, par, 0);
	66	for (i = 0; i < ECC_SIZE; i++)
	67	ecc[i] = par[i];
	68	}
	69
	70	static int ram_console_decode_rs8(void data, size_t len, uint8_t ecc)
	71	{
	72	int i;
	73	uint16_t par[ECC_SIZE];
	74	for (i = 0; i < ECC_SIZE; i++)
	75	par[i] = ecc[i];
	76	return decode_rs8(ram_console_rs_decoder, data, par, len,
	77	NULL, 0, NULL, 0, NULL);
	78	}
	79	#endif
	80
	81	static void ram_console_update(const char *s, unsigned int count)
	82	{
	83	struct ram_console_buffer *buffer = ram_console_buffer;
	84	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	85	uint8_t *buffer_end = buffer->data + ram_console_buffer_size;
	86	uint8_t *block;
	87	uint8_t *par;
88	int size = ECC_BLOCK_SIZE;
89	#endif
90	memcpy(buffer->data + buffer->start, s, count);
91	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
92	block = buffer->data + (buffer->start & ~(ECC_BLOCK_SIZE - 1));
93	par = ram_console_par_buffer +
94	(buffer->start / ECC_BLOCK_SIZE) * ECC_SIZE;
95	do {
96	if (block + ECC_BLOCK_SIZE > buffer_end)
97	size = buffer_end - block;
98	ram_console_encode_rs8(block, size, par);
99	block += ECC_BLOCK_SIZE;
100	par += ECC_SIZE;
101	} while (block < buffer->data + buffer->start + count);
102	#endif
103	}
104
105	static void ram_console_update_header(void)
106	{
107	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
108	struct ram_console_buffer *buffer = ram_console_buffer;
109	uint8_t *par;
110	par = ram_console_par_buffer +
111	DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
112	ram_console_encode_rs8((uint8_t )buffer, sizeof(buffer), par);
113	#endif
114	}
115
116	static void
117	ram_console_write(struct console console, const char s, unsigned int count)
118	{
119	int rem;
120	struct ram_console_buffer *buffer = ram_console_buffer;
121
122	if (count > ram_console_buffer_size) {
123	s += count - ram_console_buffer_size;
124	count = ram_console_buffer_size;
125	}
126	rem = ram_console_buffer_size - buffer->start;
127	if (rem < count) {
128	ram_console_update(s, rem);
129	s += rem;
130	count -= rem;
131	buffer->start = 0;
132	buffer->size = ram_console_buffer_size;
133	}
134	ram_console_update(s, count);
135
136	buffer->start += count;
137	if (buffer->size < ram_console_buffer_size)
138	buffer->size += count;
139	ram_console_update_header();
140	}
141
142	static struct console ram_console = {
143	.name = "ram",
144	.write = ram_console_write,
145	.flags = CON_PRINTBUFFER \| CON_ENABLED,
146	.index = -1,
147	};
148
149	static void __init
150	ram_console_save_old(struct ram_console_buffer buffer, char dest)
151	{
152	size_t old_log_size = buffer->size;
153	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
154	uint8_t *block;
155	uint8_t *par;
156	char strbuf[80];
157	int strbuf_len;
158
159	block = buffer->data;
160	par = ram_console_par_buffer;
161	while (block < buffer->data + buffer->size) {
162	int numerr;
163	int size = ECC_BLOCK_SIZE;
164	if (block + size > buffer->data + ram_console_buffer_size)
165	size = buffer->data + ram_console_buffer_size - block;
166	numerr = ram_console_decode_rs8(block, size, par);
167	if (numerr > 0) {
168	#if 0
169	printk(KERN_INFO "ram_console: error in block %p, %d\n",
170	block, numerr);
171	#endif
172	ram_console_corrected_bytes += numerr;
173	} else if (numerr < 0) {
174	#if 0
175	printk(KERN_INFO "ram_console: uncorrectable error in "
176	"block %p\n", block);
177	#endif
178	ram_console_bad_blocks++;
179	}
180	block += ECC_BLOCK_SIZE;
181	par += ECC_SIZE;
182	}
183	if (ram_console_corrected_bytes \|\| ram_console_bad_blocks)
184	strbuf_len = snprintf(strbuf, sizeof(strbuf),
185	"\n%d Corrected bytes, %d unrecoverable blocks\n",
186	ram_console_corrected_bytes, ram_console_bad_blocks);
187	else
188	strbuf_len = snprintf(strbuf, sizeof(strbuf),
189	"\nNo errors detected\n");
190	if (strbuf_len >= sizeof(strbuf))
191	strbuf_len = sizeof(strbuf) - 1;
192	old_log_size += strbuf_len;
193	#endif
194
195	if (dest == NULL) {
196	dest = kmalloc(old_log_size, GFP_KERNEL);
197	if (dest == NULL) {
198	printk(KERN_ERR
199	"ram_console: failed to allocate buffer\n");
200	return;
201	}
202	}
203
204	ram_console_old_log = dest;
205	ram_console_old_log_size = old_log_size;
206	memcpy(ram_console_old_log,
207	&buffer->data[buffer->start], buffer->size - buffer->start);
208	memcpy(ram_console_old_log + buffer->size - buffer->start,
209	&buffer->data[0], buffer->start);
210	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
211	memcpy(ram_console_old_log + old_log_size - strbuf_len,
212	strbuf, strbuf_len);
213	#endif
214	}
215
216	static int __init ram_console_init(struct ram_console_buffer *buffer,
217	size_t buffer_size, char *old_buf)
218	{
219	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
220	int numerr;
221	uint8_t *par;
222	#endif
223	ram_console_buffer = buffer;
224	ram_console_buffer_size =
225	buffer_size - sizeof(struct ram_console_buffer);
226
5701c051	227	if (ram_console_buffer_size > buffer_size) {
e93daf9f GKH	228	pr_err("ram_console: buffer %p, invalid size %zu, "
	229	"datasize %zu\n", buffer, buffer_size,
	230	ram_console_buffer_size);
5701c051 AH	231	return 0;
	232	}
	233
adc567e8 AH	234	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
	235	ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
	236	ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
5701c051 AH	237
5701c051 AH	238	if (ram_console_buffer_size > buffer_size) {
bdd345d8 RD	239	pr_err("ram_console: buffer %p, invalid size %zu, "
bdd345d8 RD	240	"non-ecc datasize %zu\n",
5701c051 AH	241	buffer, buffer_size, ram_console_buffer_size);
	242	return 0;
	243	}
	244
adc567e8 AH	245	ram_console_par_buffer = buffer->data + ram_console_buffer_size;
	246
	247
	248	/* first consecutive root is 0
	249	* primitive element to generate roots = 1
	250	*/
	251	ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
	252	if (ram_console_rs_decoder == NULL) {
	253	printk(KERN_INFO "ram_console: init_rs failed\n");
	254	return 0;
	255	}
	256
	257	ram_console_corrected_bytes = 0;
	258	ram_console_bad_blocks = 0;
	259
	260	par = ram_console_par_buffer +
	261	DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
	262
	263	numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);
	264	if (numerr > 0) {
	265	printk(KERN_INFO "ram_console: error in header, %d\n", numerr);
	266	ram_console_corrected_bytes += numerr;
	267	} else if (numerr < 0) {
	268	printk(KERN_INFO
	269	"ram_console: uncorrectable error in header\n");
	270	ram_console_bad_blocks++;
	271	}
	272	#endif
	273
	274	if (buffer->sig == RAM_CONSOLE_SIG) {
	275	if (buffer->size > ram_console_buffer_size
	276	\|\| buffer->start > buffer->size)
	277	printk(KERN_INFO "ram_console: found existing invalid "
	278	"buffer, size %d, start %d\n",
	279	buffer->size, buffer->start);
	280	else {
	281	printk(KERN_INFO "ram_console: found existing buffer, "
	282	"size %d, start %d\n",
	283	buffer->size, buffer->start);
	284	ram_console_save_old(buffer, old_buf);
	285	}
	286	} else {
	287	printk(KERN_INFO "ram_console: no valid data in buffer "
	288	"(sig = 0x%08x)\n", buffer->sig);
	289	}
	290
	291	buffer->sig = RAM_CONSOLE_SIG;
	292	buffer->start = 0;
	293	buffer->size = 0;
	294
	295	register_console(&ram_console);
	296	#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
	297	console_verbose();
	298	#endif
	299	return 0;
	300	}
	301
	302	#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
	303	static int __init ram_console_early_init(void)
	304	{
	305	return ram_console_init((struct ram_console_buffer *)
	306	CONFIG_ANDROID_RAM_CONSOLE_EARLY_ADDR,
	307	CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE,
	308	ram_console_old_log_init_buffer);
309	}
310	#else
311	static int ram_console_driver_probe(struct platform_device *pdev)
312	{
313	struct resource *res = pdev->resource;
314	size_t start;
315	size_t buffer_size;
316	void *buffer;
317
318	if (res == NULL \|\| pdev->num_resources != 1 \|\|
319	!(res->flags & IORESOURCE_MEM)) {
320	printk(KERN_ERR "ram_console: invalid resource, %p %d flags "
321	"%lx\n", res, pdev->num_resources, res ? res->flags : 0);
322	return -ENXIO;
323	}
324	buffer_size = res->end - res->start + 1;
325	start = res->start;
7fce9399	326	printk(KERN_INFO "ram_console: got buffer at %zx, size %zx\n",
adc567e8 AH	327	start, buffer_size);
	328	buffer = ioremap(res->start, buffer_size);
	329	if (buffer == NULL) {
	330	printk(KERN_ERR "ram_console: failed to map memory\n");
	331	return -ENOMEM;
	332	}
	333
	334	return ram_console_init(buffer, buffer_size, NULL/* allocate */);
	335	}
	336
	337	static struct platform_driver ram_console_driver = {
	338	.probe = ram_console_driver_probe,
	339	.driver = {
	340	.name = "ram_console",
	341	},
	342	};
	343
	344	static int __init ram_console_module_init(void)
	345	{
	346	int err;
	347	err = platform_driver_register(&ram_console_driver);
	348	return err;
	349	}
	350	#endif
	351
	352	static ssize_t ram_console_read_old(struct file file, char __user buf,
	353	size_t len, loff_t *offset)
	354	{
	355	loff_t pos = *offset;
	356	ssize_t count;
	357
	358	if (pos >= ram_console_old_log_size)
	359	return 0;
	360
	361	count = min(len, (size_t)(ram_console_old_log_size - pos));
	362	if (copy_to_user(buf, ram_console_old_log + pos, count))
	363	return -EFAULT;
	364
	365	*offset += count;
	366	return count;
	367	}
	368
e93daf9f	369	static const struct file_operations ram_console_file_ops = {
adc567e8 AH	370	.owner = THIS_MODULE,
	371	.read = ram_console_read_old,
	372	};
	373
	374	static int __init ram_console_late_init(void)
	375	{
	376	struct proc_dir_entry *entry;
	377
	378	if (ram_console_old_log == NULL)
	379	return 0;
	380	#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
	381	ram_console_old_log = kmalloc(ram_console_old_log_size, GFP_KERNEL);
	382	if (ram_console_old_log == NULL) {
	383	printk(KERN_ERR
	384	"ram_console: failed to allocate buffer for old log\n");
	385	ram_console_old_log_size = 0;
	386	return 0;
	387	}
	388	memcpy(ram_console_old_log,
	389	ram_console_old_log_init_buffer, ram_console_old_log_size);
	390	#endif
	391	entry = create_proc_entry("last_kmsg", S_IFREG \| S_IRUGO, NULL);
	392	if (!entry) {
	393	printk(KERN_ERR "ram_console: failed to create proc entry\n");
	394	kfree(ram_console_old_log);
	395	ram_console_old_log = NULL;
	396	return 0;
	397	}
	398
	399	entry->proc_fops = &ram_console_file_ops;
	400	entry->size = ram_console_old_log_size;
	401	return 0;
	402	}
	403
	404	#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
	405	console_initcall(ram_console_early_init);
	406	#else
	407	module_init(ram_console_module_init);
	408	#endif
	409	late_initcall(ram_console_late_init);
	410