EclaireXL

gcc -g -O0 test_joy.c joystick.c native/regs.c -I.

#include "aeon_lite/memory.h"

#include "main_real.c"

#pragma once

struct joystick_status

{

int x_;

int y_;

int fire_;

};

enum JoyWait {WAIT_QUIET, WAIT_FIRE, WAIT_MOVE, WAIT_EITHER};

void joystick_poll(struct joystick_status * status);

void joystick_wait(struct joystick_status * status, enum JoyWait waitFor);

#include "integer.h"

#include "regs.h"

#include "pause.h"

#include "printf.h"

#include "joystick.h"

#include "freeze.h"

#include "simpledir.h"

#include "simplefile.h"

#include "fileselector.h"

#include "atari_drive_emulator.h"

extern char ROM_DIR[];

// FUNCTIONS in here

// i) pff init - NOT USED EVERYWHERE

// ii) file selector - kind of crap, no fine scrolling - NOT USED EVERYWHERE

// iii) cold reset atari (clears base ram...)

// iv) start atari (begins paused)

// v) freeze/resume atari - NOT USED EVERYWHERE!

// vi) menu for various options - NOT USED EVERYWHERE!

// vii) pause - TODO - base this on pokey clock...

// standard ZPU IN/OUT use...

// OUT1 - 6502 settings (pause,reset,speed)

// pause_n: bit 0

// reset_n: bit 1

// turbo: bit 2-4: meaning... 0=1.79Mhz,1=3.58MHz,2=7.16MHz,3=14.32MHz,4=28.64MHz,5=57.28MHz,etc.

// ram_select: bit 5-7:

// RAM_SELECT : in std_logic_vector(2 downto 0); -- 64K,128K,320KB Compy, 320KB Rambo, 576K Compy, 576K Rambo, 1088K, 4MB

// rom_select: bit 8-13:

// ROM_SELECT : in std_logic_vector(5 downto 0); -- 16KB ROM Bank

#define BIT_REG(op,mask,shift,name,reg) \

int get_ ## name() \

{ \

int val = *reg; \

return op((val>>shift)&mask); \

} \

void set_ ## name(int param) \

{ \

int val = *reg; \

\

val = (val&~(mask<<shift)); \

val |= op(param)<<shift; \

\

*reg = val; \

}

#define BIT_REG_RO(op,mask,shift,name,reg) \

int get_ ## name() \

{ \

int val = *reg; \

return op((val>>shift)&mask); \

}

BIT_REG(,0x1,0,pause_6502,zpu_out1)

BIT_REG(,0x1,1,reset_6502,zpu_out1)

BIT_REG(,0x3f,2,turbo_6502,zpu_out1)

BIT_REG(,0x7,8,ram_select,zpu_out1)

BIT_REG(,0x3f,11,rom_select,zpu_out1)

BIT_REG_RO(,0x1,8,hotkey_softboot,zpu_in1)

BIT_REG_RO(,0x1,9,hotkey_coldboot,zpu_in1)

BIT_REG_RO(,0x1,10,hotkey_fileselect,zpu_in1)

BIT_REG_RO(,0x1,11,hotkey_settings,zpu_in1)

void

wait_us(int unsigned num)

{

// pause counter runs at pokey frequency - should be 1.79MHz

int unsigned cycles = (num*230)>>7;

*zpu_pause = cycles;

}

void memset8(void * address, int value, int length)

{

char * mem = address;

while (length--)

*mem++=value;

}

void memset32(void * address, int value, int length)

{

int * mem = address;

while (length--)

*mem++=value;

}

void clear_64k_ram()

{

memset8((void *)0x200000, 0, 65536); // SRAM, if present (TODO)

memset32((void *)0x800000, 0, 16384);

}

void

reboot(int cold)

{

set_pause_6502(1);

if (cold)

{

clear_64k_ram();

}

set_reset_6502(1);

// Do nothing in here - this resets the memory controller!

set_reset_6502(0);

set_pause_6502(0);

}

unsigned char toatarichar(int val)

{

int inv = val>=128;

if (inv)

{

val-=128;

}

if (val>='A' && val<='Z')

{

val+=-'A'+33;

}

else if (val>='a' && val<='z')

{

val+=-'a'+33+64;

}

else if (val>='0' && val<='9')

{

val+=-'0'+16;

}

else if (val>=32 && val<=47)

{

val+=-32;

}

else

{

val = 0;

}

if (inv)

{

val+=128;

}

return val;

}

