int main(int argc, char **argv)
{
DATA *pmstr;
int size = 10*22; // 5组数据的大小为220字节
int len = 0;
char *str = "hello";
int i = 0;
if (argc < 2) {
printf("useage:exec filename\n");
exit(1);
}
// show page size
Pagesize();
pmstr = map_memory(argv[1], size);
while (1) {
if ( len >= size )
break;
memcpy(pmstr->data1, str, 5);
memcpy(pmstr->data2, str, 5);
pmstr->len = i;
i++;
len += sizeof(DATA);
printf("i: %d, len: %d\n", pmstr->len, len);
pmstr++;
sleep(1);
}
munmap(pmstr, size);
return 0;
}
void init_shared_memory(void)
{
virt_addr = map_memory(MAP_ADDRESS); //16K space
shmem_info_p = (struct shmem_info *) virt_addr;
PX4_DEBUG("linux memory mapped");
}
void init_shared_memory(void)
{
//PX4_INFO("Value at lock address is %d\n", *(unsigned int*)0xfbfc000);
virt_addr = map_memory(MAP_ADDRESS);
shmem_info_p = (struct shmem_info *)virt_addr;
//PX4_INFO("adsp memory mapped\n");
}
int main(int argc, char** argv)
{
void *grp_regs = map_memory("/dev/hw3d", 0, 1024 * 1024);
printf("GPU base mapped at %p\n", grp_regs);
int state_offset = 0x10140;
printf("GPU state = %08lx\n",
*((long*)((char*)grp_regs + state_offset)) );
return 0;
}
/*
* Class: sharedmemory_SharedMemory
* Method: map_memory
* Signature: (Ljava/lang/String;J)Ljava/nio/ByteBuffer;
*/
JNIEXPORT jobject JNICALL Java_sharedmemory_SharedMemory_map_1memory
(JNIEnv *env, jobject obj, jstring descriptor, jlong size) {
jobject ret = NULL;
char* memory;
const char* desc = (*env)->GetStringUTFChars( env, descriptor , NULL ) ;
memory = map_memory(desc, size);
ret = (*env)->NewDirectByteBuffer(env, (void*) memory, size);
(*env)->ReleaseStringUTFChars(env, descriptor ,desc);
return ret;
}
int main(int argc, char** argv)
{
int i;
uint64_t base = 0;
unsigned char *mmio, *stash;
if (iopl(3) < 0) {
fprintf(stderr, "Failed to gain ioperm: %s\n",
strerror(errno));
exit(1);
}
for (i=0; i<4; i++) {
outb(0x24 + i, 0xcd6);
base |= (unsigned) inb(0xcd7) << (8*i);
}
if ((base & 0x03) != 0x01) {
printf("ACPI MMIO disabled\n");
exit(1);
} else {
base &= ~0xfff;
printf("ACPI MMIO enabled at %08lx\n", base);
}
fd = open("/dev/mem", O_RDONLY, 0);
if (fd < 0) {
fprintf(stderr, "Failed to gain memory access: %s\n",
strerror(errno));
exit(1);
}
mmio = map_memory(base);
stash = calloc(1, MMIO_REGION_SZ);
if (mmio == NULL || stash == NULL)
exit(1);
for (i=0; i<MMIO_REGION_SZ; i++) {
stash[i] = mmio[i];
}
unmap_memory();
close(fd);
FILE * dd = fopen("mmio_dump.dd", "w");
fwrite(stash, MMIO_REGION_SZ, 1, dd);
fclose(dd);
exit(0);
}
static void flush_kernel_vm_range(unsigned long start, unsigned long end,
int update_seq)
{
struct mm_struct *mm;
pgd_t *pgd;
pmd_t *pmd;
pte_t *pte;
unsigned long addr;
int updated = 0, err;
mm = &init_mm;
for(addr = start; addr < end;){
pgd = pgd_offset(mm, addr);
pmd = pmd_offset(pgd, addr);
if(pmd_present(*pmd)){
pte = pte_offset_kernel(pmd, addr);
if(!pte_present(*pte) || pte_newpage(*pte)){
updated = 1;
err = os_unmap_memory((void *) addr,
PAGE_SIZE);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
if(pte_present(*pte))
map_memory(addr,
pte_val(*pte) & PAGE_MASK,
PAGE_SIZE, 1, 1, 1);
}
else if(pte_newprot(*pte)){
updated = 1;
protect_memory(addr, PAGE_SIZE, 1, 1, 1, 1);
}
addr += PAGE_SIZE;
}
else {
if(pmd_newpage(*pmd)){
updated = 1;
err = os_unmap_memory((void *) addr, PMD_SIZE);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
}
addr += PMD_SIZE;
}
}
if(updated && update_seq) atomic_inc(&vmchange_seq);
}
blargg_err_t Nsf_Impl::start_track( int track )
{
int speed_flags = 0;
#if NSF_EMU_EXTRA_FLAGS
speed_flags = header().speed_flags;
#endif
apu.reset( header().pal_only(), (speed_flags & 0x20) ? 0x3F : 0 );
apu.enable_w4011_( enable_w4011 );
apu.write_register( 0, 0x4015, 0x0F );
apu.write_register( 0, 0x4017, (speed_flags & 0x10) ? 0x80 : 0 );
// Clear memory
memset( unmapped_code(), Nes_Cpu::halt_opcode, unmapped_size );
memset( low_ram, 0, low_ram_size );
memset( sram(), 0, sram_size );
map_memory();
// Arrange time of first call to play routine
play_extra = 0;
next_play = play_period;
play_delay = initial_play_delay;
saved_state.pc = idle_addr;
// Setup for call to init routine
cpu.r.a = track;
cpu.r.x = header_.pal_only();
cpu.r.sp = 0xFF;
jsr_then_stop( header_.init_addr );
if ( cpu.r.pc < get_addr( header_.load_addr ) )
set_warning( "Init address < load address" );
return blargg_ok;
}
void lin_webcam_impl::open()
{
do_open();
set_video_settings();
map_memory();
}
void flush_tlb_kernel_range_skas(unsigned long start, unsigned long end)
{
struct mm_struct *mm;
pgd_t *pgd;
pud_t *pud;
pmd_t *pmd;
pte_t *pte;
unsigned long addr, last;
int updated = 0, err;
mm = &init_mm;
for(addr = start; addr < end;){
pgd = pgd_offset(mm, addr);
pud = pud_offset(pgd, addr);
pmd = pmd_offset(pud, addr);
if(!pgd_present(*pgd)){
if(pgd_newpage(*pgd)){
updated = 1;
last = addr + PGDIR_SIZE;
if(last > end)
last = end;
err = os_unmap_memory((void *) addr,
last - addr);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
}
addr += PGDIR_SIZE;
continue;
}
pud = pud_offset(pgd, addr);
if(!pud_present(*pud)){
if(pud_newpage(*pud)){
updated = 1;
last = addr + PUD_SIZE;
if(last > end)
last = end;
err = os_unmap_memory((void *) addr,
last - addr);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
}
addr += PUD_SIZE;
continue;
}
pmd = pmd_offset(pud, addr);
if(!pmd_present(*pmd)){
if(pmd_newpage(*pmd)){
updated = 1;
last = addr + PMD_SIZE;
if(last > end)
last = end;
err = os_unmap_memory((void *) addr,
last - addr);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
}
addr += PMD_SIZE;
continue;
}
pte = pte_offset_kernel(pmd, addr);
if(!pte_present(*pte) || pte_newpage(*pte)){
updated = 1;
err = os_unmap_memory((void *) addr, PAGE_SIZE);
if(err < 0)
panic("munmap failed, errno = %d\n", -err);
if(pte_present(*pte))
map_memory(addr, pte_val(*pte) & PAGE_MASK,
PAGE_SIZE, 1, 1, 1);
}
else if(pte_newprot(*pte)){
updated = 1;
protect_memory(addr, PAGE_SIZE, 1, 1, 1, 1);
}
addr += PAGE_SIZE;
}
}
static void fix_range(struct mm_struct *mm, unsigned long start_addr,
unsigned long end_addr, int force)
{
pgd_t *npgd;
pmd_t *npmd;
pte_t *npte;
unsigned long addr;
int r, w, x, err;
if((current->thread.mode.tt.extern_pid != -1) &&
(current->thread.mode.tt.extern_pid != os_getpid()))
panic("fix_range fixing wrong address space, current = 0x%p",
current);
if(mm == NULL) return;
for(addr=start_addr;addr<end_addr;){
if(addr == TASK_SIZE){
/* Skip over kernel text, kernel data, and physical
* memory, which don't have ptes, plus kernel virtual
* memory, which is flushed separately, and remap
* the process stack. The only way to get here is
* if (end_addr == STACK_TOP) > TASK_SIZE, which is
* only true in the honeypot case.
*/
addr = STACK_TOP - ABOVE_KMEM;
continue;
}
npgd = pgd_offset(mm, addr);
npmd = pmd_offset(npgd, addr);
if(pmd_present(*npmd)){
npte = pte_offset_kernel(npmd, addr);
r = pte_read(*npte);
w = pte_write(*npte);
x = pte_exec(*npte);
if(!pte_dirty(*npte)) w = 0;
if(!pte_young(*npte)){
r = 0;
w = 0;
}
if(force || pte_newpage(*npte)){
err = os_unmap_memory((void *) addr,
PAGE_SIZE);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
if(pte_present(*npte))
map_memory(addr,
pte_val(*npte) & PAGE_MASK,
PAGE_SIZE, r, w, x);
}
else if(pte_newprot(*npte)){
protect_memory(addr, PAGE_SIZE, r, w, x, 1);
}
*npte = pte_mkuptodate(*npte);
addr += PAGE_SIZE;
}
else {
if(force || pmd_newpage(*npmd)){
err = os_unmap_memory((void *) addr, PMD_SIZE);
if(err < 0)
panic("munmap failed, errno = %d\n",
-err);
pmd_mkuptodate(*npmd);
}
addr += PMD_SIZE;
}
}
}
int main (int argc, char *argv[])
{
int ret, i;
pthread_t recv_thread;
struct timeval tv;
int nSendBufLen = 256*1024;
if (signal(SIGPIPE, sig_pipe) == SIG_ERR)
{
fprintf(stderr, "can't catch SIGPIPE\n");
exit(1);
}
/* if (signal(SIGQUIT, sig_quit) == SIG_ERR)
{
fprintf(stderr, "can't catch SIGQUIT\n");
exit(1);
}
*/
pthread_mutex_init(&dac_lock, NULL);
pthread_mutex_init(&adc_lock, NULL);
pthread_mutex_init(&lock, NULL);
/**
* Memory Mapping
*/
adc_mem_addr = map_memory(S2MM_DST_ADDR, S2MM_BUF_SIZE);
memset(adc_mem_addr, 0x0, S2MM_BUF_SIZE);
dac_mem_addr = map_memory(MM2S_SRC_ADDR, MM2S_BUF_SIZE);
memset(dac_mem_addr, 0, MM2S_BUF_SIZE);
dma_reg_addr_wr = map_memory(AXI_DMA_BASE_WR, REG_SIZE);
dma_reg_addr_rd = map_memory(AXI_DMA_BASE_RD, REG_SIZE);
/*snowleo lms6002 clock set*/
snowleo_sdr_set_clock(I2C_DEV);
/*snowleo lms6002 spi init*/
spi_fd = snowleo_sdr_spi_init(SPI_DEV);
transfer(spi_fd);
/**
* Simple ring buffer
*/
p = (struct ring_buf *)malloc(sizeof(struct ring_buf));
p->front=p->rear=0;
for(i = 0; i < MaxSize; i++)
p->data[i] = dac_mem_addr + (i * BUFFER_MAX_SIZE);
/**
* Tcp server
* TODO Support two client connections, one to do the receiving, one to do transmitting
*/
if((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
{
perror("fail to socket!");
exit(-1);
}
bzero(&myaddr, sizeof(myaddr));
myaddr.sin_family = PF_INET;
myaddr.sin_port = htons(8000);
myaddr.sin_addr.s_addr = htons(INADDR_ANY);
if(bind(listenfd, (SA *)&myaddr, sizeof(myaddr)) < 0)
{
perror("fail to bind!");
exit(-1);
}
listen(listenfd, 1);
while(1)
{
if((connfd = accept(listenfd, (SA *)&peeraddr, &peerlen)) < 0)
{
perror("fail to accept!");
exit(-1);
}
#if 1
tv.tv_sec = 10;
tv.tv_usec = 0;
#define RECV_TIMEOUT
#ifdef RECV_TIMEOUT
setsockopt(connfd, SOL_SOCKET, SO_RCVTIMEO|SO_SNDTIMEO, &tv, sizeof(tv));
#else
setsockopt(connfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
#endif
setsockopt(connfd, SOL_SOCKET, SO_SNDBUF, (const char *)&nSendBufLen, sizeof(int) );
#endif
dma_dbg(MSG_DEBUG,"Connection from [%s:%d]\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
//sprintf(file_name, "/mnt/%d.dat", ntohs(peeraddr.sin_port));
ret = pthread_create(&recv_thread, NULL, &thread_recv_func, NULL);
if (ret)
{
dma_dbg(MSG_ERROR,"ERROR; return code from pthread_create() is %d\n", ret);
return -1;
}
pthread_join(recv_thread,NULL);
memset((unsigned char *)cmd_buff, 0, sizeof(unsigned int)*2);
dma_dbg(MSG_DEBUG,"Connection from [%s:%d] is closed\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
close(connfd);
}
return 0;
}
