void si5338_complete_transfer( uint8_t check_rxack ) { if( (IORD_8DIRECT(I2C, OC_I2C_CMD_STATUS)&OC_I2C_TIP) == 0 ) { while( (IORD_8DIRECT(I2C, OC_I2C_CMD_STATUS)&OC_I2C_TIP) == 0 ) { } ; } while( IORD_8DIRECT(I2C, OC_I2C_CMD_STATUS)&OC_I2C_TIP ) { } ; while( check_rxack && IORD_8DIRECT(I2C, OC_I2C_CMD_STATUS)&OC_I2C_RXACK ) { } ; }
static void readDat(){ unsigned short accumulatedData = 0; int i; copyController(&prev_controller_state, controller_state); IOWR_8DIRECT(controller_out, 0, 0x01); IOWR_8DIRECT(controller_out, 0, 0x03); alt_busy_sleep(12); IOWR_8DIRECT(controller_out, 0, 0x01); alt_busy_sleep(6); accumulatedData = IORD_8DIRECT(controller_in, 0); for (i = 0; i < 16; i++) { IOWR_8DIRECT(controller_out, 0, 0x00); alt_busy_sleep(6); accumulatedData <<= 1; accumulatedData += IORD_8DIRECT(controller_in, 0); IOWR_8DIRECT(controller_out, 0, 0x01); // Pulse clock alt_busy_sleep(6); } IOWR_8DIRECT(leds, 0, accumulatedData); copyController(&controller_state, getControllerButtons(accumulatedData)); }
int check_switches() // FUNCTION: Reads the value of all switches // RETURNS: Value of all switches { return IORD_8DIRECT(SWITCHES_BASE, 0); }
static int alt_unlock_block_intel(alt_flash_cfi_dev* flash, int block_offset) { alt_u8 locked; alt_u8 status; int ret_code = 0; int timeout = flash->write_timeout * 100; /* * Is this block locked? */ flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0x90); locked = IORD_8DIRECT(flash->dev.base_addr, block_offset + 4); if (locked & 0x1) { flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0x60); flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0xD0); do { status = IORD_8DIRECT(flash->dev.base_addr, block_offset); if (status & 0x80) { break; } timeout--; usleep(1); }while(timeout > 0); if (timeout == 0) { ret_code = -ETIMEDOUT; } else if (status & 0x7f) { /* If we have an error of some kind bomb out */ ret_code = -EIO; } } /* * Back to Read Array mode */ flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0xFF); return ret_code; }
/* * alt_erase_block_intel * * Erase the selected erase block */ int alt_erase_block_intel(alt_flash_dev* flash_info, int block_offset) { int ret_code = 0; alt_flash_cfi_dev* flash = (alt_flash_cfi_dev*)flash_info; volatile alt_u8 status; int timeout = flash->erase_timeout; /* * If this block is locked then unlock it */ ret_code = alt_unlock_block_intel(flash, block_offset); if (!ret_code) { flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0x20); flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0xD0); do { status = IORD_8DIRECT(flash->dev.base_addr, block_offset); if (status & 0x80) { break; } usleep(1); timeout--; }while(timeout > 0); if (timeout == 0) { ret_code = -ETIMEDOUT; } else if (status & 0x7f) { /* If we have an error of some kind bomb out */ ret_code = -EIO; status = IORD_8DIRECT(flash->dev.base_addr, block_offset); } /* Put the device back into read array mode */ flash->write_native((alt_u8*)flash->dev.base_addr + block_offset, 0xFF); } return ret_code; }
/****************************************************************** * Function: main * * Purpose: Continually prints the menu and performs the actions * requested by the user. * ******************************************************************/ int main( void ) { unsigned char ImageData; int i; struct BitMapFileHeader header1; struct BitMapInfoHeader header2; unsigned int Offset; FILE * UartFile; if( ( UartFile = fopen ( "/dev/uart1", "r" ) ) == NULL ) { printf( "Uart open failed!\n" ); return 0; } // waiting for input data while( ( ImageData = fgetc( UartFile ) ) == EOF ); printf( "PC -> Target..............\n" ); for( i = 0, Offset = SDRAM_BASE; i < TotalMemory; i ++, Offset ++ ) { fscanf( UartFile, "%x", &ImageData ); IOWR_8DIRECT( SDRAM_BASE, Offset, ImageData ); } printf( "PC -> Target done\n" ); for( i = 0, Offset = SDRAM_BASE; i < TotalMemory; i ++, Offset ++ ) { ImageData = IORD_8DIRECT( SDRAM_BASE, Offset ); if( 0 == i % 16 ) printf( "\n" ); fprintf( stdout, "%02X ", ImageData ); } printf( "\nDone\n" ); fclose( UartFile ); return 0; }
int main() { printf("Hello from cpu_3!\n"); alt_mutex_dev* mutex = altera_avalon_mutex_open( "/dev/mutex_1" ); while(TRUE) { altera_avalon_mutex_lock( mutex, 1 ); if (IORD_8DIRECT(FLAG,0) == 1) { value=IORD_8DIRECT(VALUE,0); printf("Reading from shared memory (safe): %d\n",value); IOWR_8DIRECT(VALUE,0,++value); IOWR_8DIRECT(FLAG,0,0); printf("\tWriting to shared memory (safe): %d\n",value); } altera_avalon_mutex_unlock( mutex ); delay(10); } return 0; }
int main() { unsigned char i,j; int temp; for(i=0;i<100;i++) IOWR_8DIRECT(SDRAM_U1_BASE,i,i); IOWR(SDRAM_MASTER_INST_BASE,S_ADDR,SDRAM_U1_BASE); IOWR(SDRAM_MASTER_INST_BASE,D_ADDR,SDRAM_U2_BASE); IOWR(SDRAM_MASTER_INST_BASE,LONGTH,100); IOWR(SDRAM_MASTER_INST_BASE,START_ADDR,1); temp=IORD(SDRAM_MASTER_INST_BASE,S_ADDR); printf("S_ADDR:w,r==%d,%d\n",SDRAM_U1_BASE,temp); temp=IORD(SDRAM_MASTER_INST_BASE,D_ADDR); printf("D_ADDR:w,r==%d,%d\n",SDRAM_U2_BASE,temp); temp=IORD(SDRAM_MASTER_INST_BASE,LONGTH); printf("LONGTH:w,r==%d,%d\n",100,temp); while(IORD(SDRAM_MASTER_INST_BASE,STATUS_ADDR)!=1){ printf("waiting...!\n"); //break; }; for(i=0;i<100;i++){ j=IORD_8DIRECT(SDRAM_U1_BASE,i); printf("SDRAM_U1:i,j == %d, %d\n",i,j); } for(i=0;i<100;i++){ j=IORD_8DIRECT(SDRAM_U2_BASE,i); printf("SDRAM_U2:i,j == %d, %d\n",i,j); } printf("Hello from Nios II!\n"); return 0; }
/* * get_board_mac_addr * * Read the MAC address in a board specific way * */ error_t get_board_mac_addr(unsigned char mac_addr[6]) { error_t error = 0; alt_u32 signature; /* Get the flash sector with the MAC address. */ error = FindLastFlashSectorOffset(&last_flash_sector_offset); if (!error) last_flash_sector = CFI_FLASH_BASE + last_flash_sector_offset; else printf ("Could not locate flash sector with MAC address.\n"); /* This last_flash_sector region of flash is examined to see if * valid network settings are present, indicated by a signature of 0x00005afe at * the first address of the last flash sector. This hex value is chosen as the * signature since it looks like the english word "SAFE", meaning that it is * safe to use these network address values. */ ///* if (!error) { signature = IORD_32DIRECT(last_flash_sector, 0); if (signature != 0x00005afe) { error = generate_and_store_mac_addr(); } } //*/ // mac_addr[0] = 0x00; // mac_addr[1] = 0x07; // mac_addr[2] = 0xed; // mac_addr[3] = 0x12; // mac_addr[4] = 0x8f; // mac_addr[5] = 0xff; if (!error) { mac_addr[0] = IORD_8DIRECT(last_flash_sector, 4); mac_addr[1] = IORD_8DIRECT(last_flash_sector, 5); mac_addr[2] = IORD_8DIRECT(last_flash_sector, 6); mac_addr[3] = IORD_8DIRECT(last_flash_sector, 7); mac_addr[4] = IORD_8DIRECT(last_flash_sector, 8); mac_addr[5] = IORD_8DIRECT(last_flash_sector, 9); printf("Your Ethernet MAC address is %02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); } return error; }
void si5338_read( uint8_t addr, uint8_t *data ) { // Set the address to the Si5338 IOWR_8DIRECT(I2C, OC_I2C_DATA, SI5338_I2C ) ; IOWR_8DIRECT(I2C, OC_I2C_CMD_STATUS, OC_I2C_STA | OC_I2C_WR ) ; si5338_complete_transfer( 1 ) ; IOWR_8DIRECT(I2C, OC_I2C_DATA, addr ) ; IOWR_8DIRECT(I2C, OC_I2C_CMD_STATUS, OC_I2C_WR | OC_I2C_STO ) ; si5338_complete_transfer( 1 ) ; // Next transfer is a read operation, so '1' in the read/write bit IOWR_8DIRECT(I2C, OC_I2C_DATA, SI5338_I2C | 1 ) ; IOWR_8DIRECT(I2C, OC_I2C_CMD_STATUS, OC_I2C_STA | OC_I2C_WR ) ; si5338_complete_transfer( 1 ) ; IOWR_8DIRECT(I2C, OC_I2C_CMD_STATUS, OC_I2C_RD | OC_I2C_NACK | OC_I2C_STO ) ; si5338_complete_transfer( 0 ) ; *data = IORD_8DIRECT(I2C, OC_I2C_DATA) ; return ; }
//------------------------------------------------------------------------------ int target_lock(void) { alt_u8 val; if (pLock_l == NULL) return -1; // spin if id is not written to shared memory do { val = IORD_8DIRECT(pLock_l, 0); // write local id if unlocked if (val == LOCK_UNLOCKED_C) { IOWR_8DIRECT(pLock_l, 0, LOCK_LOCAL_ID); continue; // return to top of loop to check again } } while (val != LOCK_LOCAL_ID); return 0; }
int alt_write_word_intel( alt_flash_cfi_dev* flash, const int offset, const alt_u8* src_addr) { int ret_code = 0; alt_u8 status; (*flash->write_native)((alt_u8*)flash->dev.base_addr+offset, 0x40); alt_write_value_to_flash(flash, offset, src_addr); do { status = IORD_8DIRECT(flash->dev.base_addr, offset); }while(!(status & 0x80)); /* If we have an error of some kind bomb out */ if (status & 0x7f) { ret_code = -EIO; } /* Put the device back into read array mode */ flash->write_native((alt_u8*)flash->dev.base_addr + offset, 0xFF); return ret_code; }
/* * get_board_mac_addr * * Read the MAC address in a board specific way * */ error_t get_board_mac_addr(unsigned char mac_addr[6]) { error_t error = 0; alt_u32 signature; alt_u32 mac_addr_ptr = EXT_FLASH_BASE + ETHERNET_OPTION_BITS; /* This last_flash_sector region of flash is examined to see if * valid network settings are present, indicated by a signature of 0x00005afe at * the first address of the last flash sector. This hex value is chosen as the * signature since it looks like the english word "SAFE", meaning that it is * safe to use these network address values. */ /* Get the flash sector with the MAC address. */ signature = IORD_32DIRECT(mac_addr_ptr, 0); if (signature != 0x00005afe) { error = generate_and_store_mac_addr(); } if (!error) { mac_addr[0] = IORD_8DIRECT(mac_addr_ptr, 4); mac_addr[1] = IORD_8DIRECT(mac_addr_ptr, 5); mac_addr[2] = IORD_8DIRECT(mac_addr_ptr, 6); mac_addr[3] = IORD_8DIRECT(mac_addr_ptr, 7); mac_addr[4] = IORD_8DIRECT(mac_addr_ptr, 8); mac_addr[5] = IORD_8DIRECT(mac_addr_ptr, 9); printf("Your Ethernet MAC address is %02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); } return error; }
/****************************************************************** * Function: MemTest8_16BitAccess * * Purpose: Tests that the memory at the specified base address * can be read and written in both byte and half-word * modes. * ******************************************************************/ static int MemTest8_16BitAccess(unsigned int memory_base) { int ret_code = 0x0; /* Write 4 bytes */ IOWR_8DIRECT(memory_base, 0, 0x0A); IOWR_8DIRECT(memory_base, 1, 0x05); IOWR_8DIRECT(memory_base, 2, 0xA0); IOWR_8DIRECT(memory_base, 3, 0x50); /* Read it back as one word */ if(IORD_32DIRECT(memory_base, 0) != 0x50A0050A) { ret_code = memory_base; } /* Read it back as two half-words */ if (!ret_code) { if ((IORD_16DIRECT(memory_base, 2) != 0x50A0) || (IORD_16DIRECT(memory_base, 0) != 0x050A)) { ret_code = memory_base; } } /* Read it back as 4 bytes */ if (!ret_code) { if ((IORD_8DIRECT(memory_base, 3) != 0x50) || (IORD_8DIRECT(memory_base, 2) != 0xA0) || (IORD_8DIRECT(memory_base, 1) != 0x05) || (IORD_8DIRECT(memory_base, 0) != 0x0A)) { ret_code = memory_base; } } /* Write 2 half-words */ if (!ret_code) { IOWR_16DIRECT(memory_base, 0, 0x50A0); IOWR_16DIRECT(memory_base, 2, 0x050A); /* Read it back as one word */ if(IORD_32DIRECT(memory_base, 0) != 0x050A50A0) { ret_code = memory_base; } } /* Read it back as two half-words */ if (!ret_code) { if ((IORD_16DIRECT(memory_base, 2) != 0x050A) || (IORD_16DIRECT(memory_base, 0) != 0x50A0)) { ret_code = memory_base; } } /* Read it back as 4 bytes */ if (!ret_code) { if ((IORD_8DIRECT(memory_base, 3) != 0x05) || (IORD_8DIRECT(memory_base, 2) != 0x0A) || (IORD_8DIRECT(memory_base, 1) != 0x50) || (IORD_8DIRECT(memory_base, 0) != 0xA0)) { ret_code = memory_base; } } return(ret_code); }
int main() { int i,k,ipl_mode=1; //UINT r; // Initialize Disk I/F and ROM System_Initialize(); /* Event loop never exits. */ while (1){ // IPL if(ipl_mode==1){ // System Program Load IPL(); // Start MZ MZ_release(); ipl_mode=0; } // CMT Control if((z80_sts.status&S_CMT)==S_CMT){ z80_sts.status&=~S_CMT; // Eject and Set Tape if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_OPEN)==C_OPEN){ IOWR_8DIRECT(REG_BASE, MZ_CMT_STATUS, C_OPEN); tape_unmount(); fname[0]='\0'; key0(settape); z80_sts.status|=S_FBTN; // Set Flag MZ_Brequest(); menu_process(); MZ_Brelease(); z80_sts.status&=~S_FBTN; // Clear Flag } // Load if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_PLAY)==C_PLAY){ IOWR_8DIRECT(REG_BASE, MZ_CMT_STATUS, C_PLAY); IOWR_8DIRECT(REG_BASE, MZ_CMT_CTRL, C_MTON+C_TAPE); // Motor On cmtload(); } // Rewind if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_REW)==C_REW){ if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_APSS)==C_APSS){ apss_r(); } else { tape_rewind(); IOWR_8DIRECT(REG_BASE, MZ_CMT_STATUS, C_REW); } } // F.Forward if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_FF)==C_FF){ if((IORD_8DIRECT(REG_BASE, MZ_CMT_STATUS)&C_APSS)==C_APSS){ apss_f(); } else { IOWR_8DIRECT(REG_BASE, MZ_CMT_STATUS, C_FF); } } } // Function Button if((z80_sts.status&S_FBTN)==S_FBTN){ MZ_Brequest(); menu_process(); MZ_Brelease(); z80_sts.status&=~S_FBTN; } // BST check if((IORD_8DIRECT(REG_BASE, MZ_SYS_STATUS)&S_BST)==S_BST){ ipl_mode=1; } // Quick Load/Save // if((z80_sts.status&0x02)==0x02){ // if(IORD(CMT_0_BASE, 3)==0x0f){ // CMD is Load // IOWR(CMT_0_BASE, 2, 0x80); // set STAT busy // Wait for confirm busy by Z80 // while(IORD(CMT_0_BASE, 3)!=0); // if(tname[0]=='\0'){ // if tape file is empty // z80_sts.status=0x03; // // Z80-Bus request // MZ_Brequest(); // key0(settape); // k=menu(0,0,0); // Root menu // // Z80-Bus release // MZ_Brelease(); // z80_sts.status=0x02; // if(k!=10){ // z80_sts.status=0; // IOWR(CMT_0_BASE, 2, 0xff); // set STAT error // continue; // } // //keybuf_clear(); // strcpy(tname, fname); // IOWR(CMT_0_BASE, 1, 1); // ql_pt=0; // } // quick_load(); // IOWR(CMT_0_BASE, 2, 0); // set STAT free // z80_sts.status&=0xfffffffd; // } // if(IORD(CMT_0_BASE, 3)==0xf0){ // CMD is Save // IOWR(CMT_0_BASE, 2, 0x80); // set STAT busy // // Wait for confirm busy by Z80 // while(IORD(CMT_0_BASE, 3)!=0); // if(tname[0]=='\0'){ // if tape file is empty // // Z80-Bus request // MZ_Brequest(); // i=input_file_name(); // // Z80-Bus release // MZ_Brelease(); // if(tname[0]=='\0'||i<0){ // z80_sts.status=0; // IOWR(CMT_0_BASE, 2, 0xff); // set STAT error // continue; // } // keybuf_clear(); // IOWR(CMT_0_BASE, 1, 1); // } // if(quick_save()!=FR_OK) // IOWR(CMT_0_BASE, 2, 0xff); // set STAT error // else // IOWR(CMT_0_BASE, 2, 0); // set STAT free // z80_sts.status&=0xfffffffd; // } // } } return 0; }
/* * IPL Emulation */ void IPL(void) { UINT size,record,i,silent_boot,l_track; int length; unsigned char k; // Enter Boot Mode MZ_BOOT(); MZ_cls(); fname[0]='\0'; // disk already exists if(dname[0][0]=='\0') silent_boot=0; else silent_boot=1; if(IORD_8DIRECT(REG_BASE, MZ_SYS_SW70)&0x10){ IPL_from_tape(); } else { // Boot from FD or CMT if(silent_boot==0){ MZ_msg(10,0,"Make Ready FD"); } while(1){ if(silent_boot==0){ MZ_msg(10,2,"Press F or C"); MZ_msg(11,4,"F:Floppy Disk"); if(!(IORD_8DIRECT(REG_BASE, MZ_SYS_SW98)&0x2)) MZ_msg(24,4,"ette"); MZ_msg(11,5,"C:Cassette Tape"); } while(1){ if(silent_boot==0){ if((z80_sts.status&S_FBTN)==S_FBTN){ SaveVRAM(); menu_process(); z80_sts.status&=~S_FBTN; // Clear Flag RestoreVRAM(); } k=get_key(); }else{ k='F'; } if((k&'C')=='C'){ if(IPL_from_tape()==0) return; else break; } if((k&'F')=='F'){ if(silent_boot==0){ MZ_cls(); MZ_msg(10,2,"Drive No? (1-4)"); do{ k=get_key(); }while(k<'1' || k>'4'); MZ80B_MEM(0x7fec)=k-'1'; if((k=='1'&&dname[0][0]=='\0')||(k=='2'&&dname[1][0]=='\0')||k=='3'||k=='4'){ MZ_cls(); MZ_msg(10,0,"Loading error"); break; } }else{ k='1'; } read_1sector(k-'1', 0, &MZ80B_MEM(0x4f00), &l_track); if(MZ80B_MEM(0x4f00)==0x01&&strncmp((char *)&MZ80B_MEM(0x4f01), "IPLPRO", 6)==0){ MZ_cls(); MZ_msg(0,0,"IPL is loading "); MZ_msgx(16,0,(char *)&MZ80B_MEM(0x4f07),10); size=(MZ80B_MEM(0x4f15)<<8)+MZ80B_MEM(0x4f14); record=(MZ80B_MEM(0x4f1f)<<8)+MZ80B_MEM(0x4f1e); for(i=0;i<size;i+=length){ length=read_1sector(k-'1', record++, &MZ80B_MEM(i), &l_track); if(length<0) break; } if(length>0){ d_tnum[k-'1']=l_track/2; track_setting(k-'1', l_track/2); return; } } MZ_cls(); MZ_msg(7,0,"This disk is not master"); silent_boot=0; break; } } } } }
/* * IPL Emulation(CMT only) */ int IPL_from_tape(void) { UINT size; unsigned char k; MZ_cls(); t_block=0; // Select Tape file if(tname[0]=='\0'){ MZ_msg(10,0,"Make Ready CMT"); do{ k=get_key(); if((k&'C')=='C'){ key0(settape); z80_sts.status|=S_FBTN; // Set Flag }else if(k==0x1b&&!(IORD_8DIRECT(REG_BASE, MZ_SYS_SW70)&0x10)){ return -1; }else if((z80_sts.status&S_FBTN)!=S_FBTN){ continue; } SaveVRAM(); menu_process(); z80_sts.status&=~S_FBTN; // Clear Flag RestoreVRAM(); }while(fname[0]=='\0'); tape_mount(); } while(1){ // File Read MZ_msg(4,0,"IPL is looking for a program"); usleep(500000); tape_rdinf_bulk(&MZ80B_MEM(0x4f00)); MZ_cls(); MZ_msg(0,0,"IPL is loading "); MZ_msgx(16,0,(char *)&MZ80B_MEM(0x4f01),16); if((MZ80B_MEM(0x4f00))==0x01) break; MZ_cls(); MZ_msg(10,0,"File Mode error"); tape_unmount(); fname[0]='\0'; if(!(IORD_8DIRECT(REG_BASE, MZ_SYS_SW70)&0x10)) return -1; MZ_msg(4,2,"Pressing S key starts the CMT"); while(1){ if((get_key()&'S')=='S'){ if(fname[0]!='\0') break; }else if((z80_sts.status&S_FBTN)==S_FBTN){ SaveVRAM(); menu_process(); z80_sts.status&=~S_FBTN; // Clear Flag RestoreVRAM(); } } MZ_cls(); } size=(MZ80B_MEM(0x4f13)<<8)+MZ80B_MEM(0x4f12); tape_rddat_bulk(&MZ80B_MEM(0),size); return 0; }
void System_Initialize(void) { char SecName[8],buffer[512],data[4096]; unsigned char *cgrom,*keymap; int k; UINT i,r; ROMS_t *romdata=(ROMS_t *)(CFI_BASE+0x100000); // Interrupt regist int_regist(); sd_mount(); tname[0]='\0'; dname[0][0]='\0'; dname[1][0]='\0'; // Clear VRAM for(i=0;i<1000;i++) IOWR_8DIRECT(REG_BASE, MZ_VRAM+i, 0); // Clear GRAM for(i=0;i<65536;i++) MZ80B_GRAM(i)=0; cgrom=romdata->char80b; keymap=romdata->key80b; // CG ROM for(i=0;i<2048;i++){ // (0xc800-0xcfff) IOWR_8DIRECT(REG_BASE, MZ_CGROM+i, cgrom[i]); } // Key Map Data for(i=0;i<256;i++){ // (0xc000-0xc0ff) IOWR_8DIRECT(REG_BASE, MZ_KMAP+i, keymap[i]); } if(IORD_8DIRECT(REG_BASE, MZ_SYS_SW70)&0x20){ // Select Section Name by MZ mode if((IORD_8DIRECT(REG_BASE, MZ_SYS_SW98)&0x2)) strcpy(SecName, "MZ-2000"); else strcpy(SecName, "MZ-80B"); // CG ROM GetPrivateProfileString(SecName, "CGROM", "NULL", buffer, "system.ini"); if(strcmp(buffer,"NULL")==0) GetPrivateProfileString("COMMON", "CGROM", "NULL", buffer, "system.ini"); if(strcmp(buffer,"NULL")!=0){ file_bulk_read(buffer, data, 2048); for(i=0;i<2048;i++){ // (0xc800-0xcfff) IOWR_8DIRECT(REG_BASE, MZ_CGROM+i, data[i]); } } // Key Map Data GetPrivateProfileString(SecName, "KEYMAP", "NULL", buffer, "system.ini"); if(strcmp(buffer,"NULL")==0) GetPrivateProfileString("COMMON", "KEYMAP", "NULL", buffer, "system.ini"); if(strcmp(buffer,"NULL")!=0){ file_bulk_read(buffer, data, 256); for(i=0;i<256;i++){ // (0xc000-0xc0ff) IOWR_8DIRECT(REG_BASE, MZ_KMAP+i, data[i]); } } } }
int main(){ printf("NEW GAME!\n\n"); volatile int old_game_state = 0; int doge = 0; //animation counter //buffer init stuff pixel_buffer = alt_up_pixel_buffer_dma_open_dev("/dev/pixel_buffer_dma"); char_buffer = alt_up_char_buffer_open_dev("/dev/char_drawer"); //phil's stuff master* m = master_init(); printf("NEW GAME!\n\n"); // Set the 1st buffer address alt_up_pixel_buffer_dma_change_back_buffer_address(pixel_buffer,pixel_buffer_addr1); // Swap buffers – we have to swap because there is only an API function // to set the address of the background buffer. alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while (alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)); // Set the 2nd buffer address alt_up_pixel_buffer_dma_change_back_buffer_address(pixel_buffer,pixel_buffer_addr2); printf("NEW GAME!\n\n"); // Clear the screen alt_up_pixel_buffer_dma_clear_screen(pixel_buffer, 1); alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while (alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)); alt_up_pixel_buffer_dma_clear_screen(pixel_buffer, 1); alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while (alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)); alt_up_char_buffer_clear(char_buffer); //Write some text alt_up_char_buffer_string(char_buffer, "LOADING...", 0, 0); //load bitmap files title = read_bmp("title.bmp"); alt_up_char_buffer_string(char_buffer, "title.bmp", 0, 2); menu = read_bmp("menu.bmp"); alt_up_char_buffer_string(char_buffer, "MENU.BMP", 0, 3); selA = read_bmp("selA.bmp"); alt_up_char_buffer_string(char_buffer, "selA.bmp", 0, 4); selB = read_bmp("selB.bmp"); alt_up_char_buffer_string(char_buffer, "selB.bmp", 0, 5); selC = read_bmp("selC.bmp"); alt_up_char_buffer_string(char_buffer, "selC.bmp", 0, 6); dead = read_bmp("dead.bmp"); alt_up_char_buffer_string(char_buffer, "dead.bmp", 0, 7); bmp * b = read_bmp("para1.bmp"); alt_up_char_buffer_string(char_buffer, "para.bmp", 0, 8); bmp * doge0 = read_bmp("doge0.bmp"); alt_up_char_buffer_string(char_buffer, "doge0.bmp", 0, 9); bmp * doge1 = read_bmp("doge1.bmp"); alt_up_char_buffer_string(char_buffer, "doge1.bmp", 0, 10); bmp * doge2 = read_bmp("doge2.bmp"); alt_up_char_buffer_string(char_buffer, "doge2.bmp", 0, 11); bmp * doge3 = read_bmp("doge3.bmp"); alt_up_char_buffer_string(char_buffer, "doge3.bmp", 0, 12); bmp * flat = read_bmp("flat.bmp"); alt_up_char_buffer_string(char_buffer, "flat.bmp", 0, 13); bmp * coin = read_bmp("coin.bmp"); alt_up_char_buffer_string(char_buffer, "coin.bmp", 0, 14); bmp * spike = read_bmp("spike.bmp"); alt_up_char_buffer_string(char_buffer, "spike.bmp", 0, 15); bmp * box1 = read_bmp("box1.bmp"); alt_up_char_buffer_string(char_buffer, "box1.bmp", 0, 16); bmp * box3 = read_bmp("box3.bmp"); alt_up_char_buffer_string(char_buffer, "box3.bmp", 0, 17); bmp * low = read_bmp("low.bmp"); alt_up_char_buffer_string(char_buffer, "low.bmp", 0, 18); bmp * flatb = read_bmp("flatb.bmp"); alt_up_char_buffer_string(char_buffer, "flatb.bmp", 0, 19); bmp * flatr = read_bmp("flatr.bmp"); alt_up_char_buffer_string(char_buffer, "flatr.bmp", 0, 20); bmp * blue = read_bmp("bstar.bmp"); alt_up_char_buffer_string(char_buffer, "blue.bmp", 0, 21); bmp * red = read_bmp("rstar.bmp"); alt_up_char_buffer_string(char_buffer, "red.bmp", 0, 22); bmp * flag_img = read_bmp("flag.bmp"); alt_up_char_buffer_string(char_buffer, "flag.bmp", 0, 23); name = read_bmp("name.bmp"); alt_up_char_buffer_string(char_buffer, "name.bmp", 0, 24); instr = read_bmp("instr.bmp"); alt_up_char_buffer_string(char_buffer, "instr.bmp", 0, 25); dcol = read_bmp("dcol.bmp"); alt_up_char_buffer_string(char_buffer, "dcol.bmp", 0, 26); win = read_bmp("win.bmp"); alt_up_char_buffer_string(char_buffer, "win.bmp", 0,27); alt_up_char_buffer_clear(char_buffer); printf("NEW GAME!\n\n"); //interrupt init stuff (for object writing) //TIMERPERIOD int timer_period = 1 * 500000; IOWR_16DIRECT(TIMER_0_BASE, 8, timer_period & 0xFFFF); //writes the period to the hardware timer IOWR_16DIRECT(TIMER_0_BASE, 12, timer_period >> 16); IOWR_16DIRECT(TIMER_0_BASE, 4, 1 << 3); //stop timer alt_irq_register(TIMER_0_IRQ,NULL,(void*)handle_timer_interrupts);//registers function to a specific IRQ //IOWR_16DIRECT(TIMER_0_BASE, 4, 0x5); //start timer //SET UP KEYBOARD INTERRUPT// ps2 = alt_up_ps2_open_dev(KEYBOARD_NAME); alt_up_ps2_init(ps2); alt_up_ps2_clear_fifo(ps2); //void* keyboard_control_register_ptr = (void*) (PS2_0_BASE + 4); alt_irq_register(PS2_0_IRQ, m, keyboard_ISR); alt_up_ps2_enable_read_interrupt(ps2); char sw = 0; char p_sw = 0; ///////////////////////////////////////////////////////////////////////// printf("NEW GAME!\n\n"); //SUPERDUPERLOOP while (1){ printf("old state:%i\nnew state: %i\n\n",old_game_state, game_state); draw_menu(game_state); //update screen while (old_game_state == game_state); printf("old state:%i\nnew state: %i\n\n",old_game_state, game_state); //only when entering a new menu alt_up_char_buffer_clear(char_buffer); //ENTER GAME LOOP if (game_state == 5){ printf("START GAME! LEVEL: %i\n\n", highlighted_level); alt_up_char_buffer_string(char_buffer, playername, 10, 4); if (highlighted_level == 1) { free_bmp(b); b = read_bmp("para1.bmp"); game_start(m,b,"lvl/1.txt","song1.wav"); } else if (highlighted_level == 2) { free_bmp(b); b = read_bmp("bg2.bmp"); game_start(m,b,"lvl/2.txt","a/abcd.wav"); } else{ free_bmp(b); b = read_bmp("bg3.bmp"); game_start(m,b,"lvl/2.txt","a/nyan1.wav"); } //collision loop while(!m->c->collide && !m->c->win){ alt_up_char_buffer_string(char_buffer, "POINTS: ", 50, 4); char str[15]; sprintf(str, "%d", m->c->points); alt_up_char_buffer_string(char_buffer, str, 58, 4); sw = IORD_8DIRECT(SWITCHES_BASE,0); IOWR_8DIRECT(LEDS_BASE,0,sw); if(sw == 1 && p_sw == 0){ //m->ab->sfx_flag = 1; m->c->jump_pressed = 1; } p_sw = sw; //boxes int i; for( i= 0 ; i < OBJECT_SIZE ; i++) { if(m->o->color[i] == -1) draw_object(pixel_buffer, box, flat, i); else if(m->o->color[i] == 0) draw_object(pixel_buffer, box, flatb, i); else if(m->o->color[i] == 1) draw_object(pixel_buffer, box, flatr, i); draw_object(pixel_buffer, co, coin, i ); draw_object(pixel_buffer, spikes, spike, i); draw_object(pixel_buffer, box_3, box3, i); draw_object(pixel_buffer, box_1, box1, i); // if(m->color_gates->color[i] == 1) // draw_object(pixel_buffer,cgates, rgate,i); // else if (m->color_gates->color[i] == 0) // draw_object(pixel_buffer,cgates, bgate,i); } //draws the win flag draw_object(pixel_buffer, flag, flag_img, 0); //Draw Doge if (m->c->ducking) draw_bmp(pixel_buffer,m->c->x - m->c->width, m->c->y - m->c->height,low); else{ doge++; if(doge == 37) doge = 0; if( doge <9) draw_bmp(pixel_buffer,m->c->x - m->c->width, m->c->y - m->c->height,doge0); else if (doge <18) draw_bmp(pixel_buffer,m->c->x - m->c->width, m->c->y - m->c->height,doge1); else if (doge <27) draw_bmp(pixel_buffer,m->c->x - m->c->width, m->c->y - m->c->height,doge2); else draw_bmp(pixel_buffer,m->c->x - m->c->width, m->c->y - m->c->height,doge3); } //Draw Color Indicator if(m->c->color == 0) draw_bmp(pixel_buffer, m->c->x- m->c->width + 5, m->c->y - m->c->height - 10, blue); else draw_bmp(pixel_buffer,m->c->x- m->c->width + 5, m->c->y - m->c->height - 10, red); p_counter++; if(p_counter == 3){ p_shift++; alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while(alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)) refill_buffer(m->ab, "a/abcd.wav");//refills the audio buffer unrolled_parallax_draw(pixel_buffer, b); }else if(p_counter == 4){ //if(p_counter == 1){ alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while(alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)) refill_buffer(m->ab, "a/abcd.wav");//refills the audio buffer unrolled_parallax_draw(pixel_buffer, b); p_counter = 0; }else{ // alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); // while(alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)) // refill_buffer(m->ab, "a/abcd.wav");//refills the audio buffer // unrolled_parallax_draw(pixel_buffer, b); alt_up_pixel_buffer_dma_swap_buffers(pixel_buffer); while(alt_up_pixel_buffer_dma_check_swap_buffers_status(pixel_buffer)) refill_buffer(m->ab, "a/abcd.wav");//refills the audio buffer int j; for( j = 0 ; j < OBJECT_SIZE ; j++) { clear_object(pixel_buffer, box, b, j); clear_object(pixel_buffer, co, b, j); clear_object(pixel_buffer, spikes, b, j); clear_object(pixel_buffer, box_3, b, j); clear_object(pixel_buffer, box_1, b, j); } clear_object(pixel_buffer,flag,b,0); //clear doge clear_doge(pixel_buffer, m->c->x - m->c->width, m->c->y - m->c->height , b); //clear_loc(pixel_buffer,m->c->x- m->c->width + 5, m->c->y - m->c->height - 10,m->c->x- m->c->width + 5 - 10, m->c->y - m->c->height - 20,b); } } alt_up_char_buffer_string(char_buffer, "POINTS: ", 50, 4); char str[15]; sprintf(str, "%d", m->c->points); alt_up_char_buffer_string(char_buffer, str, 58, 4); printf("game exited\n"); if(m->c->win) game_state = 7; else game_state = 6; highlighted_item = 3; game_reset(m); } //exit game mode, restart superduperloop in main menu old_game_state = game_state; } return 0; }
int main() { IOWR_RAM_DATA(NIOSINTERFACE_1_0_BASE, 0, 0); int dir = 0; int posX = doubleToInt(21.5), posY = doubleToInt(11.5); //x and y start position // int posX = 22, posY = 11; //x and y start position int x =0; int p, q; IOSKYWR_RAM_DATA(SKYGEN_0_BASE, 262143, 0x0000); for(p = 0; p < 480; p++){ for(q = 0; q < 512; q++) { IOSKYWR_RAM_DATA(SKYGEN_0_BASE, p*512+q, (sky[p*1024+q*2+1]<<8) + (sky[p*1024+q*2])); } } IOSKYWR_RAM_DATA(SKYGEN_0_BASE, 262143, 0x000F); double sine_temp; double cosine_temp; for(x = 0; x < lookupLength ; x++) { //calculate ray position and direction sine_temp = sin(x*RAD + HALF_RAD); cosine_temp = cos(x*RAD + HALF_RAD); dirsine[x] = doubleToInt(sin(x*RAD)); dircosine[x] = doubleToInt(cos(x*RAD)); sine[x] = doubleToInt(sine_temp); cosine[x] = doubleToInt(cosine_temp); } int angle; int fish_angle; int move; int rayDirX; int rayDirY; int count_step; int k; int k2; int forward = 0; int backward = 0; int left = 0; int right = 0; //char key[] = { 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d', // 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d', 'd','d','d','d','d','d','d','d','d','d','d','d','d','d','d','d'}; unsigned char code = 0; //char key[] = {'d'}; k2 = 0; //start the main loop //for (k2 = 0; k2 < sizeof(key); k2++) int hardwareData = 0; while(1) { code = 0; //while (!IORD_8DIRECT(DE2_PS2_0_BASE, 0)) ; /* Poll the status */ // code = IORD_8DIRECT(DE2_PS2_0_BASE, 0); // if (code) //printf("%c, %x, %d\n", code, code, code); /* Get received byte */ //code = 'k'; //hardwareData = IORD_RAM_DATA(NIOSINTERFACE_1_0_BASE, 1); //printf("%d\n", hardwareData >> 4); code = IORD_8DIRECT(DE2_PS2_1_BASE, 1); switch(code) { case 'u': forward = 1; backward = 0; break; case 'r': forward = 0; backward = 1; break; case 't': right = 1; left = 0; break; case 'k': left = 1; right = 0; break; case 'U': forward = 0; break; case 'R': backward = 0; break; case 'T': right = 0; break; case 'K': left = 0; break; case ')': forward = 0; backward = 0; right = 0; left = 0; break; } x = 0; for(k = -halfScreenWidth; k < halfScreenWidth; k++) { angle = dir + k; if ( angle < 0) angle += lookupLength; if (angle >= lookupLength) angle -= lookupLength; fish_angle = k; if ( fish_angle < 0) fish_angle += lookupLength; if (fish_angle >= lookupLength) fish_angle -= lookupLength; //calculate ray position and direction //double cameraX = 2*x/double(w)-1; //x-coordinate in camera space rayDirX = cosine[angle]>>extensionFactor; rayDirY = sine[angle]>>extensionFactor; count_step = cosine[fish_angle]>>extensionFactor; //using a happy medium between 1/32 and 1/64 ray extension increment // rayDirX = (cosine[angle]>>6)+(cosine[angle]>>7); // rayDirY = (sine[angle]>>6) +(sine[angle]>>7); // count_step = (cosine[fish_angle]>>6) +(cosine[fish_angle]>>7); // hardwareData = IORD_32DIRECT(NIOSINTERFACE_1_0_BASE, 1); // printf("%d\n", hardwareData); DrawAccelerate(angle, posX, posY, count_step, rayDirX, rayDirY, x); IOWR_RAM_DATA(NIOSINTERFACE_1_0_BASE, 0, 0); hardwareData = IORD_32DIRECT(NIOSINTERFACE_1_0_BASE, 1); while (!(hardwareData & 1)){ hardwareData = IORD_32DIRECT(NIOSINTERFACE_1_0_BASE, 1); } //IOWR_RAM_DATA(NIOSINTERFACE_1_0_BASE, 0, 0); IOWR_RAM_DATA(NIOSINTERFACE_1_0_BASE, 0, 0xFFFFFFFF); // printf("out of loop\n"); //IOWR_RAM_DATA(NIOSINTERFACE_0_BASE, 0, 0); // int rayPosX = posX; // int rayPosY = posY; // int count = 0; // int mapX; // int mapY; // // //what direction to step in x or y-direction (either +1 or -1) // int stepX; // int stepY; // // int hit = 0; //was there a wall hit? // unsigned int side = 0; //was a NS or a EW wall hit? // // //calculate step and initial sideDist // if (rayDirX < 0) // stepX = -1; // else // stepX = 1; // // if (rayDirY < 0) // stepY = -1; // else // stepY = 1; // // // while ( worldMap[rayPosX>>posShift][rayPosY>>posShift] == 0) // { // count += count_step; // // //jump to next map square, OR in x-direction, OR in y-direction // rayPosX += rayDirX; // rayPosY += rayDirY; // // //Check if ray has hit a wall // } // // hit = 1; // //////////////////////////////////////////////////////////////////////// // /////LOOOP BACK CODE FOR SMOOTHER EDGES AND FASTER SPEEDS/////////////// // // count_step = count_step>>4; // rayDirX = rayDirX>>4; // rayDirY = rayDirY>>4; // // while(hit == 1) // { // // count -= count_step; // // //jump to next map square, OR in x-direction, OR in y-direction // rayPosX -= rayDirX; // rayPosY -= rayDirY; // // //Check if ray has hit a wall // if (worldMap[rayPosX>>posShift][rayPosY>>posShift] == 0) hit = 0; // // } // // count += count_step; // rayPosX += rayDirX; // rayPosY += rayDirY; // // //////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////// // // mapX = ((rayPosX>>posShift) + ((1 - stepX)>>1))<<posShift; // mapY = ((rayPosY>>posShift) + ((1 - stepY)>>1))<<posShift; // // //Calculate distance of perpendicular ray (oblique distance will give fisheye effect!) // if ( absVal(mapX - rayPosX) < absVal(mapY - rayPosY) ) // side = 1; // // // //Calculate height of line to draw on screen // //int lineHeight = abs( (screenHeight<<posShift) /count); // int lineHeight = (screenHeight<<posShift) /count; // //printf("lineHeight= %d", lineHeight); //// if (lineHeight >= screenHeight){ //// lineHeight = 0x1FF; //// //printf(" lineHeight= %d", lineHeight); //// } // //printf("\n"); // // //calculate lowest and highest pixel to fill in current stripe // int drawStart = (-lineHeight >> 1) + (screenHeight >> 1); // if(drawStart < 0) drawStart = 0; // int drawEnd = (lineHeight >> 1) + (screenHeight >> 1); // if(drawEnd >= screenHeight) drawEnd = screenHeight - 1; // // ///////////////////////////////////////////////// // ////texturing calculations // ///////////////////////////////////////////////// // unsigned int texNum = worldMap[rayPosX>>posShift][rayPosY>>posShift] - 1; //1 subtracted from it so that texture 0 can be used! // // //calculate value of wallX // int wallX; //where exactly the wall was hit // // if (side == 0) wallX = rayPosX; // else wallX = rayPosY; // // // wallX -= (wallX>>posShift)<<posShift; // // //x coordinate on the texture // unsigned int texX = (wallX * texWidth)>>posShift; // if(side == 1 && rayDirX > 0) texX = texWidth - texX - 1; // if(side == 0 && rayDirY < 0) texX = texWidth - texX - 1; // // unsigned int invLineHeight = (texHeight << 16)/lineHeight; // int line_minus_h = lineHeight - screenHeight; // // // // DrawTexture(x, texX, drawStart, drawEnd, side, texNum, invLineHeight , line_minus_h); // unsigned int color; // switch(worldMap[rayPosX>>posShift][rayPosY>>posShift]) // { // case 1: color = RED_8BIT; break; //red // case 2: color = GREEN_8BIT; break; //green // case 3: color = BLUE_8BIT; break; //blue // case 4: color = WHITE_8BIT; break; //white // default: color = YELLOW_8BIT; break; //yellow // } //draw the pixels of the stripe as a vertical line //DrawColumn(x, color, drawStart, drawEnd, side); //DrawColumn(x, color, lineHeight, side); //verLine(x, drawStart, drawEnd, color); x++; } //move forward if no wall in front of you if (forward == 1) { move = dircosine[dir]>>4; if(worldMap[(posX + move)>>posShift][posY>>posShift] == 0) posX += move; move = dirsine[dir]>>4; if(worldMap[posX>>posShift][(posY+move)>>posShift] == 0) posY += move; } //move backwards if no wall behind you if (backward == 1) { move = dircosine[dir]>>4; if(worldMap[(posX - move)>>posShift][posY>>posShift] == 0) posX -= move; move = dirsine[dir]>>4; if(worldMap[posX>>posShift][(posY - move)>>posShift] == 0) posY -= move; }
// Entry point int main() { struct uart_pkt { unsigned char magic; #define UART_PKT_MAGIC 'N' // | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | // | dir | dev | cnt | unsigned char mode; #define UART_PKT_MODE_CNT_MASK 0xF #define UART_PKT_MODE_CNT_SHIFT 0 #define UART_PKT_MODE_DEV_MASK 0x30 #define UART_PKT_MODE_DEV_SHIFT 4 #define UART_PKT_DEV_GPIO (0<<UART_PKT_MODE_DEV_SHIFT) #define UART_PKT_DEV_LMS (1<<UART_PKT_MODE_DEV_SHIFT) #define UART_PKT_DEV_VCTCXO (2<<UART_PKT_MODE_DEV_SHIFT) #define UART_PKT_DEV_SI5338 (3<<UART_PKT_MODE_DEV_SHIFT) #define UART_PKT_MODE_DIR_MASK 0xC0 #define UART_PKT_MODE_DIR_SHIFT 6 #define UART_PKT_MODE_DIR_READ (2<<UART_PKT_MODE_DIR_SHIFT) #define UART_PKT_MODE_DIR_WRITE (1<<UART_PKT_MODE_DIR_SHIFT) }; struct uart_cmd { unsigned char addr; unsigned char data; }; // Set the prescaler for 400kHz with an 80MHz clock (prescaer = clock / (5*desired) - 1) IOWR_16DIRECT(I2C, OC_I2C_PRESCALER, 39 ) ; IOWR_8DIRECT(I2C, OC_I2C_CTRL, OC_I2C_ENABLE ) ; // Set the UART divisor to 14 to get 4000000bps UART (baud rate = clock/(divisor + 1)) IOWR_ALTERA_AVALON_UART_DIVISOR(UART_0_BASE, 19) ; // Set the IQ Correction parameters to 0 IOWR_ALTERA_AVALON_PIO_DATA(IQ_CORR_RX_PHASE_GAIN_BASE, DEFAULT_CORRECTION); IOWR_ALTERA_AVALON_PIO_DATA(IQ_CORR_TX_PHASE_GAIN_BASE, DEFAULT_CORRECTION); /* Event loop never exits. */ { char state; enum { LOOKING_FOR_MAGIC, READING_MODE, READING_CMDS, EXECUTE_CMDS }; unsigned short i, cnt; unsigned char mode; unsigned char buf[14]; struct uart_cmd *cmd_ptr; uint32_t tmpvar = 0; state = LOOKING_FOR_MAGIC; while(1) { // Check if anything is in the FSK UART if( IORD_ALTERA_AVALON_UART_STATUS(UART_0_BASE) & ALTERA_AVALON_UART_STATUS_RRDY_MSK ) { uint8_t val ; int isRead; int isWrite; val = IORD_ALTERA_AVALON_UART_RXDATA(UART_0_BASE) ; switch (state) { case LOOKING_FOR_MAGIC: if (val == UART_PKT_MAGIC) state = READING_MODE; break; case READING_MODE: mode = val; if ((mode & UART_PKT_MODE_CNT_MASK) > 7) { mode &= ~UART_PKT_MODE_CNT_MASK; mode |= 7; } i = 0; cnt = (mode & UART_PKT_MODE_CNT_MASK) * sizeof(struct uart_cmd); state = READING_CMDS; break; case READING_CMDS: // cnt here means the number of bytes to read buf[i++] = val; if (!--cnt) state = EXECUTE_CMDS; break; default: break; } void write_uart(unsigned char val) { while (!(IORD_ALTERA_AVALON_UART_STATUS(UART_0_BASE) & ALTERA_AVALON_UART_STATUS_TRDY_MSK)); IOWR_ALTERA_AVALON_UART_TXDATA(UART_0_BASE, val); } isRead = (mode & UART_PKT_MODE_DIR_MASK) == UART_PKT_MODE_DIR_READ; isWrite = (mode & UART_PKT_MODE_DIR_MASK) == UART_PKT_MODE_DIR_WRITE; if (state == EXECUTE_CMDS) { write_uart(UART_PKT_MAGIC); write_uart(mode); // cnt here means the number of commands cnt = (mode & UART_PKT_MODE_CNT_MASK); cmd_ptr = (struct uart_cmd *)buf; if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_LMS) { for (i = 0; i < cnt; i++) { if (isRead) { lms_spi_read(cmd_ptr->addr, &cmd_ptr->data); } else if (isWrite) { lms_spi_write(cmd_ptr->addr, cmd_ptr->data); cmd_ptr->data = 0; } else { cmd_ptr->addr = 0; cmd_ptr->data = 0; } cmd_ptr++; } } if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_SI5338) { for (i = 0; i < cnt; i++) { if (isRead) { uint8_t tmpvar; si5338_read(cmd_ptr->addr, &tmpvar); cmd_ptr->data = tmpvar; } else if (isWrite) { si5338_write(cmd_ptr->addr, cmd_ptr->data); cmd_ptr->data = 0; } else { cmd_ptr->addr = 0; cmd_ptr->data = 0; } cmd_ptr++; } } const struct { enum { GDEV_UNKNOWN, GDEV_GPIO, GDEV_IQ_CORR_RX, GDEV_IQ_CORR_TX, GDEV_FPGA_VERSION, GDEV_TIME_TIMER, GDEV_VCTXCO, GDEV_XB_LO, GDEV_EXPANSION, GDEV_EXPANSION_DIR, } gdev; int start, len; } gdev_lut[] = { {GDEV_GPIO, 0, 4}, {GDEV_IQ_CORR_RX, 4, 4}, {GDEV_IQ_CORR_TX, 8, 4}, {GDEV_FPGA_VERSION, 12, 4}, {GDEV_TIME_TIMER, 16, 16}, {GDEV_VCTXCO, 34, 2}, {GDEV_XB_LO, 36, 4}, {GDEV_EXPANSION, 40, 4}, {GDEV_EXPANSION_DIR, 44, 4}, }; #define ARRAY_SZ(x) (sizeof(x)/sizeof(x[0])) #define COLLECT_BYTES(x) tmpvar &= ~ ( 0xff << ( 8 * cmd_ptr->addr)); \ tmpvar |= cmd_ptr->data << (8 * cmd_ptr->addr); \ if (lastByte) { x; tmpvar = 0; } \ cmd_ptr->data = 0; if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_GPIO) { uint32_t device; int lut, lastByte; for (i = 0; i < cnt; i++) { device = GDEV_UNKNOWN; lastByte = 0; for (lut = 0; lut < ARRAY_SZ(gdev_lut); lut++) { if (gdev_lut[lut].start <= cmd_ptr->addr && (gdev_lut[lut].start + gdev_lut[lut].len) > cmd_ptr->addr) { cmd_ptr->addr -= gdev_lut[lut].start; device = gdev_lut[lut].gdev; lastByte = cmd_ptr->addr == (gdev_lut[lut].len - 1); break; } } if (isRead) { if (device == GDEV_FPGA_VERSION) cmd_ptr->data = (FPGA_VERSION >> (cmd_ptr->addr * 8)); else if (device == GDEV_TIME_TIMER) cmd_ptr->data = IORD_8DIRECT(TIME_TAMER, cmd_ptr->addr); else if (device == GDEV_GPIO) cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_0_BASE)) >> (cmd_ptr->addr * 8); else if (device == GDEV_EXPANSION) cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_1_BASE)) >> (cmd_ptr->addr * 8); else if (device == GDEV_EXPANSION_DIR) cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_2_BASE)) >> (cmd_ptr->addr * 8); else if (device == GDEV_IQ_CORR_RX) cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(IQ_CORR_RX_PHASE_GAIN_BASE)) >> (cmd_ptr->addr * 8); else if (device == GDEV_IQ_CORR_TX)