int debug_pos;

int debug_adjust;

unsigned char volatile * baseaddr;

void clearscreen()

{

unsigned volatile char * screen;

for (screen=(unsigned volatile char *)40000+atari_regbase; screen!=(unsigned volatile char *)(atari_regbase+40000+1024); ++screen)

*screen = 0x00;

}

void char_out ( void* p, char c)

{

unsigned char val = toatarichar(c);

if (debug_pos>=0)

{

*(baseaddr+debug_pos) = val|debug_adjust;

++debug_pos;

}

}

// Memory usage...

// 0x410000-0x41FFFF (0xc10000 in zpu space) = directory cache - 64k

// 0x420000-0x43FFFF (0xc20000 in zpu space) = freeze backup

struct SimpleFile * files[6];

void loadromfile(struct SimpleFile * file, int size, void * ram_address)

{

ram_address += 0x800000;

int read = 0;

file_read(file, ram_address, size, &read);

}

void loadrom(char const * path, int size, void * ram_address)

{

if (SimpleFile_OK == file_open_name(path, files[4]))

{

loadromfile(files[4], size, ram_address);

}

}

void loadrom_indir(struct SimpleDirEntry * entries, char const * filename, int size, void * ram_address)

{

if (SimpleFile_OK == file_open_name_in_dir(entries, filename, files[4]))

{

loadromfile(files[4], size, ram_address);

}

}

void loadosrom()

{

if (file_size(files[5]) == 0x4000)

{

loadromfile(files[5],0x4000, (void *)0x704000);

}

else if (file_size(files[5]) ==0x2800)

{

loadromfile(files[5],0x2800, (void *)0x705800);

}

}

int main(void)

{

{

char buffer[512];

freeze_init((void*)0xc20000); // 128k

debug_pos = -1;

debug_adjust = 0;

baseaddr = (unsigned char volatile *)(40000 + atari_regbase);

set_pause_6502(1);

set_reset_6502(1);

set_reset_6502(0);

set_turbo_6502(1);

set_rom_select(1);

set_ram_select(0);

init_printf(0, char_out);

reboot(1);

// for (;;);

wait_us(5000000);

disk_debug();

//for (;;);

wait_us(10000000);

}

/* disk_initialize();

{

char buffer[512];

freeze_init((void*)0xc20000); // 128k

debug_pos = -1;

debug_adjust = 0;

baseaddr = (unsigned char volatile *)(40000 + atari_regbase);

set_pause_6502(1);

set_reset_6502(1);

set_reset_6502(0);

set_turbo_6502(1);

set_rom_select(1);

set_ram_select(0);

init_printf(0, char_out);

reboot(1);

// for (;;);

wait_us(5000000);

set_pause_6502(1);

freeze();

debug_pos = 0;

printf("Hello world 3");

debug_pos = 40;

int i;

for (i=0;i!=512; ++i)

{

buffer[i] = i;

}

int volatile * x = (int volatile *)0x4000;

int volatile * y = (int volatile *)&buffer[0];

for (i=0;i!=128; ++i)

{

x[i] = y[i];

}

hexdump_pure(0x4000,8);

hexdump_pure(0x41f8,8);

debug_pos = 120;

printf(" Writing sector ");

n_actual_mmc_sector = 30;

disk_writeflush();

printf(" Wrote sector ");

for (i=0;i!=128; ++i)

{

x[i] = 0;

}

n_actual_mmc_sector = -1;

disk_readp(&buffer[0],30,0,512);

hexdump_pure(0x4000,8);

hexdump_pure(0x41f8,8);

debug_pos = 200;

disk_readp(&buffer[0],0x103,0,512);

hexdump_pure(0x4000,8);

hexdump_pure(0x41f8,8);

debug_pos = 280;

disk_readp(&buffer[0],0,0,512);

hexdump_pure(0x4000,8);

hexdump_pure(0x41f8,8);

debug_pos = 360;

printf("OK...");

//for (;;);

wait_us(10000000);

}*/

/* spiInit();

set_spi_clock_freq();

mmcReadLoop();*/

/* spiInit();

set_spi_clock_freq();

char buffer[512];

while (1)

{

mmcReadLoop();

wait_us(500);

}*/

int i;

for (i=0; i!=6; ++i)

{

files[i] = (struct SimpleFile *)alloca(file_struct_size());

file_init(files[i]);

}

freeze_init((void*)0xc20000); // 128k

debug_pos = -1;

debug_adjust = 0;

baseaddr = (unsigned char volatile *)(40000 + atari_regbase);

set_pause_6502(1);

set_reset_6502(1);

set_reset_6502(0);

set_turbo_6502(1);

set_rom_select(1);

set_ram_select(2);

init_printf(0, char_out);

// TODO...

if (SimpleFile_OK == dir_init((void *)0xc10000, 65536))

{

// printf("DIR init ok\n");

init_drive_emulator();

struct SimpleDirEntry * entries = dir_entries(ROM_DIR);

//loadrom_indir(entries,"atarixl.rom",0x4000, (void *)0x704000);

if (SimpleFile_OK == file_open_name_in_dir(entries, "atarixl.rom", files[5]))

{

loadosrom();

}

/*loadrom_indir(entries,"xlhias.rom",0x4000, (void *)0x708000);

loadrom_indir(entries,"ultimon.rom",0x4000, (void *)0x70c000);

loadrom_indir(entries,"osbhias.rom",0x4000, (void *)0x710000);

loadrom_indir(entries,"osborig.rom",0x2800, (void *)0x715800);

loadrom_indir(entries,"osaorig.rom",0x2800, (void *)0x719800);*/

loadrom_indir(entries,"ataribas.rom",0x2000,(void *)0x700000);

//ROM = xlorig.rom,0x4000, (void *)0x704000

//ROM = xlhias.rom,0x4000, (void *)0x708000

//ROM = ultimon.rom,0x4000, (void *)0x70c000

//ROM = osbhias.rom,0x4000, (void *)0x710000

//ROM = osborig.rom,0x2800, (void *)0x715800

//ROM = osaorig.rom,0x2800, (void *)0x719800

//

//ROM = ataribas.rom,0x2000,(void *)0x700000

//--SDRAM_BASIC_ROM_ADDR <= "111"&"000000" &"00000000000000";

//--SDRAM_OS_ROM_ADDR <= "111"&rom_select &"00000000000000";

reboot(1);

run_drive_emulator();

}

else

{

//printf("DIR init failed\n");

}

reboot(1);

for (;;) actions();

}

