static int cmd_nand_erase(int argc, char *argv[])
{
u32 start_block, block, blocks, total_blocks;
int i, rval;
total_blocks = flnand.blocks_per_bank * flnand.banks;
if (argc != 3) {
uart_putstr("nand_erase [block] [blocks]!\r\n");
uart_putstr("Total blocks: ");
uart_putdec(total_blocks);
uart_putstr("\r\n");
return -1;
}
putstr("erase nand blocks including any bad blocks...\r\n");
putstr("press enter to start!\r\n");
putstr("press any key to terminate!\r\n");
rval = uart_wait_escape(0xffffffff);
if (rval == 0)
return -1;
strtou32(argv[1], &start_block);
strtou32(argv[2], &blocks);
for (i = 0, block = start_block; i < blocks; i++, block++) {
if (uart_poll())
break;
if (block >= total_blocks)
break;
rval = nand_erase_block(block);
putchar('.');
if ((i & 0xf) == 0xf) {
putchar(' ');
putdec(i);
putchar('/');
putdec(blocks);
putstr(" (");
putdec(i * 100 / blocks);
putstr("%)\t\t\r");
}
if (rval < 0) {
putstr("\r\nfailed at block ");
putdec(block);
putstr("\r\n");
}
}
putstr("\r\ndone!\r\n");
return 0;
}
void Fib(int argc, char **argv) {
int x,y,z;
if (argc < 2) {
usage(stderr);
exit();
}
int N = strtou32(argv[1]);
x = 1; //MOV R1, #1
y = 0; //MOV R2, #0
if (N < 2) //CMP R0, #2
x = N; //MOVMI R1, R0; BMI #5
else {
N -= 2;
do {
z = y; //MOV R3, R2
y = x; //MOV R2, R1
x = y + z; //ADD R1, R2, R3
N--; //SUBS R0, R0, 1
} while (N >= 0);//BPL #-6
}
writei(stdout, x);
writes(stdout, "\n");
exit();
}
static int cmd_hotboot(int argc, char *argv[])
{
u32 pattern;
if (argc != 2) {
uart_putstr("pattern argument is required\r\n");
return -1;
}
if (strtou32(argv[1], &pattern) < 0) {
uart_putstr("invalid parameter!\r\n");
return -2;
}
*((u32 *) &hotboot_pattern) = pattern;
*((u32 *) &hotboot_valid) = 1;
{
#if (!defined(CONFIG_NAND_NONE) || !defined(CONFIG_NOR_NONE))
flpart_table_t ptb;
flprog_get_part_table(&ptb);
boot(ptb.dev.cmdline, 1);
#else
boot(NULL, 1);
#endif
}
return 0;
}
static rc_t get_int64_option( Args * args, const char * name, uint64_t def, uint64_t * value )
{
const char * s;
rc_t rc = get_str_option( args, name, &s );
*value = def;
if ( rc == 0 && s != NULL )
{
char *endp;
*value = strtou32( s, &endp, 0 );
if ( *endp != '\0' )
{
rc = RC( rcExe, rcArgv, rcProcessing, rcParam, rcInvalid );
(void)PLOGERR( klogErr, ( klogErr, rc, "error converting string to integer option '$(t)'", "t=%s", name ) );
}
else if ( *value == 0 )
*value = def;
}
return rc;
}
static int cmd_exec(int argc, char *argv[])
{
u32 addr;
void (*jump_to_img)(void) = NULL;
if (argc != 2 || strtou32(argv[1], &addr) < 0) {
uart_putstr("address (eg. 0x");
uart_puthex(DRAM_START_ADDR + 0x00100000);
uart_putstr(") is required\r\n");
return -1;
}
if (addr < (DRAM_START_ADDR + 0x00100000) ||
addr > (DRAM_START_ADDR + DRAM_SIZE - 1)) {
uart_putstr("address out of range!\r\n");
return -1;
}
jump_to_img = (void *) addr;
if (jump_to_img != 0x0) {
uart_putstr("jumping to 0x");
uart_puthex(addr);
uart_putstr(" ...\r\n");
_clean_flush_all_cache();
_disable_icache();
_disable_dcache();
disable_interrupts();
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
__asm__ __volatile__ ("nop");
jump_to_img();
}
return 0;
}
int
patts_get_db_version (uint32_t *out)
{
int rc;
char *result;
json_t *meta_header, *metadata;
rc = sqon_query (patts_get_db (), "SELECT version FROM Meta LIMIT 1",
&result, NULL);
if (rc)
return rc;
meta_header = json_loads (result, 0, NULL);
sqon_free (result);
if (NULL == meta_header)
return PATTS_UNEXPECTED;
metadata = json_array_get (meta_header, 0);
*out = strtou32 (json_string_value (json_object_get (metadata, "version")));
json_decref (meta_header);
return 0;
}
static
rc_t KWGAEncFileHeaderRead (KWGAEncFile * self)
{
KWGAEncFileHeader header;
uint8_t * pb;
size_t num_read;
size_t tot_read;
rc_t rc;
assert (self);
assert (sizeof (KWGAEncFileHeader) == 128);
DEBUG_STS (("s: Enter '%p'\n", __func__, self));
pb = (void*)&header;
for (num_read = tot_read = 0; tot_read < sizeof header; )
{
rc = KFileRead (self->encrypted, (uint64_t)tot_read, pb,
sizeof (header) - tot_read, &num_read);
if (rc)
{
LOGERR (klogErr, rc, "Error reading the header for an encrypted file");
return rc;
}
if (num_read == 0)
{
rc = RC (rcFS, rcFile, rcReading, rcFile, rcInsufficient);
LOGERR (klogErr, rc, "Header incomplete for an encrypted file");
return rc;
}
tot_read += num_read;
pb += num_read;
}
KWGAEncFileHeaderDecrypt (&header);
if (memcmp (header.magic, ncbi_crypt_magic, sizeof ncbi_crypt_magic) != 0)
{
rc = RC (rcFS, rcFile, rcReading, rcHeader, rcCorrupt);
LOGERR (klogErr, rc, "Header's magic bad for encrypted file");
return rc;
}
/* so far unknown legal range */
self->block_size = strtou32 (header.block_sz, NULL, KWGA_ENC_FILE_HEADER_RADIX);
self->file_size = strtou64 (header.file_sz, NULL, KWGA_ENC_FILE_HEADER_RADIX);
/* file format has limiting feature of a 32 bit timestamp */
self->mtime = (KTime_t)strtol (header.mtime, NULL, KWGA_ENC_FILE_HEADER_RADIX);
switch ((FER_ENCODING)header.fer_enc)
{
default:
rc = RC (rcFS, rcFile, rcReading, rcHeader, rcOutofrange);
LOGERR (klogErr, rc, "Enryption type code out of range");
return rc;
case fer_encDES:
case fer_encBLF:
rc = RC (rcFS, rcFile, rcReading, rcHeader, rcIncorrect);
LOGERR (klogErr, rc, "Enryption type code not supported");
return rc;
case fer_encAES:
break;
}
self->md5_here = (header.md5_here != 0);
if (self->md5_here)
memmove (self->md5, header.md5, sizeof (self->md5));
memmove (self->md51, header.md51, sizeof (self->md51));
return 0; /* yeah not really checking later errors am i? */
}
static int do_fuse(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
const char *op = argc >= 2 ? argv[1] : NULL;
int confirmed = argc >= 3 && !strcmp(argv[2], "-y");
u32 bank, word, cnt, val;
int ret, i;
argc -= 2 + confirmed;
argv += 2 + confirmed;
if (argc < 2 || strtou32(argv[0], 0, &bank) ||
strtou32(argv[1], 0, &word))
return CMD_RET_USAGE;
if (!strcmp(op, "read")) {
if (argc == 2)
cnt = 1;
else if (argc != 3 || strtou32(argv[2], 0, &cnt))
return CMD_RET_USAGE;
printf("Reading bank %u:\n", bank);
for (i = 0; i < cnt; i++, word++) {
if (!(i % 4))
printf("\nWord 0x%.8x:", word);
ret = fuse_read(bank, word, &val);
if (ret)
goto err;
printf(" %.8x", val);
}
putc('\n');
} else if (!strcmp(op, "sense")) {
if (argc == 2)
cnt = 1;
else if (argc != 3 || strtou32(argv[2], 0, &cnt))
return CMD_RET_USAGE;
printf("Sensing bank %u:\n", bank);
for (i = 0; i < cnt; i++, word++) {
if (!(i % 4))
printf("\nWord 0x%.8x:", word);
ret = fuse_sense(bank, word, &val);
if (ret)
goto err;
printf(" %.8x", val);
}
putc('\n');
} else if (!strcmp(op, "prog")) {
if (argc < 3)
return CMD_RET_USAGE;
for (i = 2; i < argc; i++, word++) {
if (strtou32(argv[i], 16, &val))
return CMD_RET_USAGE;
printf("Programming bank %u word 0x%.8x to 0x%.8x...\n",
bank, word, val);
if (!confirmed && !confirm_prog())
return CMD_RET_FAILURE;
ret = fuse_prog(bank, word, val);
if (ret)
goto err;
}
} else if (!strcmp(op, "override")) {
if (argc < 3)
return CMD_RET_USAGE;
for (i = 2; i < argc; i++, word++) {
if (strtou32(argv[i], 16, &val))
return CMD_RET_USAGE;
printf("Overriding bank %u word 0x%.8x with "
"0x%.8x...\n", bank, word, val);
ret = fuse_override(bank, word, val);
if (ret)
goto err;
}
} else {
return CMD_RET_USAGE;
}
return 0;
err:
puts("ERROR\n");
return ret;
}
int main (int argc, char *argv[]) {
int poradi, poradi_zpetne;
int i;
int * permutace;
int digits = 0;
int power_of_ten = 1;
int permutace_len;
int permutace_count;
char * tail;
if (argc == 1)
permutace_len = 9;
else if (argc == 2)
permutace_len = (int) strtou32 (argv[1]);
else {
writes (stderr, "Pouziti: prec <delka permutace>\n");
exit();
return 1;
}
permutace_count = faktorial (permutace_len);
/**
* Spocteme pocet cislic v desitkovem zapisu poctu permutaci,
* abychom mohli zarovnat vypis
*/
//while (permutace_count > power_of_ten) {
// power_of_ten *= 10;
// digits++;
//}
/**
* Test konzistence indexovani permutaci hrubou silou.
*
* Projdeme vsechna poradi, dekodujeme permutaci, vytiskneme permutaci,
* permutaci zpet zakodujeme na poradi a porovname toto poradi
* s puvodnim. Jestli se lisi, tiskneme na konci radku "!!!FAIL!!!",
* jestli ne, tak "OK".
*/
permutace = (int *) 0x90000000;
for (poradi = 1; poradi <= permutace_count; poradi++) {
writes (stderr, "Permutace ");
writei (stderr, poradi);
writes (stderr, ": ");
poradi_na_permutace (poradi, permutace, permutace_len);
PRINT_INT_ARRAY (permutace, permutace_len, i);
poradi_zpetne = permutace_na_poradi (permutace, permutace_len);
if (poradi_zpetne == poradi)
writes (stderr, " OK");
else {
writes (stderr, " FAILED, permutace_na_poradi vratila ");
writei (stderr, poradi_zpetne);
}
writes (stderr, "\n");
}
exit();
return 0;
}
static int cmd_dump(int argc, char *argv[])
{
u32 val;
u32 _saddr;
u32 _eaddr;
u32 _caddr;
u32 _taddr;
int num;
int count = 0;
int flag = 1;
if (argc == 3 || argc == 5) {
if (argc == 3)
flag = 0;
if (strcmp("8", argv[1]) == 0) {
num = 1;
} else if (strcmp("16", argv[1]) == 0) {
num = 2;
} else if (strcmp("32", argv[1]) == 0) {
num = 4;
} else {
uart_putstr("2nd argument be [8|16|32]!\r\n");
return -1;
}
/* Get start address */
if (strtou32(argv[2], &_saddr) < 0) {
uart_putstr("invalid start sddress!\r\n");
return -2;
}
_taddr = _saddr & 0xf0000000;
if (_taddr != AHB_BASE &&
_taddr != APB_BASE &&
_taddr != DRAM_START_ADDR) {
uart_putstr("start address out of range!\r\n");
return -3;
}
/* Check for '-' */
if (flag == 1 && strcmp("-", argv[3]) != 0) {
uart_putstr("syntax error!\r\n");
return -4;
}
/* Get end address */
if (flag == 1 && strtou32(argv[4], &_eaddr) < 0) {
uart_putstr("invalid end address!\r\n");
return -5;
}
if (flag == 0)
_eaddr = _saddr + num - 1;
/* Check end address range */
_taddr = _eaddr & 0xf0000000;
if (_taddr != AHB_BASE &&
_taddr != APB_BASE &&
_taddr != DRAM_START_ADDR) {
uart_putstr("end address out of range!\r\n");
return -6;
}
/* Check address range */
if (_eaddr < _saddr) {
uart_putstr("end address must be larger than ");
uart_putstr("start address\r\n");
return -7;
}
/* Dump memory */
for (_caddr = _saddr; _caddr <= _eaddr; ) {
if ((count % 16) == 0){
if (count != 0)
uart_putstr("\r\n");
uart_putstr("0x");
uart_puthex(_caddr);
uart_putstr(" ");
}
if (num == 1) {
val = readb(_caddr);
uart_putbyte(val);
uart_putstr(" ");
_caddr += 1;
count += 1;
} else if (num == 2) {
val = readb(_caddr);
uart_putbyte(val);
uart_putstr(" ");
val = readb(_caddr + 1);
uart_putbyte(val);
uart_putstr(" ");
_caddr += 2;
count += 2;
} else if (num == 4) {
val = readb(_caddr);
uart_putbyte(val);
uart_putstr(" ");
val = readb(_caddr + 1);
uart_putbyte(val);
uart_putstr(" ");
val = readb(_caddr + 2);
uart_putbyte(val);
uart_putstr(" ");
val = readb(_caddr + 3);
uart_putbyte(val);
uart_putstr(" ");
_caddr += 4;
count += 4;
}
}
uart_putstr("\r\n");
} else {
uart_putstr("Type 'help dump' for help\r\n");
return -8;
}
return 0;
}
static int cmd_setmem(int argc, char *argv[])
{
u32 val;
u32 _saddr;
u32 _eaddr;
u32 _caddr;
u32 _taddr;
int num;
if (argc == 7) {
if (strcmp("8", argv[1]) == 0) {
num = 1;
} else if (strcmp("16", argv[1]) == 0) {
num = 2;
} else if (strcmp("32", argv[1]) == 0) {
num = 4;
} else {
uart_putstr("2nd argument must be [8|16|32]!\r\n");
return -1;
}
/* Get starting address */
if (strtou32(argv[2], &_saddr) < 0) {
uart_putstr("invalid start address!\r\n");
return -2;
}
/* Get start address range */
_taddr = _saddr & 0xf0000000;
if (_taddr != AHB_BASE &&
_taddr != APB_BASE &&
_taddr != DRAM_START_ADDR) {
uart_putstr("start address out of range!\r\n");
return -3;
}
/* Check for '-' */
if (strcmp("-", argv[3]) != 0) {
uart_putstr("syntax error!\r\n");
return -4;
}
/* Get end address */
if (strtou32(argv[4], &_eaddr) < 0) {
uart_putstr("incorrect ending address\r\n");
return -5;
}
/* Check end address range */
_taddr = _eaddr & 0xf0000000;
if (_taddr != AHB_BASE &&
_taddr != APB_BASE &&
_taddr != DRAM_START_ADDR) {
uart_putstr("end address out of range!\r\n");
return -6;
}
/* Check address range */
if (_eaddr < _saddr) {
uart_putstr("end address must be larger than ");
uart_putstr("start address\r\n");
return -7;
}
/* Check for ':' */
if (strcmp(":", argv[5]) != 0) {
uart_putstr("syntax error!\r\n");
return -8;
}
/* Get pattern */
if (strtou32(argv[6], &val) < 0) {
uart_putstr("invalid pattern!\r\n");
return -9;
}
/* Perform the set operation */
for (_caddr = _saddr; _caddr <= _eaddr; ) {
if (num == 1 && (val & 0xffffff00) == 0) {
writeb(_caddr, val);
_caddr += 1;
} else if (num == 2 && (val & 0xffff0000) == 0) {
writeb(_caddr, val);
writeb(_caddr + 1, val >> 8);
_caddr += 2;
} else if (num == 4) {
writeb(_caddr, val);
writeb(_caddr + 1, val >> 8);
writeb(_caddr + 2, val >> 16);
writeb(_caddr + 3, val >> 24);
_caddr += 4;
}
