atmel_lcdc.rar_AT91 lcd

#include <linux/device.h> #include <linux/err.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/io.h> #include <linux/list.h> #include <linux/memblock.h> #include <linux/rslib.h> #include <linux/slab.h> #include <linux/vmalloc.h> #include <linux/pstore_ram.h> #include <asm/page.h> struct persistent_ram_buffer { uint32_t sig; atomic_t start; atomic_t size; uint8_t data[0]; }; #define PERSISTENT_RAM_SIG (0x43474244) /* DBGC */ static inline size_t buffer_size(struct persistent_ram_zone *prz) { return atomic_read(&prz->buffer->size); } static inline size_t buffer_start(struct persistent_ram_zone *prz) { return atomic_read(&prz->buffer->start); } /* increase and wrap the start pointer, returning the old value */ static size_t buffer_start_add_atomic(struct persistent_ram_zone *prz, size_t a) { int old; int new; do { old = atomic_read(&prz->buffer->start); new = old + a; while (unlikely(new > prz->buffer_size)) new -= prz->buffer_size; } while (atomic_cmpxchg(&prz->buffer->start, old, new) != old); return old; } /* increase the size counter until it hits the max size */ static void buffer_size_add_atomic(struct persistent_ram_zone *prz, size_t a) { size_t old; size_t new; if (atomic_read(&prz->buffer->size) == prz->buffer_size) return; do { old = atomic_read(&prz->buffer->size); new = old + a; if (new > prz->buffer_size) new = prz->buffer_size; } while (atomic_cmpxchg(&prz->buffer->size, old, new) != old); } static DEFINE_RAW_SPINLOCK(buffer_lock); /* increase and wrap the start pointer, returning the old value */ static size_t buffer_start_add_locked(struct persistent_ram_zone *prz, size_t a) { int old; int new; unsigned long flags; raw_spin_lock_irqsave(&buffer_lock, flags); old = atomic_read(&prz->buffer->start); new = old + a; while (unlikely(new > prz->buffer_size)) new -= prz->buffer_size; atomic_set(&prz->buffer->start, new); raw_spin_unlock_irqrestore(&buffer_lock, flags); return old; } /* increase the size counter until it hits the max size */ static void buffer_size_add_locked(struct persistent_ram_zone *prz, size_t a) { size_t old; size_t new; unsigned long flags; raw_spin_lock_irqsave(&buffer_lock, flags); old = atomic_read(&prz->buffer->size); if (old == prz->buffer_size) goto exit; new = old + a; if (new > prz->buffer_size) new = prz->buffer_size; atomic_set(&prz->buffer->size, new); exit: raw_spin_unlock_irqrestore(&buffer_lock, flags); } static size_t (*buffer_start_add)(struct persistent_ram_zone *, size_t) = buffer_start_add_atomic; static void (*buffer_size_add)(struct persistent_ram_zone *, size_t) = buffer_size_add_atomic; static void notrace persistent_ram_encode_rs8(struct persistent_ram_zone *prz, uint8_t *data, size_t len, uint8_t *ecc) { int i; uint16_t par[prz->ecc_info.ecc_size]; /* Initialize the parity buffer */ memset(par, 0, sizeof(par)); encode_rs8(prz->rs_decoder, data, len, par, 0); for (i = 0; i < prz->ecc_info.ecc_size; i++) ecc[i] = par[i]; } static int persistent_ram_decode_rs8(struct persistent_ram_zone *prz, void *data, size_t len, uint8_t *ecc) { int i; uint16_t par[prz->ecc_info.ecc_size]; for (i = 0; i < prz->ecc_info.ecc_size; i++) par[i] = ecc[i]; return decode_rs8(prz->rs_decoder, data, par, len, NULL, 0, NULL, 0, NULL); } static void notrace persistent_ram_update_ecc(struct persistent_ram_zone *prz, unsigned int start, unsigned int count) { struct persistent_ram_buffer *buffer = prz->buffer; uint8_t *buffer_end = buffer->data + prz->buffer_size; uint8_t *block; uint8_t *par; int ecc_block_size = prz->ecc_info.block_size; int ecc_size = prz->ecc_info.ecc_size; int size = ecc_block_size; if (!ecc_size) return; block = buffer->data + (start & ~(ecc_block_size - 1)); par = prz->par_buffer + (start / ecc_block_size) * ecc_size; do { 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; } while (block < buffer->data + start + count); } static void persistent_ram_update_header_ecc(struct persistent_ram_zone *prz) { struct persistent_ram_buffer *buffer = prz->buffer; if (!prz->ecc_info.ecc_size) return; persistent_ram_encode_rs8(prz, (uint8_t *)buffer, sizeof(*buffer), prz->par_header); } static void persistent_ram_ecc_old(struct persistent_ram_zone *prz) { struct persistent_ram_buffer *buffer = prz->buffer; uint8_t *block; uint8_t *par; if (!prz->ecc_info.ecc_size) return; block = buffer->data; par = prz->par_buffer; while (block < buffer->data + buffer_size(prz)) { int numerr; int size = prz->ecc_info.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) { pr_devel("persistent_ram: error in block %p, %d\n", block, numerr); prz->corrected_bytes += numerr; } else if (numerr < 0) { pr_devel("persistent_ram: uncorrectable error in block %p\n", block); prz->bad_blocks++; } block += prz->ecc_info.block_size; par += prz->ecc_info.ecc_size; } } static int persistent_ram_init_ecc(struct persistent_ram_zone *prz, struct persistent_ram_ecc_info *ecc_info) { int numerr; struct persistent_ram_buffer *buffer = prz->buffer; int ecc_blocks; size_t ecc_total; if (!ecc_info || !ecc_info->ecc_size) return 0; prz->ecc_info.block_size = ecc_info->block_size ?: 128; prz->ecc_info.ecc_size = ecc_info->ecc_size ?: 16; prz->ecc_info.symsize = ecc_info->symsize ?: 8; prz->ecc_info.poly = ecc_info->poly ?: 0x11d; ecc_blocks = DIV_ROUND_UP(prz->buffer_size - prz->ecc_info.ecc_size, prz->ecc_info.block_size + prz->ecc_info.ecc_size); ecc_total = (ecc_blocks + 1) * prz->ecc_info.ecc_size; if (ecc_total >= prz->buffer_size) { pr_err("%s: invalid ecc_size %u (total %zu, buffer size %zu)\n", __func__, prz->ecc_info.ecc_size, ecc_total, prz->buffer_size); return -EINVAL; } prz->buffer_size -= ecc_total; prz->par_buffer = buffer->data + prz->buffer_size; prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_info.ecc_size; /* * first consecutive root is 0 * primitive element to generate roots = 1 */ prz->rs_decoder = init_rs(prz->ecc_info.symsize, prz->ecc_info.poly, 0, 1, prz->ecc_info.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++; } return 0; } ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz, char *str, size_t len) { ssize_t ret; if (!prz->ecc_info.ecc_size) return 0; 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 notrace persistent_ram_update(struct persistent_ram_zone *prz, const void *s, unsigned int start, unsigned int count) { struct persistent_ram_buffer *buffer = prz->buffer; memcpy(buffer->data + start, s, count); persistent_ram_update_ecc(prz, start, count); } void persistent_ram_save_old(struct persistent_ram_zone *prz) { struct persistent_ram_buffer *buffer = prz->buffer; size_t size = buffer_size(prz); size_t start = buffer_start(prz); if (!size) return; if (!prz->old_log) { persistent_ram_ecc_old(prz); prz->old_log = kmalloc(size, GFP_KERNEL); } if (!prz->old_log) {