// struct SimpleFile * file = alloca(file_struct_size());

// printf("Opening file\n");

// if (SimpleFile_OK == file_open_name("GUNPOWDR.ATR",file))

// {

// printf("FILE open ok\n");

//

// set_drive_status(0,file);

//

// }

// else

// {

// printf("FILE open failed\n");

// }

char const * get_ram()

{

static char const * ram[] =

{

"64K",

"128K",

"320K(Compy)",

"320K(Rambo)",

"576K(Compy)",

"576K(Rambo)",

"1MB",

"4MB"

};

return ram[get_ram_select()];

/*switch(get_ram_select())

{

case 0:

return "64K";

case 1:

return "128K";

case 2:

return "320K(Compy)";

case 3:

return "320K(Rambo)";

case 4:

return "576K(Compy)";

case 5:

return "576K(Rambo)";

case 6:

return "1MB";

case 7:

return "4MB";

}*/

}

/*

int settings()

{

struct joystick_status joy;

joy.x_ = joy.y_ = joy.fire_ = 0;

int row = 0;

int done = 0;

for (;!done;)

{

// Render

clearscreen();

debug_pos = 0;

debug_adjust = 0;

printf("Se");

debug_adjust = 128;

printf("ttings");

debug_pos = 80;

debug_adjust = row==0 ? 128 : 0;

printf("Turbo:%dx", get_turbo_6502());

debug_pos = 120;

debug_adjust = row==1 ? 128 : 0;

printf("Ram:%s", get_ram());

debug_pos = 160;

debug_adjust = row==2 ? 128 : 0;

{

printf("Rom:%s", file_name(files[5]));

}

debug_pos = 240;

int i;

for (i=1;i!=5;++i)

{

int temp = debug_pos;

debug_adjust = row==i+2 ? 128 : 0;

char buffer[20];

describe_disk(i-1,&buffer[0]);

printf("Drive %d:%s %s", i, file_name(files[i-1]), &buffer[0]);

debug_pos = temp+40;

}

debug_pos = 400;

debug_adjust = row==7 ? 128 : 0;

printf("Cartridge 8k simple");

debug_pos = 480;

debug_adjust = row==8 ? 128 : 0;

printf("Exit");

// Slow it down a bit

wait_us(100000);

// move

joystick_wait(&joy,WAIT_QUIET);

joystick_wait(&joy,WAIT_EITHER);

row+=joy.y_;

if (row<0) row = 0;

if (row>8) row = 8;

switch (row)

{

case 0:

{

int turbo = get_turbo_6502();

if (joy.x_==1) turbo<<=1;

if (joy.x_==-1) turbo>>=1;

if (turbo>16) turbo = 16;

if (turbo<1) turbo = 1;

set_turbo_6502(turbo);

}

break;

case 1:

{

int ram_select = get_ram_select();

ram_select+=joy.x_;

if (ram_select<0) ram_select = 0;

if (ram_select>7) ram_select = 7;

set_ram_select(ram_select);

}

break;

case 2:

{

if (joy.x_ || joy.fire_)

{

filter = filter_roms;

file_selector(files[5]);

loadosrom();

}

}

break;

case 3:

case 4:

case 5:

case 6:

{

if (joy.x_>0)

{

// Choose new disk

filter = filter_disks;

file_selector(files[row-3]);

set_drive_status(row-3,files[row-3]);

}

else if(joy.x_<0)

{

// Remove disk

file_init(files[row-3]);

set_drive_status(row-3,0);

}

else if (joy.fire_)

{

{

// Swap files

struct SimpleFile * temp = files[row-3];

files[row-3] = files[0];

files[0] = temp;

}

{

// Swap disks

struct SimpleFile * temp = get_drive_status(row-3);

set_drive_status(row-3, get_drive_status(0));

set_drive_status(0,temp);

}

}

}

break;

case 7:

{

if (joy.fire_)

{

filter = filter_roms;

file_selector(files[4]);

loadrom(file_name(files[4]),0x2000,(void *)0x700000);

return 1;

}

}

break;

case 8:

if (joy.fire_)

{

done = 1;

}

break;

}

}

return 0;

}

*/

