1 /* drivers/android/ram_console.c
3 * Copyright (C) 2007-2008 Google, Inc.
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.
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.
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>
25 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
26 #include <linux/rslib.h>
29 struct ram_console_buffer
{
36 #define RAM_CONSOLE_SIG (0x43474244) /* DBGC */
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
];
42 static char *ram_console_old_log
;
43 static size_t ram_console_old_log_size
;
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
58 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
59 static void ram_console_encode_rs8(uint8_t *data
, size_t len
, uint8_t *ecc
)
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
++)
70 static int ram_console_decode_rs8(void *data
, size_t len
, uint8_t *ecc
)
73 uint16_t par
[ECC_SIZE
];
74 for (i
= 0; i
< ECC_SIZE
; i
++)
76 return decode_rs8(ram_console_rs_decoder
, data
, par
, len
,
77 NULL
, 0, NULL
, 0, NULL
);
81 static void ram_console_update(const char *s
, unsigned int count
)
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
;
88 int size
= ECC_BLOCK_SIZE
;
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
;
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
;
101 } while (block
< buffer
->data
+ buffer
->start
+ count
);
105 static void ram_console_update_header(void)
107 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
108 struct ram_console_buffer
*buffer
= ram_console_buffer
;
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
);
117 ram_console_write(struct console
*console
, const char *s
, unsigned int count
)
120 struct ram_console_buffer
*buffer
= ram_console_buffer
;
122 if (count
> ram_console_buffer_size
) {
123 s
+= count
- ram_console_buffer_size
;
124 count
= ram_console_buffer_size
;
126 rem
= ram_console_buffer_size
- buffer
->start
;
128 ram_console_update(s
, rem
);
132 buffer
->size
= ram_console_buffer_size
;
134 ram_console_update(s
, count
);
136 buffer
->start
+= count
;
137 if (buffer
->size
< ram_console_buffer_size
)
138 buffer
->size
+= count
;
139 ram_console_update_header();
142 static struct console ram_console
= {
144 .write
= ram_console_write
,
145 .flags
= CON_PRINTBUFFER
| CON_ENABLED
,
150 ram_console_save_old(struct ram_console_buffer
*buffer
, char *dest
)
152 size_t old_log_size
= buffer
->size
;
153 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
159 block
= buffer
->data
;
160 par
= ram_console_par_buffer
;
161 while (block
< buffer
->data
+ buffer
->size
) {
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
);
169 printk(KERN_INFO
"ram_console: error in block %p, %d\n",
172 ram_console_corrected_bytes
+= numerr
;
173 } else if (numerr
< 0) {
175 printk(KERN_INFO
"ram_console: uncorrectable error in "
176 "block %p\n", block
);
178 ram_console_bad_blocks
++;
180 block
+= ECC_BLOCK_SIZE
;
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
);
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
;
196 dest
= kmalloc(old_log_size
, GFP_KERNEL
);
199 "ram_console: failed to allocate buffer\n");
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
,
216 static int __init
ram_console_init(struct ram_console_buffer
*buffer
,
217 size_t buffer_size
, char *old_buf
)
219 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
223 ram_console_buffer
= buffer
;
224 ram_console_buffer_size
=
225 buffer_size
- sizeof(struct ram_console_buffer
);
227 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
228 ram_console_buffer_size
-= (DIV_ROUND_UP(ram_console_buffer_size
,
229 ECC_BLOCK_SIZE
) + 1) * ECC_SIZE
;
230 ram_console_par_buffer
= buffer
->data
+ ram_console_buffer_size
;
233 /* first consecutive root is 0
234 * primitive element to generate roots = 1
236 ram_console_rs_decoder
= init_rs(ECC_SYMSIZE
, ECC_POLY
, 0, 1, ECC_SIZE
);
237 if (ram_console_rs_decoder
== NULL
) {
238 printk(KERN_INFO
"ram_console: init_rs failed\n");
242 ram_console_corrected_bytes
= 0;
243 ram_console_bad_blocks
= 0;
245 par
= ram_console_par_buffer
+
246 DIV_ROUND_UP(ram_console_buffer_size
, ECC_BLOCK_SIZE
) * ECC_SIZE
;
248 numerr
= ram_console_decode_rs8(buffer
, sizeof(*buffer
), par
);
250 printk(KERN_INFO
"ram_console: error in header, %d\n", numerr
);
251 ram_console_corrected_bytes
+= numerr
;
252 } else if (numerr
< 0) {
254 "ram_console: uncorrectable error in header\n");
255 ram_console_bad_blocks
++;
259 if (buffer
->sig
== RAM_CONSOLE_SIG
) {
260 if (buffer
->size
> ram_console_buffer_size
261 || buffer
->start
> buffer
->size
)
262 printk(KERN_INFO
"ram_console: found existing invalid "
263 "buffer, size %d, start %d\n",
264 buffer
->size
, buffer
->start
);
266 printk(KERN_INFO
"ram_console: found existing buffer, "
267 "size %d, start %d\n",
268 buffer
->size
, buffer
->start
);
269 ram_console_save_old(buffer
, old_buf
);
272 printk(KERN_INFO
"ram_console: no valid data in buffer "
273 "(sig = 0x%08x)\n", buffer
->sig
);
276 buffer
->sig
= RAM_CONSOLE_SIG
;
280 register_console(&ram_console
);
281 #ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
287 #ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
288 static int __init
ram_console_early_init(void)
290 return ram_console_init((struct ram_console_buffer
*)
291 CONFIG_ANDROID_RAM_CONSOLE_EARLY_ADDR
,
292 CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE
,
293 ram_console_old_log_init_buffer
);
296 static int ram_console_driver_probe(struct platform_device
*pdev
)
298 struct resource
*res
= pdev
->resource
;
303 if (res
== NULL
|| pdev
->num_resources
!= 1 ||
304 !(res
->flags
& IORESOURCE_MEM
)) {
305 printk(KERN_ERR
"ram_console: invalid resource, %p %d flags "
306 "%lx\n", res
, pdev
->num_resources
, res
? res
->flags
: 0);
309 buffer_size
= res
->end
- res
->start
+ 1;
311 printk(KERN_INFO
"ram_console: got buffer at %x, size %x\n",
313 buffer
= ioremap(res
->start
, buffer_size
);
314 if (buffer
== NULL
) {
315 printk(KERN_ERR
"ram_console: failed to map memory\n");
319 return ram_console_init(buffer
, buffer_size
, NULL
/* allocate */);
322 static struct platform_driver ram_console_driver
= {
323 .probe
= ram_console_driver_probe
,
325 .name
= "ram_console",
329 static int __init
ram_console_module_init(void)
332 err
= platform_driver_register(&ram_console_driver
);
337 static ssize_t
ram_console_read_old(struct file
*file
, char __user
*buf
,
338 size_t len
, loff_t
*offset
)
340 loff_t pos
= *offset
;
343 if (pos
>= ram_console_old_log_size
)
346 count
= min(len
, (size_t)(ram_console_old_log_size
- pos
));
347 if (copy_to_user(buf
, ram_console_old_log
+ pos
, count
))
354 static struct file_operations ram_console_file_ops
= {
355 .owner
= THIS_MODULE
,
356 .read
= ram_console_read_old
,
359 static int __init
ram_console_late_init(void)
361 struct proc_dir_entry
*entry
;
363 if (ram_console_old_log
== NULL
)
365 #ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
366 ram_console_old_log
= kmalloc(ram_console_old_log_size
, GFP_KERNEL
);
367 if (ram_console_old_log
== NULL
) {
369 "ram_console: failed to allocate buffer for old log\n");
370 ram_console_old_log_size
= 0;
373 memcpy(ram_console_old_log
,
374 ram_console_old_log_init_buffer
, ram_console_old_log_size
);
376 entry
= create_proc_entry("last_kmsg", S_IFREG
| S_IRUGO
, NULL
);
378 printk(KERN_ERR
"ram_console: failed to create proc entry\n");
379 kfree(ram_console_old_log
);
380 ram_console_old_log
= NULL
;
384 entry
->proc_fops
= &ram_console_file_ops
;
385 entry
->size
= ram_console_old_log_size
;
389 #ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
390 console_initcall(ram_console_early_init
);
392 module_init(ram_console_module_init
);
394 late_initcall(ram_console_late_init
);