#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
+#include <linux/rslib.h>
#include <linux/slab.h>
#include "persistent_ram.h"
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
-#include <linux/rslib.h>
-#endif
-
struct persistent_ram_buffer {
uint32_t sig;
uint32_t start;
static LIST_HEAD(zone_list);
-#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
-
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
static void persistent_ram_encode_rs8(struct persistent_ram_zone *prz,
uint8_t *data, size_t len, uint8_t *ecc)
{
int i;
- uint16_t par[ECC_SIZE];
+ uint16_t par[prz->ecc_size];
+
/* Initialize the parity buffer */
memset(par, 0, sizeof(par));
encode_rs8(prz->rs_decoder, data, len, par, 0);
- for (i = 0; i < ECC_SIZE; i++)
+ for (i = 0; i < prz->ecc_size; i++)
ecc[i] = par[i];
}
void *data, size_t len, uint8_t *ecc)
{
int i;
- uint16_t par[ECC_SIZE];
- for (i = 0; i < ECC_SIZE; i++)
+ uint16_t par[prz->ecc_size];
+
+ for (i = 0; i < prz->ecc_size; i++)
par[i] = ecc[i];
return decode_rs8(prz->rs_decoder, data, par, len,
NULL, 0, NULL, 0, NULL);
}
-#endif
-static void persistent_ram_update(struct persistent_ram_zone *prz,
- const void *s, unsigned int count)
+static void persistent_ram_update_ecc(struct persistent_ram_zone *prz,
+ unsigned int count)
{
struct persistent_ram_buffer *buffer = prz->buffer;
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
uint8_t *buffer_end = buffer->data + prz->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));
+ int ecc_block_size = prz->ecc_block_size;
+ int ecc_size = prz->ecc_size;
+ int size = prz->ecc_block_size;
+
+ if (!prz->ecc)
+ return;
+
+ block = buffer->data + (buffer->start & ~(ecc_block_size - 1));
par = prz->par_buffer +
- (buffer->start / ECC_BLOCK_SIZE) * ECC_SIZE;
+ (buffer->start / ecc_block_size) * prz->ecc_size;
do {
- if (block + ECC_BLOCK_SIZE > buffer_end)
+ if (block + ecc_block_size > buffer_end)
size = buffer_end - block;
persistent_ram_encode_rs8(prz, block, size, par);
- block += ECC_BLOCK_SIZE;
- par += ECC_SIZE;
+ block += ecc_block_size;
+ par += ecc_size;
} while (block < buffer->data + buffer->start + count);
-#endif
}
-static void persistent_ram_update_header(struct persistent_ram_zone *prz)
+static void persistent_ram_update_header_ecc(struct persistent_ram_zone *prz)
{
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
struct persistent_ram_buffer *buffer = prz->buffer;
+ if (!prz->ecc)
+ return;
+
persistent_ram_encode_rs8(prz, (uint8_t *)buffer, sizeof(*buffer),
prz->par_header);
-#endif
}
-static void __init
-persistent_ram_save_old(struct persistent_ram_zone *prz)
+static void persistent_ram_ecc_old(struct persistent_ram_zone *prz)
{
struct persistent_ram_buffer *buffer = prz->buffer;
- size_t old_log_size = buffer->size;
- char *dest;
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
uint8_t *block;
uint8_t *par;
+ if (!prz->ecc)
+ return;
+
block = buffer->data;
par = prz->par_buffer;
while (block < buffer->data + buffer->size) {
int numerr;
- int size = ECC_BLOCK_SIZE;
+ int size = prz->ecc_block_size;
if (block + size > buffer->data + prz->buffer_size)
size = buffer->data + prz->buffer_size - block;
numerr = persistent_ram_decode_rs8(prz, block, size, par);
if (numerr > 0) {
-#if 0
- pr_info("persistent_ram: error in block %p, %d\n",
+ pr_devel("persistent_ram: error in block %p, %d\n",
block, numerr);
-#endif
prz->corrected_bytes += numerr;
} else if (numerr < 0) {
-#if 0
- pr_info("persistent_ram: uncorrectable error in block %p\n",
+ pr_devel("persistent_ram: uncorrectable error in block %p\n",
block);
-#endif
prz->bad_blocks++;
}
- block += ECC_BLOCK_SIZE;
- par += ECC_SIZE;
+ block += prz->ecc_block_size;
+ par += prz->ecc_size;
+ }
+}
+
+static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
+ size_t buffer_size)
+{
+ int numerr;
+ struct persistent_ram_buffer *buffer = prz->buffer;
+ int ecc_blocks;
+
+ if (!prz->ecc)
+ return 0;
+
+ prz->ecc_block_size = 128;
+ prz->ecc_size = 16;
+ prz->ecc_symsize = 8;
+ prz->ecc_poly = 0x11d;
+
+ ecc_blocks = DIV_ROUND_UP(prz->buffer_size, prz->ecc_block_size);
+ prz->buffer_size -= (ecc_blocks + 1) * prz->ecc_size;
+
+ if (prz->buffer_size > buffer_size) {
+ pr_err("persistent_ram: invalid size %zu, non-ecc datasize %zu\n",
+ buffer_size, prz->buffer_size);
+ return -EINVAL;
+ }
+
+ prz->par_buffer = buffer->data + prz->buffer_size;
+ prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_size;
+
+ /*
+ * first consecutive root is 0
+ * primitive element to generate roots = 1
+ */
+ prz->rs_decoder = init_rs(prz->ecc_symsize, prz->ecc_poly, 0, 1,
+ prz->ecc_size);
+ if (prz->rs_decoder == NULL) {
+ pr_info("persistent_ram: init_rs failed\n");
+ return -EINVAL;
}
-#endif
+
+ prz->corrected_bytes = 0;
+ prz->bad_blocks = 0;
+
+ numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
+ prz->par_header);
+ if (numerr > 0) {
+ pr_info("persistent_ram: error in header, %d\n", numerr);
+ prz->corrected_bytes += numerr;
+ } else if (numerr < 0) {
+ pr_info("persistent_ram: uncorrectable error in header\n");
+ prz->bad_blocks++;
+ }
+
+ return 0;
+}
+
+ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
+ char *str, size_t len)
+{
+ ssize_t ret;
+
+ if (prz->corrected_bytes || prz->bad_blocks)
+ ret = snprintf(str, len, ""
+ "\n%d Corrected bytes, %d unrecoverable blocks\n",
+ prz->corrected_bytes, prz->bad_blocks);
+ else
+ ret = snprintf(str, len, "\nNo errors detected\n");
+
+ return ret;
+}
+
+static void persistent_ram_update(struct persistent_ram_zone *prz,
+ const void *s, unsigned int count)
+{
+ struct persistent_ram_buffer *buffer = prz->buffer;
+ memcpy(buffer->data + buffer->start, s, count);
+ persistent_ram_update_ecc(prz, count);
+}
+
+static void __init
+persistent_ram_save_old(struct persistent_ram_zone *prz)
+{
+ struct persistent_ram_buffer *buffer = prz->buffer;
+ size_t old_log_size = buffer->size;
+ char *dest;
+
+ persistent_ram_ecc_old(prz);
dest = kmalloc(old_log_size, GFP_KERNEL);
if (dest == NULL) {
buffer->start += c;
if (buffer->size < prz->buffer_size)
buffer->size += c;
- persistent_ram_update_header(prz);
+ persistent_ram_update_header_ecc(prz);
return count;
}
-ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
- char *str, size_t len)
-{
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
- ssize_t ret;
-
- if (prz->corrected_bytes || prz->bad_blocks)
- ret = snprintf(str, len, ""
- "\n%d Corrected bytes, %d unrecoverable blocks\n",
- prz->corrected_bytes, prz->bad_blocks);
- else
- ret = snprintf(str, len, "\nNo errors detected\n");
-
- return ret;
-#else
- return 0;
-#endif
-}
-
size_t persistent_ram_old_size(struct persistent_ram_zone *prz)
{
return prz->old_log_size;
}
static int __init __persistent_ram_init(struct persistent_ram_zone *prz,
- void __iomem *mem, size_t buffer_size)
+ void __iomem *mem, size_t buffer_size, bool ecc)
{
struct persistent_ram_buffer *buffer = mem;
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
- int numerr;
-#endif
+ int ret;
INIT_LIST_HEAD(&prz->node);
return -EINVAL;
}
-#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
- prz->buffer_size -= (DIV_ROUND_UP(prz->buffer_size,
- ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
-
- if (prz->buffer_size > buffer_size) {
- pr_err("persistent_ram: buffer %p, invalid size %zu, non-ecc datasize %zu\n",
- buffer, buffer_size, prz->buffer_size);
- return -EINVAL;
- }
-
- prz->par_buffer = buffer->data + prz->buffer_size;
- prz->par_header = prz->par_buffer +
- DIV_ROUND_UP(prz->buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
-
-
- /* first consecutive root is 0
- * primitive element to generate roots = 1
- */
- prz->rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
- if (prz->rs_decoder == NULL) {
- pr_info("persistent_ram: init_rs failed\n");
- return -EINVAL;
- }
-
- prz->corrected_bytes = 0;
- prz->bad_blocks = 0;
-
- numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
- prz->par_header);
- if (numerr > 0) {
- pr_info("persistent_ram: error in header, %d\n", numerr);
- prz->corrected_bytes += numerr;
- } else if (numerr < 0) {
- pr_info("persistent_ram: uncorrectable error in header\n");
- prz->bad_blocks++;
- }
-#endif
+ prz->ecc = ecc;
+ ret = persistent_ram_init_ecc(prz, buffer_size);
+ if (ret)
+ return ret;
if (buffer->sig == PERSISTENT_RAM_SIG) {
if (buffer->size > prz->buffer_size
}
int __init persistent_ram_init_ringbuffer(struct persistent_ram_zone *prz,
- void __iomem *mem, size_t buffer_size)
+ void __iomem *mem, size_t buffer_size, bool ecc)
{
- return __persistent_ram_init(prz, mem, buffer_size);
+ return __persistent_ram_init(prz, mem, buffer_size, true);
}
projects / openwrt / staging / blogic.git / commitdiff