void actions()

{

// Show some activity!

//*atari_colbk = *atari_random;

// Hot keys

/* if (get_hotkey_softboot())

{

reboot(0);

}

else */if (get_hotkey_coldboot())

{

reboot(1);

}

/* else if (get_hotkey_settings())

{

set_pause_6502(1);

freeze();

debug_pos = 0;

int do_reboot = settings();

debug_pos = -1;

restore();

if (do_reboot)

reboot(1);

else

set_pause_6502(0);

}

*/

else if (get_hotkey_fileselect())

{

/* set_pause_6502(1);

freeze();

filter = filter_disks;

file_selector(files[0]);

debug_pos = -1;

restore();

set_drive_status(0,files[0]);

reboot(1);

*/

disk_debug();

}

}

#include "spi.h"

#include "integer.h"

#include <stdio.h>

int spi_slow; // 1 is slow

int spi_chip_select_n; // 0 is selected

int display;

// access routines

void setSpiFast()

{

fprintf(stderr,"SPI:Fast\n");

}

void setSpiSlow()

{

fprintf(stderr,"SPI:Slow\n");

}

void set_spi_clock_freq() // avr handles spi clock?

{

setSpiFast();

}

void spiInit()

{

fprintf(stderr,"SPI:Init Slow,deselect\n");

}

void mmcChipSelect(int select)

{

spi_chip_select_n = !select;

fprintf(stderr,"SPI:%s\n",select? "Select":"deselect");

}

u08 spiTransferByte(u08 data)

{

fprintf(stderr,"SPI:Send:%02x\n",data);

return 0xff; // TODO...

}

u08 spiTransferFF()

{

return spiTransferByte(0xFF);

}

void spiReceiveData(u08 * from, u08 * to)

{

while (from!=to)

{

*from = spiTransferFF();

++from;

}

}

#include "uart.h"

#include <stdio.h>

char native_command;

char receive_buffer[1024*1024];

int receive_buffer_pos=0;

int receive_buffer_last=0;

void USART_Init( u08 value )

