static spif_bool_t
action_handle_string(event_t *ev, spif_eterm_action_t action)
{
REQUIRE_RVAL(!SPIF_PTR_ISNULL(ev), FALSE);
REQUIRE_RVAL(!SPIF_STR_ISNULL(action->parameter), FALSE);
cmd_write(SPIF_STR_STR(action->parameter), spif_str_get_len(SPIF_STR(action->parameter)));
return 1;
}
static int red_cmd(char *cmd) {
char *arg = cmd+1;
SKIPSPACES(arg);
switch(*cmd) {
case 'q':
return 0;
case ';':
case '#':
break; // comment
case '>':
return cmd_dump(arg);
break;
case '<':
return cmd_load(arg);
break;
case '.':
return red_interpret(arg);
break;
case 's':
return cmd_seek(arg);
break;
case 'b':
return cmd_bsize(arg);
break;
case '/':
return cmd_search(arg);
break;
case 'd':
return cmd_system ("echo X | ired -n $BLOCK | rasm2 -o $OFFSET -D - |head -n $(($LINES-1))");
case 'p':
return cmd_print(arg);
break;
case 'r':
return cmd_resize(arg);
break;
case 'x':
return cmd_hexdump(arg);
break;
case 'X':
return cmd_bytedump(arg);
break;
case 'w':
return cmd_write(arg);
break;
case '!':
return cmd_system(arg);
break;
case 'V':
return cmd_system("vired $FILE");
break;
case '?':
return cmd_help(arg);
break;
default:
fprintf(stderr, "? %s\n", cmd);
}
return 1;
}
/**
* Change a file. Or deleted/truncated/append/created.
* - The file must exist.
*/
void cmd_change(const char* path, int size)
{
struct stat st;
if (!size)
return;
if (lstat(path, &st) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error accessing %s\n", path);
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
if (S_ISLNK(st.st_mode)) {
/* symlink */
if (rnd(2) == 0) {
/* delete */
if (remove(path) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error removing %s\n", path);
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
} else {
/* recreate */
char linkto[PATH_MAX];
if (remove(path) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error removing %s\n", path);
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
rnd_name(linkto);
cmd_generate_symlink(path, linkto);
}
} else if (S_ISREG(st.st_mode)) {
int r;
r = rnd(4);
if (r == 0) {
cmd_write(path, size);
} else if (r == 1) {
cmd_append(path, size);
} else if (r == 2) {
cmd_truncate(path, size);
} else {
cmd_delete(path);
}
}
}
/* t_parse: test parse */
int t_parse(const char *line)
{
struct command *cmd;
fprintf(stderr, "t_parse input line: |%s|\n", line);
if ((cmd = cmd_creat(line)) == (struct command *)0)
err_quit("parse error");
cmd_write(cmd);
cmd_free(cmd);
return 0;
}
int main(int argc, char *argv[]) {
struct ihf_msg *msg = NULL;
uint8_t *req = NULL;
int ret = 0;
int len;
req = malloc(sizeof(char) * BUFMAX);
if (!req) {
fprintf(stderr, "cannot allocate receiving request buffer !\n");
ret = -1;
goto exit;
}
len = read(STDIN_FILENO, req, BUFMAX);
msg = msg_unpack(req, len);
if (!msg) {
fprintf(stderr, "error unpacking message\n");
ret = -1;
goto exit;
}
switch (msg->type) {
case MSG_TYPE_INIT:
cmd_init();
break;
case MSG_TYPE_KILL:
cmd_kill();
break;
case MSG_TYPE_EXEC:
cmd_exec(msg->arg, msg->arglen);
break;
case MSG_TYPE_READ:
cmd_read();
break;
case MSG_TYPE_WRITE:
cmd_write(msg->arg, msg->arglen);
break;
default:
fprintf(stderr, "unknown request type %d\n", msg->type);
ret = -1;
goto exit;
}
exit:
if (req)
free(req);
if (msg)
free(msg);
return ret;
}
void exec_command(char cmd, char *param)
{
switch(cmd){
case'Q':cmd_quit(); break;
case'C':cmd_check(); break;
case'P':cmd_print(atoi(param)); break;
case'R':cmd_read(param); break;
case'W':cmd_write(param); break;
case'F':cmd_find(param); break;
case'S':cmd_sort(atoi(param)); break;
case'E':cmd_edit(); break;
case'H':cmd_help(); break;
default:fprintf(stderr,"error\n\n");
}
printf(":");
}
void exec_command(char cmd, char *param)
{
switch (cmd) {
case 'Q': cmd_quit(); break;
case 'C': cmd_check(); break;
case 'P': cmd_print(atoi(param)); break;
case 'R': cmd_read(param); break;
case 'W': cmd_write(param); break;
case 'F': cmd_find(param); break;
case 'S': cmd_sort(atoi(param)); break;
case 'D': cmd_delete(param); break;
case 'r': cmd_random(); break;
case 'T': test(atoi(param)); break;
default:
fprintf(stderr, "Invalid command %c: ignored.\n", cmd);
break;
}
}
BYTE CHD61102::instruction(qint16 cmd)
{
if (pPC->pCPU->fp_log)fprintf(pPC->pCPU->fp_log,"HD61102 CMD: %04x\n",cmd);
AddLog(LOG_DISPLAY,tr("HD61102 CMD:%1").arg(cmd,4,16,QChar('0')));
if ((cmd & MASK_read) == MASK_read ) { return cmd_read(cmd); }
else
if ((cmd & MASK_status) == MASK_status ) { return cmd_status(cmd); }
else
if ((cmd & MASK_write) == MASK_write ) { cmd_write(cmd); }
else
if ((cmd & MASK_displaySL) == MASK_displaySL ) { cmd_displaySL(cmd); }
else
if ((cmd & MASK_setX) == MASK_setX ) { cmd_setX(cmd); }
else
if ((cmd & MASK_setY) == MASK_setY ) { cmd_setY(cmd); }
else
if ((cmd & MASK_on_off) == MASK_on_off ) { cmd_on_off(cmd); }
return 0;
}
int main(int argc, char **argv, char * const envp[])
{
int i, unixfd;
char *unixsock = NULL;
for(i = 1;i < argc; i++){
if(strncmp(argv[i], "-u", 3) == 0){
if( i + 1 == argc ){
fprintf(stderr, "ERROR: not enough args, path to unix socket needed\n");
exit(EXIT_FAILURE);
}
unixsock = argv[i + 1];
if (TRACE) printf("unix! : %s\n", unixsock);
}
if((strncmp(argv[i],"-h", 3) == 0) ||
(strncmp(argv[i],"-help", 6) == 0) ||
(strncmp(argv[i],"--help", 7) == 0) )
{
printf("usage: spew-exec -u /path/to/unix/socket");
exit(1);
}
}
/* set up epoll */
signal(SIGPIPE, &handlesig);
signal(SIGCHLD, &handlesig);
epfd = epoll_create1(EPOLL_CLOEXEC);
if(epfd == -1) {
perror("epoll");
exit(EXIT_FAILURE);
}
struct epoll_event ev;
int oldout, olderr;
/* set up unix comms */
if(unixsock) {
unsigned int us;
struct sockaddr_un local, remote;
int len;
oldout = dup(1);
olderr = dup(2);
if( (us = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ){
perror("socket");
exit(EXIT_FAILURE);
}
local.sun_family = AF_UNIX;
strcpy(local.sun_path, unixsock);
unlink(local.sun_path);
len = strlen(local.sun_path) + sizeof(local.sun_family);
if(bind(us, (struct sockaddr*) &local, len) == -1){
perror("bind");
exit(EXIT_FAILURE);
}
if(listen(us, 1) == -1){
perror("listen");
exit(EXIT_FAILURE);
}
/* daemonize - everything that could go wrong did before this point */
daemon(1, 1);
/* continue input on unix socket */
len = sizeof(struct sockaddr_un);
if ( (unixfd= accept(us, (struct sockaddr *) &remote, &len)) == -1) {
perror("accept");
exit(EXIT_FAILURE);
}
if (TRACE) printf("accepted!\n");
ev.data.fd = unixfd;
ev.events = EPOLLIN;
/* stdout and stderr now go on the unix socket */
dup2(unixfd,1);
dup2(unixfd,2);
if(epoll_ctl(epfd, EPOLL_CTL_ADD, unixfd, &ev) == -1) {
perror("epoll_ctl unixfd");
exit(EXIT_FAILURE);
}
}else{
if (TRACE) printf("adding stdin\n");
ev.data.fd = fileno(stdin);
ev.events = EPOLLIN;
if(epoll_ctl(epfd, EPOLL_CTL_ADD, fileno(stdin), &ev) == -1) {
perror("epoll_ctl");
exit(EXIT_FAILURE);
}
}
char buffer[BUF_SIZE];
for(;;) {
int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
for(int n = 0; n < nfds; ++n) {
if (TRACE) printf("FDs %d: [%d]: %d\n", nfds, n, events[n].data.fd);
if((unixsock && events[n].data.fd == unixfd) ||
(!unixsock && events[n].data.fd == fileno(stdin)) ){
// parse spew commands
if (TRACE) printf("COMMAND READ..\n");
int rbytes = read(events[n].data.fd, buffer, BUF_SIZE);
if (TRACE) printf("read!");
if(rbytes && rbytes < BUF_SIZE){
buffer[rbytes] = '\0';
}
if(buffer[0] == '\0'){
continue;
}
if (0 == strncmp("EXEC ", buffer, 5)) {
cmd_exec(buffer+5, envp);
} else
if (0 == strncmp("WRITE ", buffer, 6)) {
cmd_write(buffer+6);
} else
if (0 == strncmp("SIGNAL ", buffer, 7)) {
cmd_signal(buffer+7);
} else
if (0 == strncmp("KILL", buffer, 5)) {
cmd_signal("SIGKILL");
} else
if (0 == strncmp("TERM", buffer, 5)) {
cmd_signal("SIGTERM");
} else
if (0 == strncmp("QUIT", buffer, 4) || 0 == strncmp("EXIT", buffer, 4)) {
exit(0);
} else {
fprintf(stderr, "unrecognized command '%s'\n", buffer);
}
}else{
/* read from the child sockets */
if (TRACE) printf("CHILD SOCKET READ MAAN\n");
int rbytes = read(events[n].data.fd, buffer, BUF_SIZE);
if (TRACE) printf("read\n");
if(rbytes && rbytes < BUF_SIZE){
buffer[rbytes] = '\0';
}
printf("OUT(%lu): %s", rbytes, buffer);
}
fflush(stdout);
fflush(stderr);
}
}
printf("EOF\n");
}
/***********************************************************************
[function]:
callback: burn the FW to ctpm.
[parameters]:
pbt_buf[in]: point to Head+FW ;
dw_lenth[in]: the length of the FW + 6(the Head length);
[return]:
ERR_OK: no error;
ERR_MODE: fail to switch to UPDATE mode;
ERR_READID: read id fail;
ERR_ERASE: erase chip fail;
ERR_STATUS: status error;
ERR_ECC: ecc error.
************************************************************************/
E_UPGRADE_ERR_TYPE fts_ctpm_fw_upgrade(u8* pbt_buf, int dw_lenth)
{
u8 cmd,reg_val[2] = {0};
u8 buffer[2] = {0};
u8 packet_buf[FTS_PACKET_LENGTH + 6];
u8 auc_i2c_write_buf[10];
u8 bt_ecc;
int j,temp,lenght,i_ret,packet_number, i = 0;
int i_is_new_protocol = 0;
/******write 0xaa to register 0xfc******/
cmd=0xaa;
fts_register_write(0xfc,&cmd);
mdelay(50);
/******write 0x55 to register 0xfc******/
cmd=0x55;
fts_register_write(0xfc,&cmd);
printk("[TSP] Step 1: Reset CTPM test\n");
mdelay(10);
/*******Step 2:Enter upgrade mode ****/
printk("\n[TSP] Step 2:enter new update mode\n");
auc_i2c_write_buf[0] = 0x55;
auc_i2c_write_buf[1] = 0xaa;
do
{
i ++;
i_ret = fts_i2c_txdata(auc_i2c_write_buf, 2);
mdelay(5);
} while(i_ret <= 0 && i < 10 );
if (i > 1)
{
i_is_new_protocol = 1;
}
/********Step 3:check READ-ID********/
cmd_write(0x90,0x00,0x00,0x00,4);
byte_read(reg_val,2);
if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
{
printk("[TSP] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
}
else
{
return ERR_READID;
//i_is_new_protocol = 1;
}
/*********Step 4:erase app**********/
if (i_is_new_protocol)
{
cmd_write(0x61,0x00,0x00,0x00,1);
}
else
{
cmd_write(0x60,0x00,0x00,0x00,1);
}
mdelay(1500);
printk("[TSP] Step 4: erase. \n");
/*Step 5:write firmware(FW) to ctpm flash*/
bt_ecc = 0;
printk("[TSP] Step 5: start upgrade. \n");
dw_lenth = dw_lenth - 8;
packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
packet_buf[0] = 0xbf;
packet_buf[1] = 0x00;
for (j=0; j<packet_number; j++)
{
temp = j * FTS_PACKET_LENGTH;
packet_buf[2] = (u8)(temp>>8);
packet_buf[3] = (u8)temp;
lenght = FTS_PACKET_LENGTH;
packet_buf[4] = (u8)(lenght>>8);
packet_buf[5] = (u8)lenght;
for (i=0; i<FTS_PACKET_LENGTH; i++)
{
packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
mdelay(FTS_PACKET_LENGTH/6 + 1);
if ((j * FTS_PACKET_LENGTH % 1024) == 0)
{
printk("[TSP] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
}
}
if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
{
temp = packet_number * FTS_PACKET_LENGTH;
packet_buf[2] = (u8)(temp>>8);
packet_buf[3] = (u8)temp;
temp = (dw_lenth) % FTS_PACKET_LENGTH;
packet_buf[4] = (u8)(temp>>8);
packet_buf[5] = (u8)temp;
for (i=0; i<temp; i++)
{
packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(&packet_buf[0],temp+6);
mdelay(20);
}
void fdc_write_data(byte val)
{
int idx;
#ifdef DEBUG_FDC
if (FDC.phase == CMD_PHASE) {
if (FDC.byte_count) {
fprintf(pfoDebug, "%02x ", val);
}
else {
fprintf(pfoDebug, "\n%02x: ", val);
}
}
#endif
switch (FDC.phase)
{
case CMD_PHASE: // in command phase?
if (FDC.byte_count) { // receiving command parameters?
FDC.command[FDC.byte_count++] = val; // copy to buffer
if (FDC.byte_count == FDC.cmd_length) { // received all command bytes?
FDC.byte_count = 0; // clear byte counter
FDC.phase = EXEC_PHASE; // switch to execution phase
FDC.cmd_handler();
}
}
else { // first command byte received
if (val & 0x20) { // skip DAM or DDAM?
FDC.flags |= SKIP_flag; // DAM/DDAM will be skipped
val &= ~0x20; // reset skip bit in command byte
}
else {
FDC.flags &= ~SKIP_flag; // make sure skip inidicator is off
}
for (idx = 0; idx < MAX_CMD_COUNT; idx++) { // loop through all known FDC commands
if (fdc_cmd_table[idx].cmd == val) { // do we have a match?
break;
}
}
if (idx != MAX_CMD_COUNT) { // valid command received
FDC.cmd_length = fdc_cmd_table[idx].cmd_length; // command length in bytes
FDC.res_length = fdc_cmd_table[idx].res_length; // result length in bytes
FDC.cmd_direction = fdc_cmd_table[idx].cmd_direction; // direction is CPU to FDC, or FDC to CPU
FDC.cmd_handler = fdc_cmd_table[idx].cmd_handler; // pointer to command handler
FDC.command[FDC.byte_count++] = val; // copy command code to buffer
if (FDC.byte_count == FDC.cmd_length) { // already received all command bytes?
FDC.byte_count = 0; // clear byte counter
FDC.phase = EXEC_PHASE; // switch to execution phase
FDC.cmd_handler();
}
}
else { // unknown command received
FDC.result[0] = 0x80; // indicate invalid command
FDC.res_length = 1;
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
break;
case EXEC_PHASE: // in execution phase?
if (FDC.cmd_direction == CPU_TO_FDC) { // proper direction?
FDC.timeout = OVERRUN_TIMEOUT;
if ((FDC.flags & SCAN_flag)) { // processing any of the scan commands?
if (val != 0xff) { // no comparison on CPU byte = 0xff
switch((FDC.command[CMD_CODE] & 0x1f))
{
case 0x51: // scan equal
if (val != *FDC.buffer_ptr) {
FDC.result[RES_ST2] &= 0xf7; // reset Scan Equal Hit
FDC.flags |= SCANFAILED_flag;
}
break;
case 0x59: // scan low or equal
if (val != *FDC.buffer_ptr) {
FDC.result[RES_ST2] &= 0xf7; // reset Scan Equal Hit
}
if (val > *FDC.buffer_ptr) {
FDC.flags |= SCANFAILED_flag;
}
break;
case 0x5d: // scan high or equal
if (val != *FDC.buffer_ptr) {
FDC.result[RES_ST2] &= 0xf7; // reset Scan Equal Hit
}
if (val < *FDC.buffer_ptr) {
FDC.flags |= SCANFAILED_flag;
}
break;
}
}
FDC.buffer_ptr++; // advance sector data pointer
}
else {
*FDC.buffer_ptr++ = val; // write byte to sector
}
if (FDC.buffer_ptr > FDC.buffer_endptr) {
FDC.buffer_ptr = active_track->data; // wrap around
}
if (--FDC.buffer_count == 0) { // processed all data?
if ((FDC.flags & SCAN_flag)) { // processing any of the scan commands?
if ((FDC.flags & SCANFAILED_flag) && (FDC.command[CMD_R] != FDC.command[CMD_EOT])) {
FDC.command[CMD_R] += FDC.command[CMD_STP]; // advance to next sector
cmd_scan();
}
else {
if ((FDC.flags & SCANFAILED_flag)) {
FDC.result[RES_ST2] |= 0x04; // Scan Not Satisfied
}
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
else if (FDC.command[CMD_CODE] == 0x4d) { // write ID command?
dword sector_size, track_size;
byte *pbPtr, *pbDataPtr;
if (active_track->sectors != 0) { // track is formatted?
free(active_track->data); // dealloc memory for old track data
}
sector_size = 128 << FDC.command[CMD_C]; // determine number of bytes from N value
if (((sector_size + 62 + FDC.command[CMD_R]) * FDC.command[CMD_H]) > CPC.max_tracksize) { // track size exceeds maximum?
active_track->sectors = 0; // 'unformat' track
}
else {
int sector;
track_size = sector_size * FDC.command[CMD_H];
active_track->sectors = FDC.command[CMD_H];
active_track->data = (byte *)malloc(track_size); // attempt to allocate the required memory
pbDataPtr = active_track->data;
pbPtr = pbGPBuffer;
for (sector = 0; sector < FDC.command[CMD_H]; sector++) {
memcpy(active_track->sector[sector].CHRN, pbPtr, 4); // copy CHRN
memset(active_track->sector[sector].flags, 0, 2); // clear ST1 & ST2
active_track->sector[sector].data = pbDataPtr; // store pointer to sector data
pbDataPtr += sector_size;
pbPtr += 4;
}
memset(active_track->data, FDC.command[CMD_N], track_size); // fill track data with specified byte value
}
pbPtr = pbGPBuffer + ((FDC.command[CMD_H]-1) * 4); // pointer to the last CHRN passed to writeID
memcpy(&FDC.result[RES_C], pbPtr, 4); // copy sector's CHRN to result buffer
FDC.result[RES_N] = FDC.command[CMD_C]; // overwrite with the N value from the writeID command
active_drive->altered = 1; // indicate that the image has been modified
FDC.phase = RESULT_PHASE; // switch to result phase
}
else if (FDC.command[CMD_R] != FDC.command[CMD_EOT]) { // haven't reached End of Track?
FDC.command[CMD_R]++; // advance to next sector
cmd_write();
}
else {
active_drive->altered = 1; // indicate that the image has been modified
FDC.result[RES_ST0] |= 0x40; // AT
FDC.result[RES_ST1] |= 0x80; // End of Cylinder
LOAD_RESULT_WITH_CHRN
FDC.phase = RESULT_PHASE; // switch to result phase
}
}
}
break;
}
}
int main(int argc, char *argv[])
{
errorCode_t ec;
char **adpArray = NULL;
int adpLen;
neardal_adapter *adapter;
static int power = 1;
g_argc=argc;
g_argv=argv;
printf("\n");
/* Look for available adapter */
ec = neardal_get_adapters(&adpArray, &adpLen);
if (ec == NEARDAL_SUCCESS)
{
memcpy(AdpName, adpArray[0], sizeof(AdpName));
neardal_free_array(&adpArray);
} else
{
printf("---- No adapter found\n");
return 1;
}
/* Power on first adapter found */
ec = neardal_get_adapter_properties(AdpName,&adapter);
if (ec == NEARDAL_SUCCESS)
{
power=adapter->powered;
neardal_free_adapter(adapter);
if (!power)
{
power = 1;
ec = neardal_set_adapter_property(AdpName, NEARD_ADP_PROP_POWERED, GINT_TO_POINTER(power));
if (ec != NEARDAL_SUCCESS) {
printf("---- Error setting adapter properties\n");
return 1;
}
}
} else
{
printf("---- Error getting adapter properties\n");
return 1;
}
/* Register callbacks */
neardal_set_cb_tag_found(cb_tag_found, NULL);
neardal_set_cb_tag_lost(cb_tag_lost, NULL);
neardal_set_cb_dev_found(cb_dev_found, NULL);
neardal_set_cb_dev_lost(cb_dev_lost, NULL);
if (argc<2)
{
printf("Missing argument\n");
help();
}
else if (strcmp(argv[1],"poll") == 0)
{
neardal_agent_set_NDEF_cb("urn:nfc:wkt:U", cb_ndef_agent, NULL, NULL);
neardal_set_cb_record_found(cb_record_found, NULL);
cmd_poll();
}
else if(strcmp(argv[1],"write") == 0)
{
cmd_write(g_argc,g_argv);
}
else if(strcmp(argv[1],"push") == 0)
{
cmd_push(g_argc,g_argv);
}
else
{
help();
}
printf("\n");
return 0;
}
int main(int argc, char* argv[])
{
int i, j, b;
lock_init();
if (argc < 2) {
help();
exit(EXIT_SUCCESS);
}
if (strcmp(argv[1], "generate") == 0) {
int disk, file, size;
if (argc != 6) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
disk = atoi(argv[3]);
file = atoi(argv[4]);
size = atoi(argv[5]);
for (i = 0; i < disk; ++i) {
for (j = 0; j < file; ++j) {
if (j == 0)
/* create at least a big one */
cmd_generate(i + 1, size);
else if (j == 1)
/* create at least an empty one */
cmd_generate(i + 1, 0);
else
cmd_generate(i + 1, rnd(size));
}
}
} else if (strcmp(argv[1], "write") == 0) {
int fail, size;
if (argc < 6) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
fail = atoi(argv[3]);
size = atoi(argv[4]);
b = 5;
/* sort the file names */
qsort(&argv[b], argc - b, sizeof(argv[b]), file_cmp);
for (i = b; i < argc; ++i)
for (j = 0; j < fail; ++j)
cmd_write(argv[i], rndnz(size));
} else if (strcmp(argv[1], "damage") == 0) {
int fail, size;
if (argc < 6) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
fail = atoi(argv[3]);
size = atoi(argv[4]);
b = 5;
/* sort the file names */
qsort(&argv[b], argc - b, sizeof(argv[b]), file_cmp);
for (i = b; i < argc; ++i)
for (j = 0; j < fail; ++j)
cmd_damage(argv[i], rndnz(size)); /* at least one byte */
} else if (strcmp(argv[1], "append") == 0) {
int size;
if (argc < 5) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
size = atoi(argv[3]);
b = 4;
/* sort the file names */
qsort(&argv[b], argc - b, sizeof(argv[b]), file_cmp);
for (i = b; i < argc; ++i)
cmd_append(argv[i], rndnz(size)); /* at least one byte */
} else if (strcmp(argv[1], "truncate") == 0) {
int size;
if (argc < 5) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
size = atoi(argv[3]);
b = 4;
/* sort the file names */
qsort(&argv[b], argc - b, sizeof(argv[b]), file_cmp);
for (i = b; i < argc; ++i)
cmd_truncate(argv[i], rnd(size));
} else if (strcmp(argv[1], "change") == 0) {
int size;
if (argc < 5) {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
seed = atoi(argv[2]);
size = atoi(argv[3]);
b = 4;
/* sort the file names */
qsort(&argv[b], argc - b, sizeof(argv[b]), file_cmp);
for (i = b; i < argc; ++i)
cmd_change(argv[i], rnd(size));
} else {
/* LCOV_EXCL_START */
help();
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
lock_done();
return 0;
}
E_UPGRADE_ERR_TYPE fts_ctpm_fw_upgrade(struct i2c_client *client,FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
{
// FTS_BYTE cmd_len = 0;
FTS_BYTE reg_val[2] = {0};
FTS_DWRD i = 0;
// FTS_BYTE ecc = 0;
FTS_DWRD packet_number;
FTS_DWRD j;
FTS_DWRD temp;
FTS_DWRD lenght;
FTS_BYTE packet_buf[FTS_PACKET_LENGTH + 6];
FTS_BYTE auc_i2c_write_buf[10];
FTS_BYTE bt_ecc;
/*********Step 1:Reset CTPM *****/
/*write 0xaa to register 0xfc*/
Fts_i2c_write(client,0xfc,0xaa);
delay_ms(50);
/*write 0x55 to register 0xfc*/
Fts_i2c_write(client,0xfc,0x55);
pr_info("Step 1: Reset CTPM test\n");
delay_ms(40);
/*********Step 2:Enter upgrade mode *****/
auc_i2c_write_buf[0] = 0x55;
auc_i2c_write_buf[1] = 0xaa;
i2c_master_send(client, auc_i2c_write_buf, 2);
pr_info("Step 2: Enter update mode. \n");
/*********Step 3:check READ-ID***********************/
/*send the opration head*/
do{
if(i > 3)
{
return ERR_READID;
}
/*read out the CTPM ID*/
cmd_write(client,0x90,0x00,0x00,0x00,4);
byte_read(client,reg_val,2);
i++;
pr_info("Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
}while(reg_val[0] != 0x79 || reg_val[1] != 0x03);
/*********Step 4:erase app*******************************/
cmd_write(client,0x61,0x00,0x00,0x00,1);
delay_ms(1500);
pr_info("Step 4: erase. \n");
/*********Step 5:write firmware(FW) to ctpm flash*********/
bt_ecc = 0;
pr_info("Step 5: start upgrade. \n");
dw_lenth = dw_lenth - 8;
packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
packet_buf[0] = 0xbf;
packet_buf[1] = 0x00;
for (j=0;j<packet_number;j++)
{
temp = j * FTS_PACKET_LENGTH;
packet_buf[2] = (FTS_BYTE)(temp>>8);
packet_buf[3] = (FTS_BYTE)temp;
lenght = FTS_PACKET_LENGTH;
packet_buf[4] = (FTS_BYTE)(lenght>>8);
packet_buf[5] = (FTS_BYTE)lenght;
for (i=0;i<FTS_PACKET_LENGTH;i++)
{
packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(client,&packet_buf[0],FTS_PACKET_LENGTH + 6);
delay_ms(FTS_PACKET_LENGTH/6 + 1);
if ((j * FTS_PACKET_LENGTH % 1024) == 0)
{
pr_info("upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
}
}
if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
{
temp = packet_number * FTS_PACKET_LENGTH;
packet_buf[2] = (FTS_BYTE)(temp>>8);
packet_buf[3] = (FTS_BYTE)temp;
temp = (dw_lenth) % FTS_PACKET_LENGTH;
packet_buf[4] = (FTS_BYTE)(temp>>8);
packet_buf[5] = (FTS_BYTE)temp;
for (i=0;i<temp;i++)
{
packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(client,&packet_buf[0],temp+6);
delay_ms(20);
}
int main(void) {
uint8_t c;
DATA_OUT // Шина данных (DDRD)
DDRC = 0b00000000; // Шина адреса
DDRB = 0b00101101; // Шина адреса, карта и светодиод
PORTB = 0b00010001; // Подтягивающий резистор на MISO и светодиод
// Пауза, пока не стабилизируется питание
_delay_ms(100);
// while(1) {
// error();
// }
// Запуск файловой системы
if(fs_init()) error();
strcpy_P((char*)buf, PSTR("boot/boot.rk"));
if(fs_open()) error();
if(fs_getfilesize()) error();
if(fs_tmp < 7) error();
if(fs_tmp > 128) error();
if(fs_read0(rom, (WORD)fs_tmp)) error();
// Гасим светодиод
PORTB |= _BV(PB0);
while(1) {
// Эмуляция ПЗУ
RomEmu();
// Зажигаем светодиод
PORTB |= _BV(PB0);
// Проверяем наличие карты
sendStart(ERR_START);
send(ERR_WAIT);
if(fs_check()) {
send(ERR_DISK_ERR);
} else {
send(ERR_OK_DISK);
recvStart();
c = wrecv();
// Сбрасываем ошибку
lastError = 0;
// Принимаем аргументы
switch(c) {
case 0: cmd_boot(); break;
case 1: cmd_ver(); break;
case 2: cmd_exec(); break;
case 3: cmd_find(); break;
case 4: cmd_open(); break;
case 5: cmd_lseek(); break;
case 6: cmd_read(); break;
case 7: cmd_write(); break;
case 8: cmd_move(); break;
default: lastError = ERR_INVALID_COMMAND;
}
// Вывод ошибки
if(lastError) sendStart(lastError);
}
// Порт рабоатет на выход
wait();
DATA_OUT
// Гасим светодиод
PORTB &=~_BV(PB0);
_delay_ms(500);
}
}
int main( void )
#endif
{
iu8 i, len, b;
/* TODO: On error? */
hal_init();
/* Send ATR */
/* TODO: Possible from EEPROM? */
hal_io_sendByteT0( 0x3B );
#if CONF_WITH_LOGGING==1
log_init();
#endif
resplen = 0;
#if CONF_WITH_TRANSACTIONS==1
/* Commit transactions not yet done. */
/* TODO: On error? */
ta_commit();
#endif /* CONF_WITH_TRANSACTIONS */
/* Initialize FS state in RAM. */
/* TODO: On error? */
fs_init();
#if CONF_WITH_PINAUTH==1
/* Initialize authentication state. */
/* TODO: On error? */
auth_init();
#endif /* CONF_WITH_PINAUTH==1 */
if( !(hal_eeprom_read( &len, ATR_LEN_ADDR, 1 ) && (len<=ATR_MAXLEN)) )
for(;;) {} /* XXX good loop mechanism? what is it anyway */
for( i=1; i<len; i++ ) {
if( !hal_eeprom_read( &b, ATR_ADDR+i, 1 ) ) for(;;) {}
hal_io_sendByteT0( b );
}
/* Command loop */
for(;;) {
for( i=0; i<5; i++ ) {
header[i] = hal_io_recByteT0();
}
#if CONF_WITH_KEYAUTH==1
if( challvalidity ) challvalidity--;
#endif /* CONF_WITH_KEYAUTH==1 */
#if CONF_WITH_TRNG==1
hal_rnd_addEntropy();
#endif /* CONF_WITH_TRNG==1 */
if( (header[0]&0xFC)==CLA_PROP ) {
switch( header[1]&0xFE ) {
#if CONF_WITH_TESTCMDS==1
case INS_WRITE:
cmd_write();
break;
case INS_READ:
cmd_read();
break;
#endif /* CONF_WITH_TESTCMDS==1 */
#if CONF_WITH_FUNNY==1
case INS_LED:
cmd_led();
break;
#endif /* CONF_WITH_FUNNY==1 */
#if CONF_WITH_PINCMDS==1
case INS_CHANGE_PIN:
cmd_changeUnblockPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
#if CONF_WITH_CREATECMD==1
case INS_CREATE:
cmd_create();
break;
#endif /* CONF_WITH_CREATECMD==1 */
#if CONF_WITH_DELETECMD==1
case INS_DELETE:
cmd_delete();
break;
#endif /* CONF_WITH_DELETECMD==1 */
#if CONF_WITH_KEYCMDS==1
case INS_EXTERNAL_AUTH:
cmd_extAuth();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
#if CONF_WITH_KEYCMDS==1
case INS_GET_CHALLENGE:
cmd_getChallenge();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
case INS_GET_RESPONSE:
cmd_getResponse();
break;
#if CONF_WITH_KEYCMDS==1
case INS_INTERNAL_AUTH:
cmd_intAuth();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
case INS_READ_BINARY:
cmd_readBinary();
break;
case INS_SELECT:
cmd_select();
break;
#if CONF_WITH_PINCMDS==1
case INS_UNBLOCK_PIN:
cmd_changeUnblockPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
case INS_UPDATE_BINARY:
cmd_updateBinary();
break;
#if CONF_WITH_KEYCMDS==1
case INS_VERIFY_KEY:
cmd_verifyKeyPIN();
break;
#endif /* CONF_WITH_KEYCMDS==1 */
#if CONF_WITH_PINCMDS==1
case INS_VERIFY_PIN:
cmd_verifyKeyPIN();
break;
#endif /* CONF_WITH_PINCMDS==1 */
default:
t0_sendWord( SW_WRONG_INS );
}
} else {
t0_sendWord( SW_WRONG_CLA );
}
#if CONF_WITH_TRNG==1
hal_rnd_addEntropy();
#endif
/* Return the SW in sw */
t0_sendSw();
}
}
int main (void)
{
sei();
uart_init(UART_BAUD_SELECT(9600, F_CPU));
uart_puts("\r\n\r\nTHIS PROGRAM USES 57600 BAUD - PLEASE CHANGE\r\n\r\n");
_delay_ms(100);
uart_init(UART_BAUD_SELECT(57600, F_CPU));
cmd_clear();
uart_puts_P("\n\n\n\n\r");
uart_puts_P("--------------------------\r\n");
uart_puts_P("System [OK]\r\n");
systimer_init();
uart_puts_P("System Timer [OK]\r\n");
/* SD Karte Initilisieren */
cmd_init();
uart_puts_P("--------------------------\r\n\r\n");
_delay_ms(100);
char input[50]={0};
static char parameters[10][32];
while(1)
{
for (uint8_t i = 0; i<=10; *parameters[++i]=0x00);
// Input
uart_puts_P("> ");
uart_input(input);
// Process Input
getparams(input, 10, 32, parameters);
char *cmd = parameters[0];
// Call Functions
if (strings_equal(cmd, "ls"))
{
uint32_t cluster = 0;
if (parameters[1][0] != 0x00)
cluster = str2num(parameters[1], 16);
cmd_ls(cluster);
}
else if (strings_equal(cmd, "cat"))
{
if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00)
cmd_help("cat");
else
{
uint64_t cluster = str2num(parameters[1], 16);
uint64_t size = str2num(parameters[2], 16);
cmd_cat(cluster, size);
}
}
else if (strings_equal(cmd, "readtest"))
{
if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00)
cmd_help("readtest");
else
{
uint64_t cluster = str2num(parameters[1], 16);
uint64_t size = str2num(parameters[2], 16);
cmd_readtest(cluster, size);
}
}
else if (strings_equal(cmd, "write"))
{
if (parameters[1][0] == 0x00 || parameters[2][0] == 0x00)
cmd_help("write");
else
{
uint64_t cluster = str2num(parameters[1], 16);
uint8_t adcport = str2num(parameters[2], 10);
uint64_t maxsize = str2num(parameters[3], 16);
uint8_t speed = str2num(parameters[4], 10);
if (parameters[3][0] == 0x00)
maxsize = 512;
if (parameters[4][0] == 0x00)
speed = 50;
cmd_write(cluster, adcport, maxsize, speed);
}
}
else if (strings_equal(cmd, "clear"))
cmd_clear();
else if (strings_equal(cmd, "time"))
cmd_time();
else if (strings_equal(cmd, "init"))
cmd_init();
else if (strings_equal(cmd, "help"))
cmd_help(parameters[1]);
else
uart_puts_P("Error: Command not found\n\r");
}
while (1);
return (1);
}
/*
[function]:
burn the FW to ctpm.
[parameters]:(ref. SPEC)
pbt_buf[in] :point to Head+FW ;
dw_lenth[in]:the length of the FW + 6(the Head length);
bt_ecc[in] :the ECC of the FW
[return]:
ERR_OK :no error;
ERR_MODE :fail to switch to UPDATE mode;
ERR_READID :read id fail;
ERR_ERASE :erase chip fail;
ERR_STATUS :status error;
ERR_ECC :ecc error.
*/
static E_UPGRADE_ERR_TYPE ft5x0x_fw_upgrade(struct ft5x0x_data *ft5x0x, u8* pbt_buf, int dw_lenth)
{
int i = 0,j = 0,i_ret;
int packet_number;
int temp,lenght;
u8 packet_buf[FTS_PACKET_LENGTH + 6];
u8 auc_i2c_write_buf[10];
u8 reg_val[2] = {0};
u8 ctpm_id[2] = {0};
u8 cmd[4];
u8 bt_ecc;
/*********Step 1:Reset CTPM *****/
/*write 0xaa to register 0xfc*/
ft5x0x_write_reg(0xfc,0xaa);
msleep(50);
/*write 0x55 to register 0xfc*/
ft5x0x_write_reg(0xfc,0x55);
printk("[FTS] Step 1: Reset CTPM.\n");
msleep(30);
/*********Step 2:Enter upgrade mode *****/
auc_i2c_write_buf[0] = 0x55;
auc_i2c_write_buf[1] = 0xaa;
do{
i ++;
i_ret = byte_write(auc_i2c_write_buf, 2);
mdelay(5);
}while(i_ret <= 0 && i < 5 );
msleep(20);
/*********Step 3:check READ-ID**********/
if(ft5x0x->id == FT5606){
ctpm_id[0] = FT56_CTPM_ID_L;
ctpm_id[1] = FT56_CTPM_ID_H;
}else{
ctpm_id[0] = FT5X_CTPM_ID_L;
ctpm_id[1] = FT5X_CTPM_ID_H;
}
cmd[0] = 0x90;
cmd[1] = 0x00;
cmd[2] = 0x00;
cmd[3] = 0x00;
cmd_write(cmd,4);
byte_read(reg_val,2);
if (reg_val[0] == ctpm_id[0] && reg_val[1] == ctpm_id[1]){
printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
}else{
printk("[FTS] ID_ERROR: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
return ERR_READID;
}
cmd[0] = 0xcd;
cmd_write(cmd,1);
byte_read(reg_val,1);
printk("[FTS] bootloader version = 0x%x\n", reg_val[0]);
/******Step 4:erase app and panel paramenter area *********/
cmd[0] = 0x61;
cmd_write(cmd,1); //erase app area
msleep(1500);
cmd[0] = 0x63;
cmd_write(cmd,1); //erase panel parameter area
msleep(100);
printk("[FTS] Step 4: erase. \n");
/*********Step 5:write firmware(FW) to ctpm flash*********/
bt_ecc = 0;
printk("[FTS] Step 5: start upgrade. \n");
dw_lenth = dw_lenth - 8;
packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
packet_buf[0] = 0xbf;
packet_buf[1] = 0x00;
for (j=0;j<packet_number;j++){
temp = j * FTS_PACKET_LENGTH;
packet_buf[2] = (u8)(temp>>8);
packet_buf[3] = (u8)temp;
lenght = FTS_PACKET_LENGTH;
packet_buf[4] = (u8)(lenght>>8);
packet_buf[5] = (u8)lenght;
for (i=0;i<FTS_PACKET_LENGTH;i++){
packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
mdelay(FTS_PACKET_LENGTH/6 + 1);
if ((j * FTS_PACKET_LENGTH % 1024) == 0){
printk("[FTS] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
}
}
if ((dw_lenth) % FTS_PACKET_LENGTH > 0){
temp = packet_number * FTS_PACKET_LENGTH;
packet_buf[2] = (u8)(temp>>8);
packet_buf[3] = (u8)temp;
temp = (dw_lenth) % FTS_PACKET_LENGTH;
packet_buf[4] = (u8)(temp>>8);
packet_buf[5] = (u8)temp;
for (i=0;i<temp;i++){
packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
bt_ecc ^= packet_buf[6+i];
}
byte_write(&packet_buf[0],temp+6);
mdelay(20);
}
