4d73d94f728da442b465225c96416d117fd6b48b
[linux-2.6.git] / drivers / staging / android / persistent_ram.c
1 /*
2  * Copyright (C) 2012 Google, Inc.
3  *
4  * This software is licensed under the terms of the GNU General Public
5  * License version 2, as published by the Free Software Foundation, and
6  * may be copied, distributed, and modified under those terms.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  */
14
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/io.h>
21 #include <linux/list.h>
22 #include <linux/memblock.h>
23 #include <linux/persistent_ram.h>
24 #include <linux/rslib.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27
28 struct persistent_ram_buffer {
29         uint32_t    sig;
30         atomic_t    start;
31         atomic_t    size;
32         uint8_t     data[0];
33 };
34
35 #define PERSISTENT_RAM_SIG (0x43474244) /* DBGC */
36
37 static __devinitdata LIST_HEAD(persistent_ram_list);
38
39 static inline size_t buffer_size(struct persistent_ram_zone *prz)
40 {
41         return atomic_read(&prz->buffer->size);
42 }
43
44 static inline size_t buffer_start(struct persistent_ram_zone *prz)
45 {
46         return atomic_read(&prz->buffer->start);
47 }
48
49 /* increase and wrap the start pointer, returning the old value */
50 static inline size_t buffer_start_add(struct persistent_ram_zone *prz, size_t a)
51 {
52         int old;
53         int new;
54
55         do {
56                 old = atomic_read(&prz->buffer->start);
57                 new = old + a;
58                 while (unlikely(new > prz->buffer_size))
59                         new -= prz->buffer_size;
60         } while (atomic_cmpxchg(&prz->buffer->start, old, new) != old);
61
62         return old;
63 }
64
65 /* increase the size counter until it hits the max size */
66 static inline void buffer_size_add(struct persistent_ram_zone *prz, size_t a)
67 {
68         size_t old;
69         size_t new;
70
71         if (atomic_read(&prz->buffer->size) == prz->buffer_size)
72                 return;
73
74         do {
75                 old = atomic_read(&prz->buffer->size);
76                 new = old + a;
77                 if (new > prz->buffer_size)
78                         new = prz->buffer_size;
79         } while (atomic_cmpxchg(&prz->buffer->size, old, new) != old);
80 }
81
82 static void notrace persistent_ram_encode_rs8(struct persistent_ram_zone *prz,
83         uint8_t *data, size_t len, uint8_t *ecc)
84 {
85         int i;
86         uint16_t par[prz->ecc_size];
87
88         /* Initialize the parity buffer */
89         memset(par, 0, sizeof(par));
90         encode_rs8(prz->rs_decoder, data, len, par, 0);
91         for (i = 0; i < prz->ecc_size; i++)
92                 ecc[i] = par[i];
93 }
94
95 static int persistent_ram_decode_rs8(struct persistent_ram_zone *prz,
96         void *data, size_t len, uint8_t *ecc)
97 {
98         int i;
99         uint16_t par[prz->ecc_size];
100
101         for (i = 0; i < prz->ecc_size; i++)
102                 par[i] = ecc[i];
103         return decode_rs8(prz->rs_decoder, data, par, len,
104                                 NULL, 0, NULL, 0, NULL);
105 }
106
107 static void notrace persistent_ram_update_ecc(struct persistent_ram_zone *prz,
108         unsigned int start, unsigned int count)
109 {
110         struct persistent_ram_buffer *buffer = prz->buffer;
111         uint8_t *buffer_end = buffer->data + prz->buffer_size;
112         uint8_t *block;
113         uint8_t *par;
114         int ecc_block_size = prz->ecc_block_size;
115         int ecc_size = prz->ecc_size;
116         int size = prz->ecc_block_size;
117
118         if (!prz->ecc)
119                 return;
120
121         block = buffer->data + (start & ~(ecc_block_size - 1));
122         par = prz->par_buffer + (start / ecc_block_size) * prz->ecc_size;
123
124         do {
125                 if (block + ecc_block_size > buffer_end)
126                         size = buffer_end - block;
127                 persistent_ram_encode_rs8(prz, block, size, par);
128                 block += ecc_block_size;
129                 par += ecc_size;
130         } while (block < buffer->data + start + count);
131 }
132
133 static void persistent_ram_update_header_ecc(struct persistent_ram_zone *prz)
134 {
135         struct persistent_ram_buffer *buffer = prz->buffer;
136
137         if (!prz->ecc)
138                 return;
139
140         persistent_ram_encode_rs8(prz, (uint8_t *)buffer, sizeof(*buffer),
141                                   prz->par_header);
142 }
143
144 static void persistent_ram_ecc_old(struct persistent_ram_zone *prz)
145 {
146         struct persistent_ram_buffer *buffer = prz->buffer;
147         uint8_t *block;
148         uint8_t *par;
149
150         if (!prz->ecc)
151                 return;
152
153         block = buffer->data;
154         par = prz->par_buffer;
155         while (block < buffer->data + buffer_size(prz)) {
156                 int numerr;
157                 int size = prz->ecc_block_size;
158                 if (block + size > buffer->data + prz->buffer_size)
159                         size = buffer->data + prz->buffer_size - block;
160                 numerr = persistent_ram_decode_rs8(prz, block, size, par);
161                 if (numerr > 0) {
162                         pr_devel("persistent_ram: error in block %p, %d\n",
163                                block, numerr);
164                         prz->corrected_bytes += numerr;
165                 } else if (numerr < 0) {
166                         pr_devel("persistent_ram: uncorrectable error in block %p\n",
167                                 block);
168                         prz->bad_blocks++;
169                 }
170                 block += prz->ecc_block_size;
171                 par += prz->ecc_size;
172         }
173 }
174
175 static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
176         size_t buffer_size)
177 {
178         int numerr;
179         struct persistent_ram_buffer *buffer = prz->buffer;
180         int ecc_blocks;
181
182         if (!prz->ecc)
183                 return 0;
184
185         prz->ecc_block_size = 128;
186         prz->ecc_size = 16;
187         prz->ecc_symsize = 8;
188         prz->ecc_poly = 0x11d;
189
190         ecc_blocks = DIV_ROUND_UP(prz->buffer_size, prz->ecc_block_size);
191         prz->buffer_size -= (ecc_blocks + 1) * prz->ecc_size;
192
193         if (prz->buffer_size > buffer_size) {
194                 pr_err("persistent_ram: invalid size %zu, non-ecc datasize %zu\n",
195                        buffer_size, prz->buffer_size);
196                 return -EINVAL;
197         }
198
199         prz->par_buffer = buffer->data + prz->buffer_size;
200         prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_size;
201
202         /*
203          * first consecutive root is 0
204          * primitive element to generate roots = 1
205          */
206         prz->rs_decoder = init_rs(prz->ecc_symsize, prz->ecc_poly, 0, 1,
207                                   prz->ecc_size);
208         if (prz->rs_decoder == NULL) {
209                 pr_info("persistent_ram: init_rs failed\n");
210                 return -EINVAL;
211         }
212
213         prz->corrected_bytes = 0;
214         prz->bad_blocks = 0;
215
216         numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
217                                            prz->par_header);
218         if (numerr > 0) {
219                 pr_info("persistent_ram: error in header, %d\n", numerr);
220                 prz->corrected_bytes += numerr;
221         } else if (numerr < 0) {
222                 pr_info("persistent_ram: uncorrectable error in header\n");
223                 prz->bad_blocks++;
224         }
225
226         return 0;
227 }
228
229 ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
230         char *str, size_t len)
231 {
232         ssize_t ret;
233
234         if (prz->corrected_bytes || prz->bad_blocks)
235                 ret = snprintf(str, len, ""
236                         "\n%d Corrected bytes, %d unrecoverable blocks\n",
237                         prz->corrected_bytes, prz->bad_blocks);
238         else
239                 ret = snprintf(str, len, "\nNo errors detected\n");
240
241         return ret;
242 }
243
244 static void notrace persistent_ram_update(struct persistent_ram_zone *prz,
245         const void *s, unsigned int start, unsigned int count)
246 {
247         struct persistent_ram_buffer *buffer = prz->buffer;
248         memcpy(buffer->data + start, s, count);
249         persistent_ram_update_ecc(prz, start, count);
250 }
251
252 static void __devinit
253 persistent_ram_save_old(struct persistent_ram_zone *prz)
254 {
255         struct persistent_ram_buffer *buffer = prz->buffer;
256         size_t size = buffer_size(prz);
257         size_t start = buffer_start(prz);
258         char *dest;
259
260         persistent_ram_ecc_old(prz);
261
262         dest = kmalloc(size, GFP_KERNEL);
263         if (dest == NULL) {
264                 pr_err("persistent_ram: failed to allocate buffer\n");
265                 return;
266         }
267
268         prz->old_log = dest;
269         prz->old_log_size = size;
270         memcpy(prz->old_log, &buffer->data[start], size - start);
271         memcpy(prz->old_log + size - start, &buffer->data[0], start);
272 }
273
274 int notrace persistent_ram_write(struct persistent_ram_zone *prz,
275         const void *s, unsigned int count)
276 {
277         int rem;
278         int c = count;
279         size_t start;
280
281         if (unlikely(c > prz->buffer_size)) {
282                 s += c - prz->buffer_size;
283                 c = prz->buffer_size;
284         }
285
286         buffer_size_add(prz, c);
287
288         start = buffer_start_add(prz, c);
289
290         rem = prz->buffer_size - start;
291         if (unlikely(rem < c)) {
292                 persistent_ram_update(prz, s, start, rem);
293                 s += rem;
294                 c -= rem;
295                 start = 0;
296         }
297         persistent_ram_update(prz, s, start, c);
298
299         persistent_ram_update_header_ecc(prz);
300
301         return count;
302 }
303
304 size_t persistent_ram_old_size(struct persistent_ram_zone *prz)
305 {
306         return prz->old_log_size;
307 }
308
309 void *persistent_ram_old(struct persistent_ram_zone *prz)
310 {
311         return prz->old_log;
312 }
313
314 void persistent_ram_free_old(struct persistent_ram_zone *prz)
315 {
316         kfree(prz->old_log);
317         prz->old_log = NULL;
318         prz->old_log_size = 0;
319 }
320
321 static int persistent_ram_buffer_map(phys_addr_t start, phys_addr_t size,
322                 struct persistent_ram_zone *prz)
323 {
324         struct page **pages;
325         phys_addr_t page_start;
326         unsigned int page_count;
327         pgprot_t prot;
328         unsigned int i;
329
330         page_start = start - offset_in_page(start);
331         page_count = DIV_ROUND_UP(size + offset_in_page(start), PAGE_SIZE);
332
333         prot = pgprot_noncached(PAGE_KERNEL);
334
335         pages = kmalloc(sizeof(struct page *) * page_count, GFP_KERNEL);
336         if (!pages) {
337                 pr_err("%s: Failed to allocate array for %u pages\n", __func__,
338                         page_count);
339                 return -ENOMEM;
340         }
341
342         for (i = 0; i < page_count; i++) {
343                 phys_addr_t addr = page_start + i * PAGE_SIZE;
344                 pages[i] = pfn_to_page(addr >> PAGE_SHIFT);
345         }
346
347         prz->vaddr = vmap(pages, page_count, VM_MAP, prot);
348         kfree(pages);
349         if (!prz->vaddr) {
350                 pr_err("%s: Failed to map %u pages\n", __func__, page_count);
351                 return -ENOMEM;
352         }
353
354         prz->buffer = prz->vaddr + offset_in_page(start);
355         prz->buffer_size = size - sizeof(struct persistent_ram_buffer);
356
357         return 0;
358 }
359
360 static int __devinit persistent_ram_buffer_init(const char *name,
361                 struct persistent_ram_zone *prz)
362 {
363         int i;
364         struct persistent_ram *ram;
365         struct persistent_ram_descriptor *desc;
366         phys_addr_t start;
367
368         list_for_each_entry(ram, &persistent_ram_list, node) {
369                 start = ram->start;
370                 for (i = 0; i < ram->num_descs; i++) {
371                         desc = &ram->descs[i];
372                         if (!strcmp(desc->name, name))
373                                 return persistent_ram_buffer_map(start,
374                                                 desc->size, prz);
375                         start += desc->size;
376                 }
377         }
378
379         return -EINVAL;
380 }
381
382 static  __devinit
383 struct persistent_ram_zone *__persistent_ram_init(struct device *dev, bool ecc)
384 {
385         struct persistent_ram_zone *prz;
386         int ret = -ENOMEM;
387
388         prz = kzalloc(sizeof(struct persistent_ram_zone), GFP_KERNEL);
389         if (!prz) {
390                 pr_err("persistent_ram: failed to allocate persistent ram zone\n");
391                 goto err;
392         }
393
394         INIT_LIST_HEAD(&prz->node);
395
396         ret = persistent_ram_buffer_init(dev_name(dev), prz);
397         if (ret) {
398                 pr_err("persistent_ram: failed to initialize buffer\n");
399                 goto err;
400         }
401
402         prz->ecc = ecc;
403         ret = persistent_ram_init_ecc(prz, prz->buffer_size);
404         if (ret)
405                 goto err;
406
407         if (prz->buffer->sig == PERSISTENT_RAM_SIG) {
408                 if (buffer_size(prz) > prz->buffer_size ||
409                     buffer_start(prz) > buffer_size(prz))
410                         pr_info("persistent_ram: found existing invalid buffer,"
411                                 " size %zu, start %zu\n",
412                                buffer_size(prz), buffer_start(prz));
413                 else {
414                         pr_info("persistent_ram: found existing buffer,"
415                                 " size %zu, start %zu\n",
416                                buffer_size(prz), buffer_start(prz));
417                         persistent_ram_save_old(prz);
418                 }
419         } else {
420                 pr_info("persistent_ram: no valid data in buffer"
421                         " (sig = 0x%08x)\n", prz->buffer->sig);
422         }
423
424         prz->buffer->sig = PERSISTENT_RAM_SIG;
425         atomic_set(&prz->buffer->start, 0);
426         atomic_set(&prz->buffer->size, 0);
427
428         return prz;
429 err:
430         kfree(prz);
431         return ERR_PTR(ret);
432 }
433
434 struct persistent_ram_zone * __devinit
435 persistent_ram_init_ringbuffer(struct device *dev, bool ecc)
436 {
437         return __persistent_ram_init(dev, ecc);
438 }
439
440 int __init persistent_ram_early_init(struct persistent_ram *ram)
441 {
442         int ret;
443
444         ret = memblock_reserve(ram->start, ram->size);
445         if (ret) {
446                 pr_err("Failed to reserve persistent memory from %08lx-%08lx\n",
447                         (long)ram->start, (long)(ram->start + ram->size - 1));
448                 return ret;
449         }
450
451         list_add_tail(&ram->node, &persistent_ram_list);
452
453         pr_info("Initialized persistent memory from %08lx-%08lx\n",
454                 (long)ram->start, (long)(ram->start + ram->size - 1));
455
456         return 0;
457 }