{

fprintf(stderr, "USART_Init:%d\n",value);

}

void USART_Transmit_Byte( unsigned char data )

{

fprintf(stderr, "USART_Transmit:%02x\n", data);

}

unsigned char USART_Receive_Byte( void )

{

unsigned char res = receive_buffer[receive_buffer_pos++];

fprintf(stderr, "USART_Receive:%02x\n",res);

return res;

}

int USART_Data_Ready()

{

return 0;

}

void USART_Transmit_Mode()

{

fprintf(stderr,"USART_Transmit mode\n");

}

void USART_Receive_Mode()

{

fprintf(stderr,"USART_Receive mode\n");

}

int USART_Framing_Error()

{

return 0;

}

void USART_Wait_Transmit_Complete()

{

return;

}

int USART_Command_Line()

{

return native_command;

}

#include "mmc.h"

#include <stdio.h>

FILE * disk_image;

char mmc_sector_buffer[512];

void set_spi_clock_freq()

{

}

//! Initialize AVR<->MMC hardware interface.

/// Prepares hardware for MMC access.

void mmc_init()

{

mmcInit();

}

void mmcInit(void)

{

//disk_image = fopen("/home/markw/fpga/sd_images/sd.image","r+");

//disk_image = fopen("/home/markw/fpga/sd_images/sd_large.image","r+");

//disk_image = fopen("/home/markw/fpga/sd_images/sdimage_elektraglide","r+");

disk_image = fopen("/home/markw/fpga/sd_images/sdimage_mist","r+");

fprintf(stderr,"mmcInit:%x\n",disk_image);

}

//! Initialize the card and prepare it for use.

/// Returns zero if successful.

u08 mmcReset(void){ return 0;}

//! Read 512-byte sector from card to buffer

/// Returns zero if successful.

u08 mmcRead(u32 sector)

{

//fprintf(stderr,"mmcRead:%x\n",sector);

fseek(disk_image, sector*512, SEEK_SET);

fread(&mmc_sector_buffer,512,1,disk_image);

return 0;

}

//! Write 512-byte sector from buffer to card

/// Returns zero if successful.

u08 mmcWrite(u32 sector)

{

fprintf(stderr,"mmcWrite:%x\n",sector);

fseek(disk_image, sector*512, SEEK_SET);

fwrite(&mmc_sector_buffer,512,1,disk_image);

return 0;

}

link ../sd_direct/diskio_mmc.c

#include "joystick.h"

#include <poll.h>

#include <termios.h>

#include <unistd.h>

extern char native_porta;

extern char native_trig;

struct termios oldt, newt;

void term_init()

{

tcgetattr(STDIN_FILENO, &oldt);

newt = oldt;

newt.c_lflag &= ~( ICANON | ECHO );

tcsetattr( STDIN_FILENO, TCSANOW, &newt);

}

void term_close()

{

tcsetattr(STDIN_FILENO, TCSANOW, &oldt);

}

void read_keys()

{

struct pollfd fds[1];

fds[0].fd = STDIN_FILENO;

fds[0].events = POLLIN;

native_porta = 0xff;

native_trig = 0xff;

while (poll(&fds[0], 1, 0))

{

char buffer[0];

read(0,&buffer[0],1);

/* if (buffer[0] == 0x41) fprintf(stderr, "UP\n");

if (buffer[0] == 0x42) fprintf(stderr, "DOWN\n");

if (buffer[0] == 0x44) fprintf(stderr, "LEFT\n");

if (buffer[0] == 0x43) fprintf(stderr, "RIGHT\n");

if (buffer[0] == 0x20) fprintf(stderr, "FIRE\n");*/

// RLDU

if (buffer[0] == 0x41) native_porta=0xff&~(1<<0);

if (buffer[0] == 0x42) native_porta=0xff&~(1<<1);

if (buffer[0] == 0x44) native_porta=0xff&~(1<<2);

if (buffer[0] == 0x43) native_porta=0xff&~(1<<3);

if (buffer[0] == 0x20) native_trig=0xff&~1;

fds[0].fd = STDIN_FILENO;

fds[0].events = POLLIN;

}

}

#include "regs.h"

void joystick_poll(struct joystick_status * status)

