static int __init bootinfo_bck_ecc(struct rs_control *rs, struct bootinfo_bck_buf *buf) { u8 *payload, *ecc; int i, bad_blocks = 0, corrected = 0, numerr; u16 par[ECC_SIZE]; for (payload = (u8 *)&buf->bck, ecc = (u8 *)&buf->ecc; payload < (u8 *)&buf->ecc; payload += ECC_BLOCK_SIZE, ecc += ECC_SIZE) { for (i = 0; i < ECC_SIZE; i++) par[i] = ecc[i]; numerr = decode_rs8(rs, payload, par, ECC_BLOCK_SIZE, NULL, 0, NULL, 0, NULL); if (numerr > 0) corrected += numerr; else if (numerr < 0) bad_blocks++; } if (corrected) BOOTINFO_LKMSG("\n%s: corrected %d bytes\n", __func__, corrected); if (bad_blocks) BOOTINFO_LKMSG("\n%s: %d bad blocks\n", __func__, bad_blocks); return bad_blocks; }
static int ram_console_decode_rs8(void *data, size_t len, uint8_t *ecc) { int i; uint16_t par[ECC_SIZE]; for (i = 0; i < ECC_SIZE; i++) par[i] = ecc[i]; return decode_rs8(ram_console_rs_decoder, data, par, len, NULL, 0, NULL, 0, NULL); }
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_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); }
static int __init ram_console_init(struct ram_console_buffer *buffer, size_t buffer_size, char *old_buf) { #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION int numerr; uint8_t *par; #endif ram_console_buffer = buffer; ram_console_buffer_size = buffer_size - sizeof(struct ram_console_buffer); #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) + 1) * ECC_SIZE; ram_console_par_buffer = buffer->data + ram_console_buffer_size; /* Symbolsize is 10 (bits) * Primitive polynomial is x^10+x^3+1 * first consecutive root is 0 * primitive element to generate roots = 1 * generator polynomial degree (number of roots) = 6 */ ram_console_rs_decoder = init_rs(10, 0x409, 0, 1, 6); ram_console_corrected_bytes = 0; ram_console_bad_blocks = 0; par = ram_console_par_buffer + DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE; numerr = decode_rs8(ram_console_rs_decoder, (uint8_t *)buffer, (uint16_t *)par, sizeof(*buffer), NULL, 0, NULL, 0, NULL); if (numerr > 0) { printk(KERN_INFO "ram_console: error in header, %d\n", numerr); ram_console_corrected_bytes += numerr; } else if (numerr < 0) { printk(KERN_INFO "ram_console: uncorrectable error in header\n"); ram_console_bad_blocks++; } #endif if (buffer->sig == RAM_CONSOLE_SIG) { if (buffer->size > buffer_size || buffer->start >= buffer_size) printk(KERN_INFO "ram_console: found existing invalid " "buffer, size %d, start %d\n", buffer->size, buffer->start); else { printk(KERN_INFO "ram_console: found existing buffer, " "size %d, start %d\n", buffer->size, buffer->start); ram_console_save_old(buffer, old_buf); } } else { printk(KERN_INFO "ram_console: no valid data in buffer " "(sig = 0x%08x)\n", buffer->sig); } buffer->sig = RAM_CONSOLE_SIG; buffer->start = 0; buffer->size = 0; register_console(&ram_console); #ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE console_verbose(); #endif return 0; }
static void __init ram_console_save_old(struct ram_console_buffer *buffer, char *dest) { size_t old_log_size = buffer->size; #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION uint8_t *block; uint8_t *par; char strbuf[80]; int strbuf_len; block = buffer->data; par = ram_console_par_buffer; while (block < buffer->data + buffer->size) { int numerr; int size = ECC_BLOCK_SIZE; if (block + size > buffer->data + ram_console_buffer_size) size = buffer->data + ram_console_buffer_size - block; numerr = decode_rs8(ram_console_rs_decoder, block, (uint16_t *)par, size, NULL, 0, NULL, 0, NULL); if (numerr > 0) { printk(KERN_INFO "ram_console: error in block %p, %d\n", block, numerr); ram_console_corrected_bytes += numerr; } else if (numerr < 0) { printk(KERN_INFO "ram_console: uncorrectable error in " "block %p\n", block); ram_console_bad_blocks++; } block += ECC_BLOCK_SIZE; par += ECC_SIZE; } if (ram_console_corrected_bytes || ram_console_bad_blocks) strbuf_len = snprintf(strbuf, sizeof(strbuf), "\n%d Corrected bytes, %d unrecoverable blocks\n", ram_console_corrected_bytes, ram_console_bad_blocks); else strbuf_len = snprintf(strbuf, sizeof(strbuf), "\nNo errors detected\n"); if (strbuf_len >= sizeof(strbuf)) strbuf_len = sizeof(strbuf) - 1; old_log_size += strbuf_len; #endif if (dest == NULL) { dest = kmalloc(old_log_size, GFP_KERNEL); if (dest == NULL) { printk(KERN_ERR "ram_console: failed to allocate buffer\n"); return; } } ram_console_old_log = dest; ram_console_old_log_size = old_log_size; memcpy(ram_console_old_log, &buffer->data[buffer->start], buffer->size - buffer->start); memcpy(ram_console_old_log + buffer->size - buffer->start, &buffer->data[0], buffer->start); #ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION memcpy(ram_console_old_log + old_log_size - strbuf_len, strbuf, strbuf_len); #endif }