/** send command and display result */ static int go_cmd(SSL* ssl, int fd, int argc, char* argv[]) { char pre[10]; const char* space=" "; const char* newline="\n"; int was_error = 0, first_line = 1; int i; char buf[1024]; snprintf(pre, sizeof(pre), "NSDCT%d ", NSD_CONTROL_VERSION); remote_write(ssl, fd, pre, strlen(pre)); for(i=0; i<argc; i++) { remote_write(ssl, fd, space, strlen(space)); remote_write(ssl, fd, argv[i], strlen(argv[i])); } remote_write(ssl, fd, newline, strlen(newline)); /* send contents to server */ if(argc == 1 && (strcmp(argv[0], "addzones") == 0 || strcmp(argv[0], "delzones") == 0)) { send_file(ssl, fd, stdin, buf, sizeof(buf)); } while(1) { if(remote_read(ssl, fd, buf, sizeof(buf)) == 0) { break; /* EOF */ } printf("%s", buf); if(first_line && strncmp(buf, "error", 5) == 0) was_error = 1; first_line = 0; } return was_error; }
/* * this should probably be in lib9 as readn */ static long myreadn(int f, void *av, long n) { char *a; long m, t; if (protodebug) { print("remote read fd %d bytes: %ld", f, n); } a = av; t = 0; while(t < n){ m = remote_read(f, a+t, n-t); if(m < 0){ if(t == 0) return m; break; } if (protodebug) { print(" rtn: %ld\n", m); if (m) { int i; for (i=0; i < m; i++) print(" %2.2ux", a[i+t]&0xFF); print("\n"); } } t += m; } return t; }
/* Lookup an unwind-table entry in remote memory. Returns 1 if an entry is found, 0 if no entry is found, negative if an error occurred reading remote memory. */ static int remote_lookup (unw_addr_space_t as, unw_word_t table, size_t table_size, unw_word_t rel_ip, struct ia64_table_entry *e, void *arg) { unw_word_t e_addr = 0, start_offset, end_offset, info_offset; unw_accessors_t *a = unw_get_accessors (as); unsigned long lo, hi, mid; int ret; /* do a binary search for right entry: */ for (lo = 0, hi = table_size / sizeof (struct ia64_table_entry); lo < hi;) { mid = (lo + hi) / 2; e_addr = table + mid * sizeof (struct ia64_table_entry); if ((ret = remote_read (e_addr, start_offset)) < 0) return ret; if (rel_ip < start_offset) hi = mid; else { if ((ret = remote_read (e_addr, end_offset)) < 0) return ret; if (rel_ip >= end_offset) lo = mid + 1; else break; } } if (rel_ip < start_offset || rel_ip >= end_offset) return 0; e->start_offset = start_offset; e->end_offset = end_offset; if ((ret = remote_read (e_addr, info_offset)) < 0) return ret; e->info_offset = info_offset; return 1; }
/** send command and display result */ static int go_cmd(SSL* ssl, int fd, int quiet, int argc, char* argv[]) { char pre[10]; const char* space=" "; const char* newline="\n"; int was_error = 0, first_line = 1; int i; char buf[1024]; snprintf(pre, sizeof(pre), "UBCT%d ", UNBOUND_CONTROL_VERSION); remote_write(ssl, fd, pre, strlen(pre)); for(i=0; i<argc; i++) { remote_write(ssl, fd, space, strlen(space)); remote_write(ssl, fd, argv[i], strlen(argv[i])); } remote_write(ssl, fd, newline, strlen(newline)); if(argc == 1 && strcmp(argv[0], "load_cache") == 0) { send_file(ssl, fd, stdin, buf, sizeof(buf)); } else if(argc == 1 && (strcmp(argv[0], "local_zones") == 0 || strcmp(argv[0], "local_zones_remove") == 0 || strcmp(argv[0], "local_datas") == 0 || strcmp(argv[0], "local_datas_remove") == 0)) { send_file(ssl, fd, stdin, buf, sizeof(buf)); send_eof(ssl, fd); } while(1) { if(remote_read(ssl, fd, buf, sizeof(buf)) == 0) { break; /* EOF */ } if(first_line && strncmp(buf, "error", 5) == 0) { printf("%s", buf); was_error = 1; } else if (!quiet) printf("%s", buf); first_line = 0; } return was_error; }
void* request_handler(void* connection){ int bytes_recieved = 0; char rec_data[4096]; int connected = *(int*)connection; //Receive the request bytes_recieved = recv(connected,rec_data,4096,0); rec_data[bytes_recieved]='\0'; fflush(stdout); char* response; char* request_copy = strdup(rec_data); char* tokenreq = strtok(rec_data," ,"); char* firstarg = tokenreq; //switch on first argument of request which is system call name if( !strcmp(firstarg,"readdir") ) { tokenreq = strtok(NULL, " ,"); response = remote_readdir(tokenreq); } else if( !strcmp(firstarg,"getattr")){ tokenreq = strtok(NULL, " ,"); response = remote_getattr(tokenreq); } else if( !strcmp(firstarg,"opendir")){ tokenreq = strtok(NULL, " ,"); response = remote_opendir(tokenreq); } else if( !strcmp(firstarg,"releasedir")){ tokenreq = strtok(NULL, " ,"); response = remote_releasedir(tokenreq); } else if( !strcmp(firstarg,"mkdir")){ tokenreq = strtok(NULL, " ,"); mode_t mode = (mode_t)atoi(strtok(NULL, " ,")); response = remote_mkdir(tokenreq,mode); } else if( !strcmp(firstarg,"read")){ tokenreq = strtok(NULL, " ,"); size_t size = (size_t)atoi(strtok(NULL, " ,")); off_t offset = (off_t)atoi(strtok(NULL, " ,")); response = remote_read(tokenreq,size,offset); } else if( !strcmp(firstarg,"open")){ tokenreq = strtok(NULL, " ,"); int flags = atoi(strtok(NULL, " ,")); response = remote_open(tokenreq, flags); } else if( !strcmp(firstarg,"release")){ tokenreq = strtok(NULL, " ,"); response = remote_release(tokenreq); } else if( !strcmp(firstarg,"write")){ tokenreq = strtok(NULL, " ,"); size_t size = (size_t)atoi(strtok(NULL, " ,")); off_t offset = (off_t)atoi(strtok(NULL, " ,")); //cut off the string so it just has the info to be written response = remote_write(tokenreq,size,offset,request_copy); } else if( !strcmp(firstarg,"truncate")){ tokenreq = strtok(NULL, " ,"); off_t newsize = (off_t)atoi(strtok(NULL, " ,")); response = remote_truncate(tokenreq,newsize); } else if( !strcmp(firstarg,"create")){ tokenreq = strtok(NULL, " ,"); mode_t mode = (mode_t)atoi(strtok(NULL, " ,")); response = remote_create(tokenreq,mode); } else if( !strcmp(firstarg,"unlink")){ tokenreq = strtok(NULL, " ,"); response = remote_unlink(tokenreq); } send(connected,response,4096,0); free(response); close(connected); free((int*)connection); pthread_exit(0); }
bool UsbConnection::Read(apacket* packet) { int rc = remote_read(packet, handle_); return rc == 0; }
PROTECTED unw_word_t _Uia64_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg) { unw_word_t hdr_addr, info_addr, hdr, directives, pers, cookie, off; unw_word_t start_offset, end_offset, info_offset, segbase; struct ia64_table_entry *e; size_t table_size; unw_word_t gp = di->gp; int ret; switch (di->format) { case UNW_INFO_FORMAT_DYNAMIC: default: return 0; case UNW_INFO_FORMAT_TABLE: e = (struct ia64_table_entry *) di->u.ti.table_data; table_size = di->u.ti.table_len * sizeof (di->u.ti.table_data[0]); segbase = di->u.ti.segbase; if (table_size < sizeof (struct ia64_table_entry)) return 0; start_offset = e[0].start_offset; end_offset = e[0].end_offset; info_offset = e[0].info_offset; break; case UNW_INFO_FORMAT_REMOTE_TABLE: { unw_accessors_t *a = unw_get_accessors (as); unw_word_t e_addr = di->u.rti.table_data; table_size = di->u.rti.table_len * sizeof (unw_word_t); segbase = di->u.rti.segbase; if (table_size < sizeof (struct ia64_table_entry)) return 0; if ( (ret = remote_read (e_addr, start_offset) < 0) || (ret = remote_read (e_addr, end_offset) < 0) || (ret = remote_read (e_addr, info_offset) < 0)) return ret; } break; } if (start_offset != end_offset) /* dyn-list entry cover a zero-length "procedure" and should be first entry (note: technically a binary could contain code below the segment base, but this doesn't happen for normal binaries and certainly doesn't happen when libunwind is a separate shared object. For weird cases, the application may have to provide its own (slower) version of this routine. */ return 0; hdr_addr = info_offset + segbase; info_addr = hdr_addr + 8; /* read the header word: */ if ((ret = read_mem (as, hdr_addr, &hdr, arg)) < 0) return ret; if (IA64_UNW_VER (hdr) != 1 || IA64_UNW_FLAG_EHANDLER (hdr) || IA64_UNW_FLAG_UHANDLER (hdr)) /* dyn-list entry must be version 1 and doesn't have ehandler or uhandler */ return 0; if (IA64_UNW_LENGTH (hdr) != 1) /* dyn-list entry must consist of a single word of NOP directives */ return 0; if ( ((ret = read_mem (as, info_addr, &directives, arg)) < 0) || ((ret = read_mem (as, info_addr + 0x08, &pers, arg)) < 0) || ((ret = read_mem (as, info_addr + 0x10, &cookie, arg)) < 0) || ((ret = read_mem (as, info_addr + 0x18, &off, arg)) < 0)) return 0; if (directives != 0 || pers != 0 || (!as->big_endian && cookie != 0x7473696c2d6e7964ULL) || ( as->big_endian && cookie != 0x64796e2d6c697374ULL)) return 0; /* OK, we ran the gauntlet and found it: */ return off + gp; }
static int uvvp_vdec_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret=0; int i, j; //int recv_buf[256]; //int send_buf[256]; //int num = 0; // For UVVP_VDEC_TEST_VERSION_1 int reg_in = 0; int reg_out = 0; // For UVVP_VDEC_TEST_VERSION_2 int mem_sz = 1; UCHAR *p = NULL; unsigned int u4Align = 1024; unsigned int u4Size = 16384; unsigned char *buf_data; unsigned char *buf_data2; UINT32 u4RetValue; // For UVVP_VDEC_TEST_VERSION_3 struct termios settings; struct file *fd = 0; mm_segment_t oldfs; unsigned long crc = 0; unsigned long own_crc = 0; int frame_start = 0; int frame_end= 0; int file_num = 0; int file_len = 0; int read_len = 0; int tmp_buf[256]; // For speed measurement struct timeval tv1; struct timeval tv2; //struct file * pfilename; VDEC_PARAM_T *param; #if (VDEC_MVC_SUPPORT) VDEC_PARAM_T *param1; #endif printk("\r\n******** uvvp_vdec_ioctl cmd[%d]********\r\n",cmd); param = kmalloc(sizeof(VDEC_PARAM_T), GFP_KERNEL); #if (VDEC_MVC_SUPPORT) param1 = kmalloc(sizeof(VDEC_PARAM_T), GFP_KERNEL); #endif switch (cmd) { // General TEST CASE case UVVP_VDEC_TEST_VERSION: param->u4InstanceId = 0; param->u4Mode = 0; #if (VDEC_MVC_SUPPORT) param->fgMVCType = TRUE; #else param->fgMVCType = FALSE; #endif printk("\r\n******** uvvp_vdec_ioctl UVVP_VDEC_TEST_VERSION ********\r\n"); #if VDEC_VP8_WEBP_SUPPORT_ME2_INTEGRATION vVDecVerifyThread(param); vVerInitVDec(0); vVParserProc(0); vVDecProc(0); #if VP8_MB_ROW_MODE_SUPPORT_ME2_INTEGRATION while(1) { u4RetValue = vVerVP8DecEndProc_MB_ROW_START(0); if (u4RetValue == vVerResult_MB_ROW_DONE) { printk("\n\n======== MB ROW DONE!! ========\n\n"); } else if(u4RetValue == vVerResult_FRAME_DONE) { printk("\n\n======== FRAME DONE!! ========\n\n"); break; } else { printk("\n\n[ERROR]======== decode timeout!! ========\n\n"); break; } } vChkVDec_Webp_Row_Mode(0); #else vChkVDec(0); #endif #ifdef PCFILE_WRITE if(_tInFileInfo[param->u4InstanceId].pFile) { fclose(_tInFileInfo[param->u4InstanceId].pFile); } #endif vVerifyVDecIsrStop(param->u4InstanceId); vMemoryFree(param->u4InstanceId); #ifdef SATA_HDD_READ_SUPPORT #ifdef SATA_HDD_FS_SUPPORT if (_tFileListInfo[param->u4InstanceId].i4FileId != 0xFFFFFFFF) { // fgHDDFsCloseFile(u4InstID); // temp avoid system crash _tFileListInfo[param->u4InstanceId].i4FileId = 0xFFFFFFFF; } //FS mount fgHDDFsUnMount(0); #endif #endif #else MPV_thread = kthread_run(vVDecVerifyThread, param, "rt8192cu_rtw_xmit_thread"); if (IS_ERR(MPV_thread)) { printk("[%s]: failed to create MPV thread\n", __FUNCTION__); return 0; } else { printk("Creat mpv0 thread ok!\n"); } // break; // case UVVP_VDEC_TEST_VERSION_1: #if (VDEC_MVC_SUPPORT) param1->u4InstanceId = 1; param1->u4Mode = 0; param1->fgMVCType = TRUE; msleep(2); MPV_thread = kthread_run(vVDecVerifyThread, param1, "rt8192cu_rtw_xmit_thread"); if (IS_ERR(MPV_thread)) { printk("[%s]: failed to create MPV thread\n", __FUNCTION__); return 0; } else { printk("Creat mpv1 thread ok!\n"); } #endif #endif break; case UVVP_VDEC_TEST_VERSION_1: printk("UVVP_VDEC_TEST_VERSION_1\n"); reg_in = 0x1; reg_out = 0; MFV_HW_WRITE(VDEC_GCON_BASE, reg_in); reg_out = MFV_HW_READ(VDEC_GCON_BASE); printk("GCON write 0x%x, read 0x%x, %s\n", reg_in, reg_out, reg_in == reg_out ? "Pass":"******"); reg_in = 0xFFFFFFFF; reg_out = 0; MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1Y_ADD), reg_in); reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1Y_ADD)); printk("OFFSET_R1Y_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, Y_MASK, (reg_in & Y_MASK) == reg_out ? "Pass":"******"); reg_in = 0xFFFFFFFF; reg_out = 0; MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1C_ADD), reg_in); reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R1C_ADD)); printk("OFFSET_R1C_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, C_MASK, (reg_in & C_MASK) == reg_out ? "Pass":"******"); reg_in = 0xFFFFFFFF; reg_out = 0; MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2Y_ADD), reg_in); reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2Y_ADD)); printk("OFFSET_R2Y_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, Y_MASK, (reg_in & Y_MASK) == reg_out ? "Pass":"******"); reg_in = 0xFFFFFFFF; reg_out = 0; MFV_HW_WRITE((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2C_ADD), reg_in); reg_out = MFV_HW_READ((VDEC_BASE + MC_BASE_OFFSET + OFFSET_R2C_ADD)); printk("OFFSET_R2C_ADD write 0x%x, read 0x%x, mask 0x%x, %s\n", reg_in, reg_out, C_MASK, (reg_in & C_MASK) == reg_out ? "Pass":"******"); break; case UVVP_VDEC_TEST_VERSION_2: printk("UVVP_VDEC_TEST_VERSION_2\n"); printk("=== vmalloc memory speed test ===\n"); do_gettimeofday(&tv1); buf_data = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ); buf_data2 = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("Allocated %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); do_gettimeofday(&tv1); memset(buf_data, 0, TESTDATA_BUFFER_SZ); memset(buf_data2, 1, TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("memset %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); do_gettimeofday(&tv1); memcpy(buf_data, buf_data2, TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("memcpy %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); vfree(buf_data); vfree(buf_data2); printk("=== ioremap_nocache memory speed test ===\n"); do_gettimeofday(&tv1); buf_data = g_pu1AllocSA; buf_data2 = g_pu1AllocSA + TESTDATA_BUFFER_SZ; buf_data = ioremap_nocache(buf_data, TESTDATA_BUFFER_SZ); buf_data2 = ioremap_nocache(buf_data2, TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("ioremap %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); do_gettimeofday(&tv1); memset(buf_data, 0, TESTDATA_BUFFER_SZ); memset(buf_data2, 1, TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("memset %d + %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); do_gettimeofday(&tv1); memcpy(buf_data, buf_data2, TESTDATA_BUFFER_SZ); do_gettimeofday(&tv2); calc_time_diff(&tv1, &tv2); printk("memcpy %dMB in %d sec %d usec\n", TESTDATA_BUFFER_SZ/1024/1024, tv2.tv_sec, tv2.tv_usec); iounmap(buf_data); iounmap(buf_data2); printk("=== ioremap write test ===\n"); p = g_pu1AllocSA; p = ((UINT32)p + u4Align-1) & (~(u4Align - 1)); printk("p physical addr 0x%x\n", p); p = ioremap_nocache(p, u4Size); printk("p virtual addr 0x%x\n", p); *p = 'S'; *(p+u4Size-1) = 'E'; printk("p %c %c\n", *p, *(p+u4Size-1)); iounmap(p); /* while (1) { buf_data = (unsigned char *)vmalloc(mem_sz*1024*1024); if (buf_data != NULL) { vfree(buf_data); mem_sz = mem_sz + 1; printk("Memory size %dMB allocated!\n", mem_sz); } else { printk("Memory size %dMB failed to allocate\n", mem_sz); break; } } */ break; case UVVP_VDEC_TEST_VERSION_3: printk("UVVP_VDEC_TEST_VERSION_3\n"); buf_data = (unsigned char *)vmalloc(TESTDATA_BUFFER_SZ); if (0 == buf_data) { printk("Allocate %d bytes failed\n", TESTDATA_BUFFER_SZ); return 0; } oldfs = get_fs(); set_fs(KERNEL_DS); #ifdef USB_ACM_DMA1 printk("UVVP_VDEC_TEST_VERSION_3 Open /dev/usbacm\n"); fd = filp_open("/dev/usbacm", O_RDWR|O_NOCTTY|O_NDELAY, 0); if (fd == 0) { printk("Open /dev/usbacm failed\n"); return 0; } #else printk("UVVP_VDEC_TEST_VERSION_3 Open /dev/ttyGS0\n"); fd = filp_open("/dev/ttyGS0", O_RDWR, 0); if (fd == 0) { printk("Open /dev/ttyGS0 failed\n"); return 0; } fd->f_op->unlocked_ioctl(fd, TCGETS, (unsigned long)&settings); settings.c_cflag &= ~CBAUD; settings.c_cflag |= B921600; settings.c_cflag &= ~PARENB; settings.c_cflag &= ~CSTOPB; settings.c_cflag &= ~CSIZE; settings.c_cflag |= CS8 | CLOCAL | CREAD; settings.c_iflag &= ~(INLCR | ICRNL | IXON | IXOFF | IXANY); settings.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*raw input*/ settings.c_oflag &= ~OPOST; /*raw output*/ settings.c_cc[VMIN] = 0; settings.c_cc[VTIME] = 100; fd->f_op->unlocked_ioctl(fd, TCSETS, (unsigned long)&settings); #endif // Read CRC printk("Read CRC file\n"); file_num = remote_open(fd, "Z:\\1280x720_30_2000.ivf.crc", 27, "rb", 2); if (file_num < 0) { printk("Open CRC failed\n"); return 0; } file_len = remote_seek(fd, file_num, 0, SEEK_END); if (file_len < 0 || file_len > TESTDATA_BUFFER_SZ) { printk("CRC file too big %d\n", file_len); return 0; } remote_seek(fd, file_num, 0, SEEK_SET); read_len = remote_read(fd, file_num, &crc, sizeof(int)); if (read_len < file_len) { printk("Fail to read CRC file\n"); return 0; } remote_close(fd, file_num); // Read real file printk("Read Data file\n"); file_num = remote_open(fd, "Z:\\1280x720_30_2000.ivf", 23, "rb", 2); if (file_num < 0) { printk("Open data file failed\n"); return 0; } file_len = remote_seek(fd, file_num, 0, SEEK_END); if (file_len < 0 || file_len > TESTDATA_BUFFER_SZ) { printk("Data file too big %d\n", file_len); return 0; } remote_seek(fd, file_num, 0, SEEK_SET); memset(&tv1, 0, sizeof(struct timeval)); memset(&tv2, 0, sizeof(struct timeval)); printk("Start reading data\n"); do_gettimeofday(&tv1); read_len = remote_read(fd, file_num, buf_data, file_len); do_gettimeofday(&tv2); printk("End reading data\n"); printk("tv1 %d.%d, tv2 %d.%d \n", tv1.tv_sec, tv1.tv_usec, tv2.tv_sec, tv2.tv_usec); tv2.tv_sec -= tv1.tv_sec; if (tv2.tv_usec < tv1.tv_usec) { if (tv2.tv_sec < 1) printk("TIME ERROR\n"); tv2.tv_usec = tv2.tv_usec + 1000000 - tv1.tv_usec; tv2.tv_sec -= 1; } else { tv2.tv_usec -= tv1.tv_usec; } printk("Data len %d, elapsed time %d ms, avg speed %d bytes/ms\n", read_len, (tv2.tv_sec * 1000000 + tv2.tv_usec)/1000, read_len/((tv2.tv_sec * 1000000 + tv2.tv_usec)/1000)); if (read_len < file_len) { printk("Fail read data file exp. %d, read %d\n", file_len, read_len); return 0; } remote_close(fd, file_num); // CRC check own_crc = av_adler32_update(1, buf_data, 1, read_len); printk("own_crc 0x%08x, crc 0x%08x, %s\n", own_crc, crc, (own_crc == crc) ? "Pass":"******"); // Write file file_num = remote_open(fd, "D:\\Test.txt", 11, "wb", 2); if (file_num < 0) { printk("Open data file failed\n"); return 0; } for (i = 0; i < 256; i++) { tmp_buf[i] = i; } for (i = 0; i < 1024; i++) { memcpy(buf_data+(1024*i), (unsigned char *)&tmp_buf[0], 1024); } remote_write(fd, file_num, buf_data, 1024*1024); remote_close(fd, file_num); filp_close(fd, NULL); vfree(buf_data); /* _pucVFifo[0] = ioremap(0x8000000, 0x100000); memset(_pucVFifo[0] ,5,0x100000); printk("_pucVFifo = 0x%x\n", _pucVFifo[0]); printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0])); iounmap(_pucVFifo[0]); _pucVFifo[0] = ioremap(0x8000000, 0x100000); memset(_pucVFifo[0] ,5,0x100000); printk("_pucVFifo = 0x%x\n", _pucVFifo[0]); printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0])); iounmap(_pucVFifo[0]); _pucVFifo[0] = ioremap(0x8000000, 0x100000); memset(_pucVFifo[0] ,5,0x100000); printk("_pucVFifo = 0x%x\n", _pucVFifo[0]); printk("_pucVFifo m4u_v2p = 0x%x\n", m4u_v2p_new((unsigned int)_pucVFifo[0])); iounmap(_pucVFifo[0]); */ break; case UVVP_VDEC_TEST_VERSION_4: initKernelEnv(); fd = openFile("/etc/frame_num",O_RDONLY,0); if (IS_ERR(fd) ) printk("[Error] Miss file: input arg file!!!!!!!!!!!!!\n"); else readFile(fd ,tmp_buf, 256 ); closeFile(fd); set_fs( oldfs ); sscanf ( tmp_buf, "%i %i %i %i %i %s %i %i" , &frame_start, &frame_end, &width, &height, &debug_mode, bitstream_name, &error_rate, &UFO_MODE); hevc_test( frame_start, frame_end); break; default: break; } //printk("\r\n******** uvvp_vdec_ioctl done********\r\n"); return 0; }