{

static int first = 1;

if (first)

{

first = 0;

term_init();

}

read_keys();

status->x_ = 0;

status->y_ = 0;

status->fire_ = 0;

unsigned char porta = *atari_porta;

if (0==(porta&0x2)) // down

{

status->y_ =1;

}

else if (0==(porta&0x1)) // up

{

status->y_ =-1;

}

if (0==(porta&0x8)) // right

{

status->x_ = 1;

}

else if (0==(porta&0x4)) // left

{

status->x_ = -1;

}

if (0==(1&*atari_trig0)) // fire

{

status->fire_ = 1;

}

}

void joystick_wait(struct joystick_status * status, enum JoyWait waitFor)

{

while (1)

{

joystick_poll(status);

switch (waitFor)

{

case WAIT_QUIET:

if (status->x_ == 0 && status->y_ == 0 && status->fire_ == 0) return;

break;

case WAIT_FIRE:

if (status->fire_ == 1) return;

break;

case WAIT_EITHER:

if (status->fire_ == 1) return;

// fall through

case WAIT_MOVE:

if (status->x_ != 0 || status->y_ != 0) return;

break;

}

}

}

void clearscreen()

{

}

#include "regs.h"

char native_porta;

char native_trig;

unsigned char volatile * atari_porta = (unsigned char volatile *)&native_porta;

unsigned char volatile * atari_trig0 = (unsigned char volatile *)&native_trig;

link ../sd_direct/mmc.h

#pragma once

int compare_ext(char const * filename, char const * ext);

#include "uart.h"

#include "regs.h"

void actions();

int USART_Data_Needed()

{

int needed = 0==(0x10&(*zpu_pokey_irqen));

if (needed)

{

*zpu_pokey_irqen = 0x28;

*zpu_pokey_irqen = 0x38;

}

return needed;

}

int USART_Data_Ready()

{

int ready = 0==(0x20&(*zpu_pokey_irqen));

if (ready)

{

*zpu_pokey_irqen = 0x18;

*zpu_pokey_irqen = 0x38;

}

return ready;

}

void USART_Init( u08 value )

{

// value is pokey div + 6

*zpu_pokey_skctl = 0;

wait_us(10);

USART_Receive_Mode(); // turn of reset and listen to commands

*zpu_pokey_audctl = 0x78; // linked channels, fast clocked

*zpu_pokey_audf1 = 0x00;

*zpu_pokey_audf0 = value-6;

*zpu_pokey_audf3 = 0x00;

*zpu_pokey_audf2 = value-6;

*zpu_pokey_irqen = 0x00;

*zpu_pokey_irqen = 0x38;

}

void USART_Transmit_Byte( unsigned char data )

{

*zpu_pokey_serout = data;

// wait until next byte is needed

while (!USART_Data_Needed());

}

unsigned char USART_Receive_Byte( void )

{

// wait for data

while (!USART_Data_Ready())

{

actions();

}

u08 res = *zpu_pokey_serout; //serin at same address

return res;

}

void USART_Transmit_Mode()

{

*zpu_pokey_skctl = 0x23; // 010 for transmission

*zpu_pokey_skrest = 0xff;

*zpu_pokey_irqen = 0x28; // clear data needed

*zpu_pokey_irqen = 0x38;

}

void USART_Receive_Mode()

{

*zpu_pokey_skctl = 0x13; // 001 for receiving

*zpu_pokey_skrest = 0xff;

}

int USART_Framing_Error()

{

if (0xc0&(*zpu_pokey_skctl))

{

return 0;

}

else

{

return 1;

}

}

void USART_Wait_Transmit_Complete()

{

while (1)

{

int ready = 0==(0x08&(*zpu_pokey_irqen));

if (ready)

{

*zpu_pokey_irqen = 0x30;

*zpu_pokey_irqen = 0x38;

return;

}

}

}

int USART_Command_Line()

{

return (1&(*zpu_sio));

}

#include "simpledir.h"

#include "simplefile.h"

#include "atari_drive_emulator.h"

#include "stdio.h"

#include "stdlib.h"

#include <sys/time.h>

extern char native_command;

extern char receive_buffer[];

extern int receive_buffer_pos;

extern int receive_buffer_last;

double start_time;

double now()

{

struct timeval tv;

gettimeofday(&tv,0);

return ((double)tv.tv_sec + (double)tv.tv_usec/1e6);

}

void char_out ( void* p, char c)

{

putc(c, stderr);

}

