1
2
3
4
5
6
7
8
9
10
11
12
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>
23#include <linux/io.h>
24
25#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
26#include <linux/rslib.h>
27#endif
28
29struct 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)
37
38#ifdef CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT
39static char __initdata
40 ram_console_old_log_init_buffer[CONFIG_ANDROID_RAM_CONSOLE_EARLY_SIZE];
41#endif
42static char *ram_console_old_log;
43static size_t ram_console_old_log_size;
44
45static struct ram_console_buffer *ram_console_buffer;
46static size_t ram_console_buffer_size;
47#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
48static char *ram_console_par_buffer;
49static struct rs_control *ram_console_rs_decoder;
50static int ram_console_corrected_bytes;
51static 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
59static 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
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
70static 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
81static 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
105static 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
116static void
117ram_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
142static struct console ram_console = {
143 .name = "ram",
144 .write = ram_console_write,
145 .flags = CON_PRINTBUFFER | CON_ENABLED,
146 .index = -1,
147};
148
149static void __init
150ram_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
216static 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
227 if (ram_console_buffer_size > buffer_size) {
228 pr_err("ram_console: buffer %p, invalid size %zu, "
229 "datasize %zu\n", buffer, buffer_size,
230 ram_console_buffer_size);
231 return 0;
232 }
233
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;
237
238 if (ram_console_buffer_size > buffer_size) {
239 pr_err("ram_console: buffer %p, invalid size %zu, "
240 "non-ecc datasize %zu\n",
241 buffer, buffer_size, ram_console_buffer_size);
242 return 0;
243 }
244
245 ram_console_par_buffer = buffer->data + ram_console_buffer_size;
246
247
248
249
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
303static 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
311static 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;
326 printk(KERN_INFO "ram_console: got buffer at %zx, size %zx\n",
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);
335}
336
337static struct platform_driver ram_console_driver = {
338 .probe = ram_console_driver_probe,
339 .driver = {
340 .name = "ram_console",
341 },
342};
343
344static 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
352static 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
369static const struct file_operations ram_console_file_ops = {
370 .owner = THIS_MODULE,
371 .read = ram_console_read_old,
372};
373
374static 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
405console_initcall(ram_console_early_init);
406#else
407module_init(ram_console_module_init);
408#endif
409late_initcall(ram_console_late_init);
410
411