struct SimpleFile * files[5];

int main(void)

{

init_printf(NULL, char_out);

struct SimpleDirEntry * entry;

char * mem = (char *)malloc(8192);

if (SimpleFile_OK != dir_init(mem, 8192))

{

fprintf(stderr,"Failed to open dir!");

return -1;

}

entry = dir_entries("");

entry = dir_next(dir_next(dir_next(entry)));

fprintf(stderr, " Name:%s", dir_filename(entry));

int i;

for (i=0;i!=5;++i)

{

struct SimpleFile * file = alloca(file_struct_size());

file_init(file);

files[i] = file;

}

//file_open_dir(entry,file);

if (SimpleFile_OK == file_open_name("GUNPOWDR.ATR",files[0]))

{

}

else

{

fprintf(stderr,"\nARG\n");

}

int read = 0;

char buffer[1024];

//file_seek(file,100);

file_read(files[0],&buffer[0],1024,&read);

for (i=0; i!=read; ++i)

{

fprintf(stderr,"|%02x", (unsigned char)buffer[i]);

//fprintf(stderr,"%c", buffer[i]);

}

fprintf(stderr,"\n");

native_command = 1;

init_drive_emulator();

//set_drive_status(0,files[0]);

for (i=1;i!=5;++i)

{

char buffer[20];

describe_disk(i-1,&buffer[0]);

fprintf(stderr, "Drive %d:%s %s\n", i, file_name(get_file_status(i-1)), &buffer[0]);

}

int row = 6;

{

// Swap files

struct SimpleFile * temp = files[row-3];

files[row-3] = files[0];

files[0] = temp;

}

{

// Swap disks

struct SimpleFile * temp = get_drive_status(row-3);

set_drive_status(row-3, get_drive_status(0));

set_drive_status(0,temp);

}

for (i=1;i!=5;++i)

{

char buffer[20];

describe_disk(i-1,&buffer[0]);

fprintf(stderr, "Drive %d:%s %s\n", i, file_name(get_file_status(i-1)), &buffer[0]);

}

start_time = now();

run_drive_emulator();

return 0;

}

void actions()

{

// USART_TransmitByte();

// native_command

double when = now();

if ((when-start_time) > 1.0 && (when-start_time)<1.1)

{

native_command = 0;

static int once = 0;

if (!once)

{

once = 1;

receive_buffer[receive_buffer_last++] = 0x31;

//receive_buffer[receive_buffer_last++] = 0x32;

receive_buffer[receive_buffer_last++] = 0x52;

receive_buffer[receive_buffer_last++] = 0x01;

receive_buffer[receive_buffer_last++] = 0x00;

receive_buffer[receive_buffer_last++] = 0x84;

//receive_buffer[receive_buffer_last++] = 0x85;

}

else

{

native_command = 1;

}

}

else

{

native_command = 1;

}

}

void

wait_us(int unsigned num)

{

usleep(num);

}

char USER_DIR[]="/atari800/user";

char ROM_DIR[]="/atari800/rom";

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/uart.o -c pokey/uart.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/hexdump.o -c hexdump.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/printf.o -c printf/printf.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/pff_file.o -c fat/pff_file.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/pff.o -c fat/pff.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/utils.o -c common/utils.c

zpu-elf-gcc -I. -Isd_direct -Iprintf -Ifat -Icommon -c -g -O2 -DDISABLE_UART_RX -o zpu_obj/diskio_mmc.o -c diskio_mmc.c

zpu-elf-gcc -nostartfiles -Wl,--relax -g -Os -T ./standalone_simple.ld -o JustStartAtari.elf mycrt0.s zpu_obj/main.o zpu_obj/regs.o zpu_obj/atari_drive_emulator.o zpu_obj/pokey/uart.o zpu_obj/hexdump.o zpu_obj/printf/printf.o zpu_obj/fat/pff_file.o zpu_obj/fat/pff.o zpu_obj/common/utils.o zpu_obj/diskio_mmc.o

zpu-elf-objcopy -O binary JustStartAtari.elf JustStartAtari.bin

echo >JustStartAtari.rpt -n "End of code:\t"

zpu-elf-objdump -x JustStartAtari.elf | grep >>JustStartAtari.rpt _romend

echo >>JustStartAtari.rpt -n "Start of BSS:\t"

zpu-elf-objdump -x JustStartAtari.elf | grep >>JustStartAtari.rpt __bss_start__

echo >>JustStartAtari.rpt -n "End of BSS:\t"

zpu-elf-objdump -x JustStartAtari.elf | grep >>JustStartAtari.rpt __bss_end__

cat JustStartAtari.rpt

#include "simpledir.h"

#include "simplefile.h"

#include "fileselector.h"

//#include "fat/pff_file.h"

// XXX - BEST NOT to include this?

char USER_DIR[]="/";

char ROM_DIR[]="/atari800/rom";

#include "stdio.h"

#include "stdlib.h"

int debug_pos = 0;

int prev_debug_pos = 0;

int debug_adjust = 0;

void wait_us(int us)

{

usleep(us);

}

struct SimpleFile * file;

#define ROM_MEM 0x700000

void char_out ( void* p, char c)

{

if (debug_pos!=prev_debug_pos)

{

fprintf(stderr,"\n");

}

//fprintf(stderr,"\n%dWTFWTF\n", debug_pos);

if (debug_adjust == 128)

{

putc('*',stderr);

}

putc(c, stderr);

++debug_pos;

prev_debug_pos = debug_pos;

}

struct SimpleFile * temp_file;

/*void loadrom(char const * path, int size, void * ram_address)

{

filter = 0;

fprintf(stderr,"loadrom:%s\n",path);

ram_address += 0x800000;

if (SimpleFile_OK == file_open_name(path, temp_file))

{

int read = 0;

//file_read(temp_file, ram_address, size, &read);

printf("file_read:%s %x %x\n",file_name(temp_file), ram_address,size);

}

else

{

printf("%s:FAILED\n",path);

}

}*/

void loadromfile(struct SimpleFile * file, int size, void * ram_address)

{

ram_address += 0x800000;

int read = 0;

//file_read(file, ram_address, size, &read);

printf("file_read:%s %x %x\n",file_name(temp_file), ram_address,size);

}

void loadrom(char const * path, int size, void * ram_address)

{

if (SimpleFile_OK == file_open_name(path, temp_file))

{

loadromfile(temp_file, size, ram_address);

}

else

{

printf("%s:FAILED\n",path);

}

}

void loadrom_indir(struct SimpleDirEntry * entries, char const * filename, int size, void * ram_address)

{

if (SimpleFile_OK == file_open_name_in_dir(entries, filename, temp_file))

{

loadromfile(temp_file, size, ram_address);

}

else

{

printf("FAILED\n");

}

}

void loadosrom()

{

if (file_size(file) == 0x0800)

{

printf("Hello world!\n");

int i=0;

unsigned char * src = (unsigned char *)(ROM_MEM + 0x4000);

unsigned char * dest1 = (unsigned char *)(ROM_MEM + 0x4800);

loadromfile(file,0x0800, (void *)(ROM_MEM + 0x4000));

for (i=0; i!=0x800; ++i)

{

dest1[i] = src[i];

}

}

else if (file_size(file) == 0x4000)

{

loadromfile(file,0x4000, (void *)(ROM_MEM + 0x4000));

}

else if (file_size(file) ==0x2800)

{

loadromfile(file,0x2800, (void *)(ROM_MEM + 0x5800));

}

}

int main(void)

{

init_printf(NULL, char_out);

char * mem = (char *)malloc(65536);

if (SimpleFile_OK != dir_init(mem, 65536))

{

fprintf(stderr,"Failed to open dir!");

return -1;

}

struct SimpleDirEntry * entry = dir_entries("");

while (entry)

{

fprintf(stderr, "Path:%s", dir_path(entry));

fprintf(stderr, " Name:%s", dir_filename(entry));

fprintf(stderr, " Size:%d", dir_filesize(entry));

fprintf(stderr, " Subdir:%d\n", dir_is_subdir(entry));

entry = dir_next(entry);

}

fprintf(stderr,"\n\n");

entry = dir_entries("/atari800");

while (entry)

{

fprintf(stderr, "Path:%s", dir_path(entry));

fprintf(stderr, " Name:%s", dir_filename(entry));

fprintf(stderr, " Size:%d", dir_filesize(entry));

fprintf(stderr, " Subdir:%d\n", dir_is_subdir(entry));

entry = dir_next(entry);

}