void midi_run(void *param) {
// Sound settings
int dsp_bits = 16;
int dsp_rate = 22000;
// Init sound
tones_init(WAVE_SQUARE);
//tones_init(WAVE_SINE);
midi_init();
midi_play(&hes_a_pirate);
// Open audio device
int sound_file = open("/dev/dsp", O_WRONLY);
// Set proper playback parameters
ioctl(sound_file, SOUND_PCM_WRITE_BITS, &dsp_bits);
ioctl(sound_file, SOUND_PCM_WRITE_RATE, &dsp_rate);
// Main loop
while (1) {
// Get data from midi player
int16_t data = midi_tick();
// Write to audio device
write(sound_file, &data, 2);
}
// Close audio device
close(sound_file);
return 0;
}
int main(void) {
MidiMessage* msg;
// Halt the watchdog timer - According to the datasheet the watchdog timer
// starts automatically after powerup. It must be configured or halted at
// the beginning of code execution to avoid a system reset. Furthermore,
// the watchdog timer register (WDTCTL) is password protected, and requires
// the upper byte during write operations to be 0x5A, which is the value
// associated with WDTPW.
WDTCTL = WDTPW + WDTHOLD;
// Initialize MIDI using USCI for input only
midi_init(MIDI_MODE_USCI, MIDI_DIR_IN);
// Listen to channel 0-15 (first nibble) with a mask including all
// channels (second nibble)
midi_set_channel_mask(0xFF);
while(1) {
// Poll for a message, if true we go ahead and read the
// prepared MIDI message
if (midi_poll()) {
msg = (MidiMessage*)midi_read();
}
}
}
void App::config_open(){
system("config.txt");
load_config();
midi_close(midi_device);
midi_device = midi_init();
echo("Wczytano nowe ustawienia.");
}
//--------------------------------------------------------------------
// name: main
// desc: entry point
//--------------------------------------------------------------------
int main (int argc, char ** argv)
{
ipData *ipAdds = new ipData;
// Command Line parsing
//---------------------
if( argc == 2 && strcmp(argv[1], "-help") == 0)
{
usage();
exit(0);
}
else if ( argc == 4 ) {
ipAdds->hostName = argv[1];
ipAdds->inPort = atoi(argv[2]);
ipAdds->outPort = atoi(argv[3]);
}
else {
usage();
exit(0);
}
Thread listenerThread;
// start the OSC listener thread
bool success = listenerThread.start( oscListener, (void *)ipAdds );
if( !success )
{
cerr << "Error when creating listener thread!" << endl;
exit(1);
}
midi_init((void *)ipAdds);
delete ipAdds;
return 0;
}
int
SND_LoadMidi (QFile *file, sfx_t *sfx, char *realname)
{
wavinfo_t info;
midi *handle;
unsigned char *local_buffer;
unsigned long int local_buffer_size = Qfilesize (file);
if (!midi_intiialized) {
if (midi_init ()) {
return -1;
}
}
local_buffer = malloc (local_buffer_size);
Qread (file, local_buffer, local_buffer_size);
Qclose (file);
// WildMidi takes ownership, so be damned if you touch it
handle = WildMidi_OpenBuffer (local_buffer, local_buffer_size);
if (handle == NULL)
return -1;
info = midi_get_info (handle);
WildMidi_Close (handle);
Sys_MaskPrintf (SYS_DEV, "stream %s\n", realname);
// we init stream here cause we will only ever stream
SND_SFX_Stream (sfx, realname, info, midi_stream_open);
return 0;
}
void notmain() {
gpio_init();
timer_init();
midi_init();
midi_set_channel(CHANNEL_BEATS);
while (1) {
unsigned i;
for (i = 0; i < sizeof(beats); i++) {
midi_note_on(beats[i], 64);
timer_wait_for(250000);
midi_note_off(beats[i], 64);
led_toggle();
}
}
while (1) {
unsigned i;
for (i = 20; i < 80; i += 5) {
midi_note_on(i, 64);
timer_wait_for(250000);
midi_note_off(i, 64);
led_toggle();
}
}
}
int main(void)
{
volatile uint16_t i;
/* BLINK LED FOR A SHORT TIME AT RESET. */
/* PD0 is output. */
DDRD = 0x02;
/* Write data on port. */
PORTD = 0x00;
i = 0;
do {
i--;
} while(i);
PORTD = 0x02;
dac_init();
uart_init();
midi_init();
struct midi_msg *m;
while(1) {
m = midi_msg_get();
if (NULL != m) {
if (midi_msg_is_note_on(m)) {
dac_write(m->data1, DAC_A);
}
}
}
}
void *dspio_init(void)
{
struct dspio_state *state;
state = malloc(sizeof(struct dspio_state));
if (!state)
return NULL;
memset(&state->dma, 0, sizeof(struct dspio_dma));
state->input_running = state->pcm_input_running =
state->lin_input_running = state->mic_input_running =
state->output_running = state->dac_running = state->speaker = 0;
state->dma.dsp_fifo_enabled = 1;
rng_init(&state->fifo_in, DSP_FIFO_SIZE, 2);
rng_init(&state->fifo_out, DSP_FIFO_SIZE, 2);
rng_init(&state->midi_fifo_in, MIDI_FIFO_SIZE, 1);
rng_init(&state->midi_fifo_out, MIDI_FIFO_SIZE, 1);
state->i_handle = pcm_register_player(&player, state);
pcm_init();
pcm_set_volume_cb(dspio_get_volume);
pcm_set_connected_cb(dspio_is_connected);
state->dac_strm = pcm_allocate_stream(1, "SB DAC", (void*)MC_VOICE);
pcm_set_flag(state->dac_strm, PCM_FLAG_RAW);
state->dma_strm = pcm_allocate_stream(2, "SB DMA", (void*)MC_VOICE);
pcm_set_flag(state->dma_strm, PCM_FLAG_SLTS);
midi_init();
return state;
}
void retro_init()
{
int frames = 0;
int c, d;
install_timer();
install_int_ex(timer_rout, BPS_TO_TIMER(100));
install_int_ex(onesec, BPS_TO_TIMER(1));
midi_init();
initpc();
struct retro_log_callback log;
unsigned colorMode = RETRO_PIXEL_FORMAT_XRGB8888;
screen_pitch = 0;
if (environ_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log))
log_cb = log.log;
else
log_cb = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_PERF_INTERFACE, &perf_cb))
perf_get_cpu_features_cb = perf_cb.get_cpu_features;
else
perf_get_cpu_features_cb = NULL;
environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &colorMode);
environ_cb(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumble);
}
struct mpu401 *
mpu401_init(kobj_class_t cls, void *cookie, driver_intr_t softintr,
mpu401_intr_t ** cb)
{
struct mpu401 *m;
*cb = NULL;
m = malloc(sizeof(*m), M_MIDI, M_NOWAIT | M_ZERO);
if (!m)
return NULL;
kobj_init((kobj_t)m, cls);
callout_init(&m->timer, CALLOUT_MPSAFE);
m->si = softintr;
m->cookie = cookie;
m->flags = 0;
m->mid = midi_init(&mpu401_class, 0, 0, m);
if (!m->mid)
goto err;
*cb = mpu401_intr;
return m;
err:
printf("mpu401_init error\n");
free(m, M_MIDI);
return NULL;
}
void App::wm_create(HWND *window){
hwnd = *window;
//kontrolki
hctrl[0]=CreateWindowEx(WS_EX_CLIENTEDGE,WC_EDIT,"",WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL,0,20,window_w,20,hwnd,0,*hInst,0); //wiersz poleceñ
hctrl[1]=CreateWindowEx(0,WC_STATIC,"",WS_CHILD|WS_VISIBLE|SS_CENTER|SS_CENTERIMAGE,0,0,window_w,20,hwnd,0,*hInst,0); //konsola
hctrl[2]=CreateWindowEx(0,WC_BUTTON,"Przechwytywanie klawiszy [F11]",WS_CHILD|WS_VISIBLE|BS_CHECKBOX,25,40,180,20,hwnd,(HMENU)1,*hInst,0);
//groupbox1
hctrl[3]=CreateWindowEx(0,WC_BUTTON,"Akordy",WS_CHILD|WS_VISIBLE|BS_GROUPBOX,10,60,window_w-20,150,hwnd,(HMENU)0,*hInst,0);
for(int i=0; i<12; i++){
hctrl[4+i]=CreateWindowEx(0,WC_BUTTON,"",WS_CHILD|WS_VISIBLE,20+(i%3)*60,80+(i/3)*30,60,30,hwnd,(HMENU)(2+i),*hInst,0);
}
//groupbox2
hctrl[16]=CreateWindowEx(0,WC_BUTTON,"Rodzaj akordu",WS_CHILD|WS_VISIBLE|BS_GROUPBOX,10,215,window_w-20,140,hwnd,(HMENU)0,*hInst,0);
hctrl[17]=CreateWindowEx(0,WC_BUTTON,"Pojedynczy dŸwiêk",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,230,160,20,hwnd,(HMENU)14,*hInst,0);
hctrl[18]=CreateWindowEx(0,WC_BUTTON,"Power chord",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,250,160,20,hwnd,(HMENU)15,*hInst,0);
hctrl[19]=CreateWindowEx(0,WC_BUTTON,"Akord molowy",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,270,160,20,hwnd,(HMENU)16,*hInst,0);
hctrl[20]=CreateWindowEx(0,WC_BUTTON,"Akord durowy",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,290,160,20,hwnd,(HMENU)17,*hInst,0);
hctrl[21]=CreateWindowEx(0,WC_BUTTON,"Akord molowy septymowy",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,310,160,20,hwnd,(HMENU)18,*hInst,0);
hctrl[22]=CreateWindowEx(0,WC_BUTTON,"Akord durowy septymowy",WS_CHILD|WS_VISIBLE|BS_RADIOBUTTON,30,330,160,20,hwnd,(HMENU)19,*hInst,0);
//kapodaster
hctrl[23]=CreateWindowEx(0,WC_STATIC,"Kapodaster",WS_CHILD|WS_VISIBLE|SS_CENTER|SS_CENTERIMAGE,55,360,110,25,hwnd,0,*hInst,0);
hctrl[24]=CreateWindowEx(0,WC_BUTTON,"-1",WS_CHILD|WS_VISIBLE,30,360,25,25,hwnd,(HMENU)20,*hInst,0);
hctrl[25]=CreateWindowEx(0,WC_BUTTON,"+1",WS_CHILD|WS_VISIBLE,165,360,25,25,hwnd,(HMENU)21,*hInst,0);
hctrl[26]=CreateWindowEx(0,WC_BUTTON,"-12",WS_CHILD|WS_VISIBLE,5,360,25,25,hwnd,(HMENU)22,*hInst,0);
hctrl[27]=CreateWindowEx(0,WC_BUTTON,"+12",WS_CHILD|WS_VISIBLE,190,360,25,25,hwnd,(HMENU)23,*hInst,0);
//g³oœnoœæ
hctrl[28]=CreateWindowEx(0,WC_STATIC,"G³oœnoœæ",WS_CHILD|WS_VISIBLE|SS_CENTER|SS_CENTERIMAGE,60,390,100,25,hwnd,0,*hInst,0);
hctrl[29]=CreateWindowEx(0,WC_BUTTON,"-",WS_CHILD|WS_VISIBLE,30,390,25,25,hwnd,(HMENU)24,*hInst,0);
hctrl[30]=CreateWindowEx(0,WC_BUTTON,"+",WS_CHILD|WS_VISIBLE,165,390,25,25,hwnd,(HMENU)25,*hInst,0);
//haki
hExe = GetModuleHandle(NULL);
hHookkb = SetWindowsHookEx(WH_KEYBOARD_LL, hpkb, hExe, 0);
//ustawienia
load_config();
//ustawienia pocz¹tkowe
checkbox1_click(1);
radiobutton1_click(2);
kapodaster=0;
capo_add(0);
volume=100;
volume_add(0);
//czcionki
fontsize=13;
fontface="MS Shell Dlg 2";
for(int i=0; i<ctrls_num; i++){
change_font(hctrl[i]);
}
SetFocus(hctrl[0]);
//subclassing
subclass(0);
//midi init
midi_device=midi_init();
echo("wersja "+version);
}
int musmidi_init() {
int st = midi_init(&prv.mididev);
if (st == -1) {
prv.midi_valid = FALSE;
return NG;
} else {
prv.midi_valid = TRUE;
prv.midi.dev = &prv.mididev;
prv.midi.st = MIDI_NOP;
return OK;
}
}
int main(int argc, const char * argv[]) {
PaStream *stream;
PaError err;
synth s = synth_new();
//synth_add_oscillator(s, osc_new(440.0f, OSC_TYPE_SINE));
//synth_add_oscillator(s, osc_new(880.0f, OSC_TYPE_SINE));
//synth_add_oscillator(s, osc_new(1760.0f, OSC_TYPE_SINE));
//synth_add_oscillator(s, osc_new(1108.7f, OSC_TYPE_SQUARE));
/* Test that you can't add more than 4 oscillators */
//synth_add_oscillator(s, osc_new(440.0f, OSC_TYPE_SINE));
synth_set_envelope(s, env_new(0.005, 0.625, 0.5, 0.5, ENVELOPE_TYPE_EXPONENTIAL));
midi_init();
/* Play every other note. Impossible for a human */
// for (i = 0; i < NUM_MIDI_NOTES / 2; ++i) {
// synth_add_note(s, 2*i, 90);
// }
/* A440 100% volume */
/*synth_add_note(s, 69, 90);
synth_add_note(s, 57, 90);
synth_add_note(s, 81, 90);
synth_add_note(s, 45, 90);*/
err = Pa_Initialize();
CHK(err);
err = Pa_OpenDefaultStream(&stream, 0, 1, paFloat32, SR, 512, callback, (void*)s);
CHK(err);
err = Pa_StartStream(stream);
CHK(err);
midi_loop(s);
err = Pa_StopStream(stream);
CHK(err);
err = Pa_CloseStream(stream);
CHK(err);
Pa_Terminate();
synth_destroy(s);
midi_terminate();
return 0;
}
void
setup_jack ( )
{
const char *jack_name;
jack_name = midi_init( instance_name );
if ( ! jack_name )
ASSERTION( "Could not initialize MIDI system! (is Jack running and with MIDI ports enabled?)" );
if ( ! transport.valid )
{
if ( transport.master )
ASSERTION( "The version of JACK you are using does not appear to be capable of passing BBT positional information." );
else
ASSERTION( "Either the version of JACK you are using does pass BBT information, or the current timebase master does not provide it." );
}
}
//=======================================================
// main関数
//=======================================================
int main( int argc, char **argv )
{
// GLUTの初期化
glutInit( &argc, argv );
// ARアプリケーションの初期化
Init();
midi_init();
// ビデオキャプチャの開始
arVideoCapStart();
// メインループの開始
argMainLoop( MouseEvent, KeyEvent, MainLoop );
return 0;
}
int main (int argc, char *argv[]) {
// Init sound
tones_init(WAVE_SQUARE);
midi_init();
midi_play(&mario);
// Init hardware
initHardware();
// Main loop
while (1) {
// Get data from midi player
abdac_output = midi_tick();
// Wait for next interrupt (Assume abdac)
asm("sleep 1");
}
return 0;
}
int main (void)
{
midi_init();
// Play a chord
midi_write(Pm_Message(0x90, 60, 100));
midi_write(Pm_Message(0x90, 64, 100));
midi_write(Pm_Message(0x90, 67, 100));
midi_flush();
printf("num_devices: %i\n",Pm_CountDevices());
PmDeviceID id = Pm_GetDefaultOutputDeviceID();
const PmDeviceInfo* device = Pm_GetDeviceInfo(id);
printf("%s\n", device->name);
char setchar = '.';
int channel = 0;
while (setchar!='\e'){
scanf(" %c", &setchar);
//printf("%c\n", setchar);
switch (setchar){
case 'z': channel = 0xB0; break;
case 'x': channel = 0xB1; break;
case 'c': channel = 0xB2; break;
case 'v': channel = 0xB3; break;
// 'q': Pm_WriteShort(midi, 0, Pm_Message(channel, 10, 0)); //button1
// 'w': Pm_WriteShort(midi, 0, Pm_Message(channel, 11, 0)); //button2
// 'e': Pm_WriteShort(midi, 0, Pm_Message(channel, 12, 0)); //button3
// 'r': Pm_WriteShort(midi, 0, Pm_Message(channel, 13, 0)); //button4
case '1': midi_write(Pm_Message(channel, 0, 0)); midi_flush(); break;
case '2': midi_write(Pm_Message(channel, 1, 0)); midi_flush(); break;//hand angle
// '7': Pm_WriteShort(midi, 0, Pm_Message(channel, 7, 0));
// '8': Pm_WriteShort(midi, 0, Pm_Message(channel, 8, 0));
// '9': Pm_WriteShort(midi, 0, Pm_Message(channel, 9, 0));
// '0': Pm_WriteShort(midi, 0, Pm_Message(channel, 10, 0));
default:
break;
}
}
void osd_interface::init_subsystems()
{
if (!video_init())
{
video_exit();
osd_printf_error("video_init: Initialization failed!\n\n\n");
fflush(stderr);
fflush(stdout);
exit(-1);
}
sound_init();
input_init();
// we need pause callbacks
machine().add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(osd_interface::input_pause), this));
machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(osd_interface::input_resume), this));
output_init();
#ifdef USE_NETWORK
network_init();
#endif
midi_init();
}
void resetpchard()
{
if (!modelchanged)
device_close_all();
else
modelchanged = 0;
device_init();
midi_close();
midi_init();
timer_reset();
sound_reset();
mem_resize();
if (pcfirsttime)
{
fdc_init();
pcfirsttime = 0;
}
else
fdc_hard_reset();
model_init();
video_init();
speaker_init();
// #ifdef USE_NETWORKING
vlan_reset(); //NETWORK
network_card_init(network_card_current);
// #endif
sound_card_init(sound_card_current);
if (GUS)
device_add(&gus_device);
if (GAMEBLASTER)
device_add(&cms_device);
if (SSI2001)
device_add(&ssi2001_device);
if (voodoo_enabled)
device_add(&voodoo_device);
pc_reset();
resetide();
loadnvr();
// cpuspeed2 = (AT)?2:1;
// atfullspeed = 0;
// setpitclock(models[model].cpu[cpu_manufacturer].cpus[cpu].rspeed);
shadowbios = 0;
ali1429_reset();
keyboard_at_reset();
// output=3;
#if __unix
if (cdrom_drive == -1)
cdrom_null_reset();
else
#endif
ioctl_reset();
}
void initpc()
{
char *p;
// allegro_init();
get_executable_name(pcempath,511);
pclog("executable_name = %s\n", pcempath);
p=get_filename(pcempath);
*p=0;
pclog("path = %s\n", pcempath);
fdd_init();
keyboard_init();
mouse_init();
joystick_init();
midi_init();
loadconfig(NULL);
pclog("Config loaded\n");
loadfont("mda.rom", 0, cga_fontdat, cga_fontdatm);
loadfont("roms/pc1512/40078.ic127", 0, pc1512_fontdat, pc1512_fontdatm);
loadfont("roms/pc200/40109.bin", 0, pc200_fontdat, pc200_fontdatm);
codegen_init();
cpuspeed2=(AT)?2:1;
// cpuspeed2=cpuspeed;
atfullspeed=0;
device_init();
initvideo();
mem_init();
loadbios();
mem_add_bios();
timer_reset();
sound_reset();
fdc_init();
// #ifdef USE_NETWORKING
vlan_reset(); //NETWORK
network_card_init(network_card_current);
// #endif
loaddisc(0,discfns[0]);
loaddisc(1,discfns[1]);
//loadfont();
loadnvr();
sound_init();
resetide();
#if __unix
if (cdrom_drive == -1)
cdrom_null_open(cdrom_drive);
else
#endif
ioctl_open(cdrom_drive);
pit_reset();
/* if (romset==ROM_AMI386 || romset==ROM_AMI486) */fullspeed();
ali1429_reset();
// CPUID=(is486 && (cpuspeed==7 || cpuspeed>=9));
// pclog("Init - CPUID %i %i\n",CPUID,cpuspeed);
shadowbios=0;
#if __unix
if (cdrom_drive == -1)
cdrom_null_reset();
else
#endif
ioctl_reset();
}
/* Driver initialization routine */
static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
{
struct emu10k1_card *card;
if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "emu10k1: out of memory\n");
return -ENOMEM;
}
memset(card, 0, sizeof(struct emu10k1_card));
#if LINUX_VERSION_CODE > 0x020320
if (!pci_dma_supported(pci_dev, EMU10K1_DMA_MASK)) {
printk(KERN_ERR "emu10k1: architecture does not support 32bit PCI busmaster DMA\n");
kfree(card);
return -ENODEV;
}
if (pci_enable_device(pci_dev)) {
printk(KERN_ERR "emu10k1: couldn't enable device\n");
kfree(card);
return -ENODEV;
}
pci_set_master(pci_dev);
card->iobase = pci_dev->resource[0].start;
if (request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]) == NULL) {
printk(KERN_ERR "emu10k1: IO space in use\n");
kfree(card);
return -ENODEV;
}
pci_dev->driver_data = card;
pci_dev->dma_mask = EMU10K1_DMA_MASK;
#else
pci_set_master(pci_dev);
card->iobase = pci_dev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
if (check_region(card->iobase, EMU10K1_EXTENT)) {
printk(KERN_ERR "emu10k1: IO space in use\n");
kfree(card);
return -ENODEV;
}
request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]);
#endif
card->irq = pci_dev->irq;
card->pci_dev = pci_dev;
/* Reserve IRQ Line */
if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
printk(KERN_ERR "emu10k1: IRQ in use\n");
goto err_irq;
}
pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
printk(KERN_INFO "emu10k1: %s rev %d found at IO 0x%04lx, IRQ %d\n", card_names[pci_id->driver_data], card->chiprev, card->iobase, card->irq);
spin_lock_init(&card->lock);
card->mixeraddx = card->iobase + AC97DATA;
init_MUTEX(&card->open_sem);
card->open_mode = 0;
init_waitqueue_head(&card->open_wait);
/* Register devices */
if ((card->audio1_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register first audio device!\n");
goto err_dev0;
}
if ((card->audio2_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register second audio device!\n");
goto err_dev1;
}
if ((card->mixer_num = register_sound_mixer(&emu10k1_mixer_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register mixer device!\n");
goto err_dev2;
}
if ((card->midi_num = register_sound_midi(&emu10k1_midi_fops, -1)) < 0) {
printk(KERN_ERR "emu10k1: cannot register midi device!\n");
goto err_dev3;
}
if (emu10k1_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize device!\n");
goto err_emu10k1_init;
}
if (audio_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize audio!\n");
goto err_audio_init;
}
if (midi_init(card) != CTSTATUS_SUCCESS) {
printk(KERN_ERR "emu10k1: cannot initialize midi!\n");
goto err_midi_init;
}
mixer_init(card);
DPD(2, "Hardware initialized. TRAM allocated: %u bytes\n", (unsigned int) card->tmemsize);
list_add(&card->list, &emu10k1_devs);
return 0;
err_midi_init:
audio_exit(card);
err_audio_init:
emu10k1_exit(card);
err_emu10k1_init:
unregister_sound_midi(card->midi_num);
err_dev3:
unregister_sound_mixer(card->mixer_num);
err_dev2:
unregister_sound_dsp(card->audio2_num);
err_dev1:
unregister_sound_dsp(card->audio1_num);
err_dev0:
free_irq(card->irq, card);
err_irq:
release_region(card->iobase, EMU10K1_EXTENT);
kfree(card);
return -ENODEV;
}
int main(int argc, char *argv[])
{
int c;
struct state *state = NULL;
#if TEST_BUILD
struct test_case *test_case;
#endif
prefs_init();
while(1) {
int option_index = 0;
static struct option long_options[] = {
{"cart", required_argument, 0, OPT_CART },
{"force-extreme-disasm", no_argument, 0, OPT_FORCE_EXTREME_DISASM },
{"crop-screen", no_argument, 0, OPT_CROP_SCREEN },
{"loglevels" , required_argument, 0, OPT_LOGLEVELS },
{"audio-device" , required_argument, 0, OPT_AUDIO_DEVICE },
#if TEST_BUILD
{"test-case", required_argument, 0, OPT_TEST_MODE},
#endif
{0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "a:b:c:t:s:hdpyVAMvq", long_options, &option_index);
if(c == -1) break;
switch(c) {
case 'a':
prefs_set("diskimage", optarg);
break;
case 'b':
prefs_set("diskimage2", optarg);
break;
case 'c':
prefs_set("hdimage", optarg);
break;
case 't':
prefs_set("tosimage", optarg);
break;
case 's':
prefs_set("stateimage", optarg);
break;
case OPT_CART:
prefs_set("cartimage", optarg);
break;
case OPT_FORCE_EXTREME_DISASM:
cprint_all = 1;
break;
case OPT_CROP_SCREEN:
crop_screen = 1;
break;
case OPT_LOGLEVELS:
diag_set_module_levels(optarg);
break;
case OPT_AUDIO_DEVICE:
if(!strncmp("list", optarg, 4)) {
audio_device = -1;
} else {
audio_device = atoi(optarg);
}
break;
#if TEST_BUILD
case OPT_TEST_MODE:
test_case_name = xstrdup(optarg);
test_mode = 1;
break;
#endif
case 'd':
debugger = 1;
break;
case 'p':
ppmoutput = 1;
break;
case 'y':
psgoutput = 1;
break;
case 'v':
verbosity++;
break;
case 'q':
verbosity = MAX(1, verbosity-1);
break;
case 'V':
vsync_delay = 1;
break;
case 'A':
play_audio = 1;
break;
case 'M':
monitor_sm124 = 1;
break;
case 'h':
default:
printf("Usage: %s [-AdMpqvVy] [-a diskimage1] [-b diskimage2] [-c hdimage] [-t tosimage] [-s stateimage]\n",
argv[0]);
exit(-1);
break;
}
}
/* Do not crop screen while debugging */
if(debugger) {
crop_screen = 0;
}
if((prefs.diskimage == NULL) && (argv[optind] != NULL))
prefs_set("diskimage", argv[optind]);
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_AUDIO);
#if TEST_BUILD
if(test_mode) {
test_case = test_init(test_case_name);
if(test_case) {
if(test_case->cartridge_name) {
prefs_set("cartimage", test_case->cartridge_name);
}
if(test_case->floppy_name) {
prefs_set("diskimage", test_case->floppy_name);
}
} else {
printf("DEBUG: Could not load test case %s\n", test_case_name);
exit(-3);
}
}
#endif
/* Must run before hardware module inits */
mmu_init();
/* This must also be run before hardware modules.
It gives a dummy area for some memory regions to not
cause bus errors */
mmu_fallback_init();
/* Actual hardware */
ram_init();
rom_init();
cpu_init();
if(prefs.cartimage) {
cartridge_init(prefs.cartimage);
} else {
cartridge_init(NULL);
}
psg_init();
midi_init();
acia_init();
ikbd_init();
#if INCLUDE_RTC
rtc_init();
#endif
dma_init();
fdc_init();
hdc_init(prefs.hdimage);
mfp_init();
screen_disable(0);
glue_init();
shifter_init();
if(debugger) {
debug_init();
cpu_halt_for_debug();
}
screen_init();
floppy_init(prefs.diskimage, prefs.diskimage2);
if(prefs.stateimage) {
state = state_load(prefs.stateimage);
}
if(state != NULL)
state_restore(state);
memset(&reset, 0, sizeof reset);
reset.sa_sigaction = reset_action;
sigaction(SIGHUP, &reset, NULL);
while(cpu_run(CPU_RUN));
return 0;
}
void main_init(int argc, char *argv[])
{
char t[512], *p;
int c;
int tapenext = 0, discnext = 0;
startblit();
log_open();
log_info("main: starting %s", VERSION_STR);
vid_fskipmax = 1;
al_init_main(argc, argv);
append_filename(t, exedir, "roms/tube/ReCo6502ROM_816", 511);
if (!file_exists(t,FA_ALL,NULL) && selecttube == 4) selecttube = -1;
curtube = selecttube;
model_check();
for (c = 1; c < argc; c++)
{
// log_debug("%i : %s",c,argv[c]);
/* if (!strcasecmp(argv[c],"-1770"))
{
I8271=0;
WD1770=1;
}
else*/
//#ifndef WIN32
if (!strcasecmp(argv[c], "--help"))
{
printf("%s command line options :\n\n", VERSION_STR);
printf("-mx - start as model x (see readme.txt for models)\n");
printf("-tx - start with tube x (see readme.txt for tubes)\n");
printf("-disc disc.ssd - load disc.ssd into drives :0/:2\n");
printf("-disc1 disc.ssd - load disc.ssd into drives :1/:3\n");
printf("-autoboot - boot disc in drive :0\n");
printf("-tape tape.uef - load tape.uef\n");
printf("-fasttape - set tape speed to fast\n");
printf("-s - scanlines display mode\n");
printf("-i - interlace display mode\n");
printf("-debug - start debugger\n");
printf("-allegro - use Allegro for video rendering\n");
exit(-1);
}
else
//#endif
if (!strcasecmp(argv[c], "-tape"))
{
tapenext = 2;
}
else if (!strcasecmp(argv[c], "-disc") || !strcasecmp(argv[c], "-disk"))
{
discnext = 1;
}
else if (!strcasecmp(argv[c], "-disc1"))
{
discnext = 2;
}
else if (argv[c][0] == '-' && (argv[c][1] == 'm' || argv[c][1] == 'M'))
{
sscanf(&argv[c][2], "%i", &curmodel);
}
else if (argv[c][0] == '-' && (argv[c][1] == 't' || argv[c][1] == 'T'))
{
sscanf(&argv[c][2], "%i", &curtube);
}
else if (!strcasecmp(argv[c], "-fasttape"))
{
fasttape = 1;
}
else if (!strcasecmp(argv[c], "-autoboot"))
{
autoboot = 150;
}
else if (argv[c][0] == '-' && (argv[c][1] == 'f' || argv[c][1]=='F'))
{
sscanf(&argv[c][2], "%i", &vid_fskipmax);
if (vid_fskipmax < 1) vid_fskipmax = 1;
if (vid_fskipmax > 9) vid_fskipmax = 9;
}
else if (argv[c][0] == '-' && (argv[c][1] == 's' || argv[c][1] == 'S'))
{
vid_scanlines = 1;
}
else if (!strcasecmp(argv[c], "-debug"))
{
debug_core = 1;
}
else if (!strcasecmp(argv[c], "-debugtube"))
{
debug_tube = 1;
}
else if (argv[c][0] == '-' && (argv[c][1] == 'i' || argv[c][1] == 'I'))
{
vid_interlace = 1;
vid_linedbl = vid_scanlines = 0;
}
else if (tapenext)
strcpy(tape_fn, argv[c]);
else if (discnext)
{
strcpy(discfns[discnext-1], argv[c]);
discnext = 0;
}
else
{
if ((p = strrchr(argv[c], '.')) && (!strcasecmp(p, ".uef") || !strcasecmp(p, ".csw"))) {
strncpy(tape_fn, argv[c], sizeof tape_fn);
tapenext = 0;
}
else {
strncpy(discfns[0], argv[c], sizeof discfns[0]);
discnext = 0;
autoboot = 150;
}
}
if (tapenext) tapenext--;
}
video_init();
mode7_makechars();
#ifndef WIN32
install_keyboard();
#endif
install_timer();
mem_init();
ddnoise_init();
tapenoise_init();
sound_init();
al_init();
sid_init();
sid_settype(sidmethod, cursid);
music5000_init();
adc_init();
#ifdef WIN32
pal_init();
#endif
disc_init();
fdi_init();
scsi_init();
ide_init();
vdfs_init();
model_init();
midi_init();
main_reset();
install_int_ex(secint, MSEC_TO_TIMER(1000));
install_int_ex(int50, MSEC_TO_TIMER(20));
set_display_switch_mode(SWITCH_BACKGROUND);
#ifdef WIN32
timeBeginPeriod(1);
#endif
oldmodel = curmodel;
if (curtube == 3 || mouse_amx) install_mouse();
disc_load(0, discfns[0]);
disc_load(1, discfns[1]);
tape_load(tape_fn);
if (defaultwriteprot) writeprot[0] = writeprot[1] = 1;
endblit();
debug_start();
}
int
main(int argc, char **argv)
{
int c, background, unit;
int pmin, pmax, rmin, rmax;
char base[PATH_MAX], path[PATH_MAX];
unsigned int mode, dup, mmc, vol;
unsigned int hold, autovol, bufsz, round, rate;
const char *str;
struct aparams par;
struct dev *d;
struct port *p;
struct listen *l;
atexit(log_flush);
/*
* global options defaults
*/
vol = 118;
dup = 1;
mmc = 0;
hold = 0;
autovol = 1;
bufsz = 0;
round = 0;
rate = DEFAULT_RATE;
unit = 0;
background = 1;
pmin = 0;
pmax = 1;
rmin = 0;
rmax = 1;
aparams_init(&par);
mode = MODE_PLAY | MODE_REC;
setsig();
filelist_init();
while ((c = getopt(argc, argv, "a:b:c:C:de:f:j:L:m:Mq:r:s:t:U:v:w:x:z:")) != -1) {
switch (c) {
case 'd':
log_level++;
background = 0;
break;
case 'U':
if (listen_list)
errx(1, "-U must come before -L");
unit = strtonum(optarg, 0, 15, &str);
if (str)
errx(1, "%s: unit number is %s", optarg, str);
break;
case 'L':
listen_new_tcp(optarg, AUCAT_PORT + unit);
break;
case 'm':
mode = opt_mode();
break;
case 'j':
dup = opt_onoff();
break;
case 't':
mmc = opt_mmc();
break;
case 'c':
opt_ch(&pmin, &pmax);
break;
case 'C':
opt_ch(&rmin, &rmax);
break;
case 'e':
opt_enc(&par);
break;
case 'r':
rate = strtonum(optarg, RATE_MIN, RATE_MAX, &str);
if (str)
errx(1, "%s: rate is %s", optarg, str);
break;
case 'v':
vol = strtonum(optarg, 0, MIDI_MAXCTL, &str);
if (str)
errx(1, "%s: volume is %s", optarg, str);
break;
case 's':
if ((d = dev_list) == NULL) {
d = mkdev(DEFAULT_DEV, &par, 0, bufsz, round, rate,
hold, autovol);
}
mkopt(optarg, d, pmin, pmax, rmin, rmax,
mode, vol, mmc, dup);
break;
case 'q':
p = port_new(optarg, MODE_MIDIMASK, hold);
if (!p)
errx(1, "%s: can't open port", optarg);
break;
case 'a':
hold = opt_onoff();
break;
case 'w':
autovol = opt_onoff();
break;
case 'b':
bufsz = strtonum(optarg, 1, RATE_MAX, &str);
if (str)
errx(1, "%s: buffer size is %s", optarg, str);
break;
case 'z':
round = strtonum(optarg, 1, SHRT_MAX, &str);
if (str)
errx(1, "%s: block size is %s", optarg, str);
break;
case 'f':
mkdev(optarg, &par, 0, bufsz, round, rate, hold, autovol);
break;
case 'M':
/* XXX: for compatibility with aucat, remove this */
break;
default:
fputs(usagestr, stderr);
return 1;
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
fputs(usagestr, stderr);
return 1;
}
if (dev_list == NULL)
mkdev(DEFAULT_DEV, &par, 0, bufsz, round, rate, hold, autovol);
for (d = dev_list; d != NULL; d = d->next) {
if (opt_byname("default", d->num))
continue;
mkopt("default", d, pmin, pmax, rmin, rmax,
mode, vol, mmc, dup);
}
getbasepath(base, sizeof(base));
snprintf(path, PATH_MAX, "%s/%s%u", base, AUCAT_PATH, unit);
listen_new_un(path);
if (geteuid() == 0)
privdrop();
midi_init();
for (p = port_list; p != NULL; p = p->next) {
if (!port_init(p))
return 1;
}
for (d = dev_list; d != NULL; d = d->next) {
if (!dev_init(d))
return 1;
}
for (l = listen_list; l != NULL; l = l->next) {
if (!listen_init(l))
return 1;
}
if (background) {
log_flush();
log_level = 0;
if (daemon(0, 0) < 0)
err(1, "daemon");
}
/*
* Loop, start audio.
*/
for (;;) {
if (quit_flag)
break;
if (!file_poll())
break;
}
while (listen_list != NULL)
listen_close(listen_list);
while (sock_list != NULL)
sock_close(sock_list);
while (opt_list != NULL)
opt_del(opt_list);
for (d = dev_list; d != NULL; d = d->next)
dev_done(d);
for (p = port_list; p != NULL; p = p->next)
port_done(p);
midi_done();
while (file_poll())
; /* nothing */
while (dev_list)
dev_del(dev_list);
while (port_list)
port_del(port_list);
filelist_done();
rmdir(base);
unsetsig();
return 0;
}
/* VIC20-specific initialization. */
int machine_specific_init(void)
{
int delay;
vic20_log = log_open("VIC20");
if (mem_load() < 0) {
return -1;
}
event_init();
/* Setup trap handling. */
traps_init();
if (!video_disabled_mode) {
joystick_init();
}
gfxoutput_init();
/* Initialize serial traps. If user does not want them, or if the
``drive'' emulation is used, do not install them. */
if (serial_init(vic20_serial_traps) < 0) {
return -1;
}
serial_trap_init(0xa4);
serial_iec_bus_init();
/* Initialize RS232 handler. */
rs232drv_init();
vic20_rsuser_init();
/* initialize print devices. */
printer_init();
/* Initialize the tape emulation. */
tape_init(&tapeinit);
/* Initialize the datasette emulation. */
datasette_init();
/* Fire up the hardware-level drive emulation. */
drive_init();
disk_image_init();
/* Initialize autostart. */
resources_get_int("AutostartDelay", &delay);
if (delay == 0) {
delay = 3; /* default */
}
autostart_init((CLOCK)
(delay * VIC20_PAL_RFSH_PER_SEC * VIC20_PAL_CYCLES_PER_RFSH),
1, 0xcc, 0xd1, 0xd3, 0xd5);
#ifdef USE_BEOS_UI
/* Pre-init VIC20-specific parts of the menus before vic_init()
creates a canvas window with a menubar at the top. This could
also be used by other ports, e.g. GTK+... */
vic20ui_init_early();
#endif
/* Initialize the VIC-I emulation. */
if (vic_init() == NULL) {
return -1;
}
via1_init(machine_context.via1);
via2_init(machine_context.via2);
ieeevia1_init(machine_context.ieeevia1);
ieeevia2_init(machine_context.ieeevia2);
#ifndef COMMON_KBD
/* Load the default keymap file. */
if (vic20_kbd_init() < 0) {
return -1;
}
#endif
vic20_monitor_init();
/* Initialize vsync and register our hook function. */
vsync_init(machine_vsync_hook);
vsync_set_machine_parameter(machine_timing.rfsh_per_sec,
machine_timing.cycles_per_sec);
/* Initialize native sound chip first */
vic_sound_chip_init();
/* Initialize the sidcart */
sidcart_sound_chip_init();
/* Initialize cartridge based sound chips */
cartridge_sound_chip_init();
/* Initialize userport based sound chips */
userport_dac_sound_chip_init();
drive_sound_init();
video_sound_init();
/* Initialize sound. Notice that this does not really open the audio
device yet. */
sound_init(machine_timing.cycles_per_sec, machine_timing.cycles_per_rfsh);
/* Initialize keyboard buffer. */
kbdbuf_init(631, 198, 10, (CLOCK)(machine_timing.cycles_per_rfsh * machine_timing.rfsh_per_sec));
/* Initialize the VIC20-specific part of the UI. */
vic20ui_init();
vic20iec_init();
cartridge_init();
#ifdef HAVE_MOUSE
mouse_init();
#ifdef HAVE_LIGHTPEN
/* Initialize lightpen support and register VIC-I callbacks */
lightpen_init();
lightpen_register_timing_callback(vic_lightpen_timing, 0);
lightpen_register_trigger_callback(vic_trigger_light_pen);
#endif
#endif
/* Register joystick callback (for lightpen triggering via fire button) */
joystick_register_machine(via2_check_lightpen);
#ifdef HAVE_MIDI
midi_init();
#endif
machine_drive_stub();
#if defined (USE_XF86_EXTENSIONS) && (defined(USE_XF86_VIDMODE_EXT) || defined (HAVE_XRANDR))
{
/* set fullscreen if user used `-fullscreen' on cmdline */
int fs;
resources_get_int("UseFullscreen", &fs);
if (fs) {
resources_set_int("VICFullscreen", 1);
}
}
#endif
return 0;
}
int main(void) {
// copy vector table to SRAM1!
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnonnull"
memcpy((char *)0x20000000, (const char)0x00000000, 0x200);
#pragma GCC diagnostic pop
// remap SRAM1 to 0x00000000
SYSCFG->MEMRMP |= 0x03;
halInit();
chSysInit();
sdcard_init();
sysmon_init();
#if ENABLE_SERIAL_DEBUG
// SD2 for serial debug output
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7) | PAL_MODE_INPUT); // RX
palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL); // TX
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX
// 115200 baud
static const SerialConfig sd2Cfg = {115200,
0, 0, 0};
sdStart(&SD2, &sd2Cfg);
chprintf((BaseSequentialStream * )&SD2,"Hello world!\r\n");
#endif
exception_init();
InitPatch0();
InitPConnection();
InitPWM();
// display SPI CS?
palSetPadMode(GPIOC, 1, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(GPIOC, 1);
chThdSleepMilliseconds(10);
palSetPadMode(SW2_PORT, SW2_PIN, PAL_MODE_INPUT_PULLDOWN);
axoloti_board_init();
codec_init();
if (!palReadPad(SW2_PORT, SW2_PIN)) { // button S2 not pressed
// watchdog_init();
chThdSleepMilliseconds(1);
}
start_dsp_thread();
adc_init();
axoloti_math_init();
midi_init();
#if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05))
axoloti_control_init();
#endif
ui_init();
StartLoadPatchTread();
#if (BOARD_AXOLOTI_V05)
configSDRAM();
//memTest();
#endif
#ifdef ENABLE_USB_HOST
MY_USBH_Init();
#endif
if (!exception_check()) {
// only try booting a patch when no exception is to be reported
#if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05))
sdcard_attemptMountIfUnmounted();
if (fs_ready && !palReadPad(SW2_PORT, SW2_PIN)){
// button S2 not pressed
FRESULT res;
// res = f_stat("/start.bin", NULL);
// if (res == FR_OK) {
LoadPatch("/start.bin");
// }
}
#endif
// if no patch booting or running yet
// try loading from flash
if (patchStatus) {
// patch in flash sector 11
memcpy((uint8_t *)PATCHMAINLOC, (uint8_t *)PATCHFLASHLOC, PATCHFLASHSIZE);
if ((*(uint32_t *)PATCHMAINLOC != 0xFFFFFFFF)
&& (*(uint32_t *)PATCHMAINLOC != 0)) {
if (!palReadPad(SW2_PORT, SW2_PIN)) // button S2 not pressed
StartPatch();
}
}
}
while (1) {
chThdSleepMilliseconds(1000);
}
}
int main(int argc, char *argv[])
{
int frames = 0;
int c, d;
allegro_init();
allegro_video_init();
install_timer();
install_int_ex(timer_rout, BPS_TO_TIMER(100));
install_int_ex(onesec, BPS_TO_TIMER(1));
midi_init();
initpc(argc, argv);
d = romset;
for (c = 0; c < ROM_MAX; c++)
{
romset = c;
romspresent[c] = loadbios();
pclog("romset %i - %i\n", c, romspresent[c]);
}
for (c = 0; c < ROM_MAX; c++)
{
if (romspresent[c])
break;
}
if (c == ROM_MAX)
{
printf("No ROMs present!\nYou must have at least one romset to use PCem.");
return 0;
}
romset=d;
c=loadbios();
if (!c)
{
if (romset != -1)
printf("Configured romset not available.\nDefaulting to available romset.");
for (c = 0; c < ROM_MAX; c++)
{
if (romspresent[c])
{
romset = c;
model = model_getmodel(romset);
saveconfig();
resetpchard();
break;
}
}
}
for (c = 0; c < GFX_MAX; c++)
gfx_present[c] = video_card_available(video_old_to_new(c));
if (!video_card_available(video_old_to_new(gfxcard)))
{
if (gfxcard) printf("Configured video BIOS not available.\nDefaulting to available romset.");
for (c = GFX_MAX-1; c >= 0; c--)
{
if (gfx_present[c])
{
gfxcard = c;
saveconfig();
resetpchard();
break;
}
}
}
resetpchard();
ticks = 0;
while (!quited)
{
if (ticks)
{
ticks--;
runpc();
frames++;
if (frames >= 200 && nvr_dosave)
{
frames = 0;
nvr_dosave = 0;
savenvr();
}
}
else
rest(1);
if (ticks > 10)
ticks = 0;
if ((mouse_b & 1) && !mousecapture)
mousecapture = 1;
if (((key[KEY_LCONTROL] || key[KEY_RCONTROL]) && key[KEY_END]) || (mouse_b & 4))
mousecapture = 0;
if ((key[KEY_LCONTROL] || key[KEY_RCONTROL]) && key[KEY_ALT] && key[KEY_PGDN])
{
int old_winsizex = winsizex, old_winsizey = winsizey;
if (winsizex < 512 || winsizey < 350)
updatewindowsize(512, 350);
gui_enter();
if (old_winsizex < 512 || old_winsizey < 350)
updatewindowsize(old_winsizex, old_winsizey);
ticks = 0;
}
}
closepc();
midi_close();
return 0;
}
static void bios_init(void)
{
KDEBUG(("bios_init()\n"));
/* initialize Native Features, if available
* do it as soon as possible so that kprintf can make use of them
*/
#if DETECT_NATIVE_FEATURES
KDEBUG(("natfeat_init()\n"));
natfeat_init();
#endif
#if STONX_NATIVE_PRINT
KDEBUG(("stonx_kprintf_init()\n"));
stonx_kprintf_init();
#endif
#if CONF_WITH_UAE
KDEBUG(("amiga_uaelib_init()\n"));
amiga_uaelib_init();
#endif
/* Initialize the processor */
KDEBUG(("processor_init()\n"));
processor_init(); /* Set CPU type, longframe and FPU type */
KDEBUG(("vecs_init()\n"));
vecs_init(); /* setup all exception vectors (above) */
KDEBUG(("init_delay()\n"));
init_delay(); /* set 'reasonable' default values for delay */
/* Detect optional hardware (video, sound, etc.) */
KDEBUG(("machine_detect()\n"));
machine_detect(); /* detect hardware */
KDEBUG(("machine_init()\n"));
machine_init(); /* initialise machine-specific stuff */
/* Initialize the screen */
KDEBUG(("screen_init()\n"));
screen_init(); /* detect monitor type, ... */
/* Initialize the BIOS memory management */
KDEBUG(("bmem_init()\n"));
bmem_init(); /* this must be done after screen_init() */
KDEBUG(("cookie_init()\n"));
cookie_init(); /* sets a cookie jar */
KDEBUG(("fill_cookie_jar()\n"));
fill_cookie_jar(); /* detect hardware features and fill the cookie jar */
/* Set up the BIOS console output */
KDEBUG(("linea_init()\n"));
linea_init(); /* initialize screen related line-a variables */
font_init(); /* initialize font ring (requires cookie_akp) */
font_set_default(-1);/* set default font */
vt52_init(); /* initialize the vt52 console */
/* Now kcprintf() will also send debug info to the screen */
KDEBUG(("after vt52_init()\n"));
/* misc. variables */
dumpflg = -1;
sysbase = (LONG) os_entry;
savptr = (LONG) trap_save_area;
etv_timer = (void(*)(int)) just_rts;
etv_critic = default_etv_critic;
etv_term = just_rts;
/* setup VBL queue */
nvbls = 8;
vblqueue = vbl_list;
{
int i;
for(i = 0 ; i < 8 ; i++) {
vbl_list[i] = 0;
}
}
#if CONF_WITH_MFP
KDEBUG(("mfp_init()\n"));
mfp_init();
#endif
#if CONF_WITH_TT_MFP
if (has_tt_mfp)
{
KDEBUG(("tt_mfp_init()\n"));
tt_mfp_init();
}
#endif
/* Initialize the system 200 Hz timer */
KDEBUG(("init_system_timer()\n"));
init_system_timer();
/* Initialize the RS-232 port(s) */
KDEBUG(("chardev_init()\n"));
chardev_init(); /* Initialize low-memory bios vectors */
boot_status |= CHARDEV_AVAILABLE; /* track progress */
KDEBUG(("init_serport()\n"));
init_serport();
boot_status |= RS232_AVAILABLE; /* track progress */
#if CONF_WITH_SCC
if (has_scc)
boot_status |= SCC_AVAILABLE; /* track progress */
#endif
/* The sound init must be done before allowing MFC interrupts,
* because of dosound stuff in the timer C interrupt routine.
*/
#if CONF_WITH_DMASOUND
KDEBUG(("dmasound_init()\n"));
dmasound_init();
#endif
KDEBUG(("snd_init()\n"));
snd_init(); /* Reset Soundchip, deselect floppies */
/* Init the two ACIA devices (MIDI and KBD). The three actions below can
* be done in any order provided they happen before allowing MFP
* interrupts.
*/
KDEBUG(("kbd_init()\n"));
kbd_init(); /* init keyboard, disable mouse and joystick */
KDEBUG(("midi_init()\n"));
midi_init(); /* init MIDI acia so that kbd acia irq works */
KDEBUG(("init_acia_vecs()\n"));
init_acia_vecs(); /* Init the ACIA interrupt vector and related stuff */
KDEBUG(("after init_acia_vecs()\n"));
boot_status |= MIDI_AVAILABLE; /* track progress */
/* Now we can enable the interrupts.
* We need a timer for DMA timeouts in floppy and harddisk initialisation.
* The VBL processing will be enabled later with the vblsem semaphore.
*/
#if CONF_WITH_ATARI_VIDEO
/* Keep the HBL disabled */
set_sr(0x2300);
#else
set_sr(0x2000);
#endif
KDEBUG(("calibrate_delay()\n"));
calibrate_delay(); /* determine values for delay() function */
/* - requires interrupts to be enabled */
KDEBUG(("blkdev_init()\n"));
blkdev_init(); /* floppy and harddisk initialisation */
KDEBUG(("after blkdev_init()\n"));
/* initialize BIOS components */
KDEBUG(("parport_init()\n"));
parport_init(); /* parallel port */
//mouse_init(); /* init mouse driver */
KDEBUG(("clock_init()\n"));
clock_init(); /* init clock */
KDEBUG(("after clock_init()\n"));
#if CONF_WITH_NLS
KDEBUG(("nls_init()\n"));
nls_init(); /* init native language support */
nls_set_lang(get_lang_name());
#endif
/* set start of user interface */
#if WITH_AES
exec_os = ui_start;
#elif WITH_CLI
exec_os = coma_start;
#else
exec_os = NULL;
#endif
KDEBUG(("osinit()\n"));
osinit(); /* initialize BDOS */
KDEBUG(("after osinit()\n"));
boot_status |= DOS_AVAILABLE; /* track progress */
/* Enable VBL processing */
vblsem = 1;
#if CONF_WITH_CARTRIDGE
{
WORD save_hz = v_hz_rez, save_vt = v_vt_rez, save_pl = v_planes;
/* Run all boot applications from the application cartridge.
* Beware: Hatari features a special cartridge which is used
* for GEMDOS drive emulation. It will hack drvbits and hook Pexec().
* It will also hack Line A variables to enable extended VDI video modes.
*/
KDEBUG(("run_cartridge_applications(3)\n"));
run_cartridge_applications(3); /* Type "Execute prior to bootdisk" */
KDEBUG(("after run_cartridge_applications()\n"));
if ((v_hz_rez != save_hz) || (v_vt_rez != save_vt) || (v_planes != save_pl))
{
set_rez_hacked();
font_set_default(-1); /* set default font */
vt52_init(); /* initialize the vt52 console */
}
}
#endif
#if CONF_WITH_ALT_RAM
#if CONF_WITH_FASTRAM
/* add TT-RAM that was detected in memory.S */
if (ramtop != NULL)
{
KDEBUG(("xmaddalt()\n"));
xmaddalt(FASTRAM_START, ramtop - FASTRAM_START);
}
#endif
#if CONF_WITH_MONSTER
/* Add MonSTer alt-RAM detected in machine.c */
if (has_monster)
{
/* Dummy read from MonSTer register to initiate write sequence. */
unsigned short monster_reg = *(volatile unsigned short *)MONSTER_REG;
/* Only enable 6Mb when on a Mega STE due to address conflict with
VME bus. Todo: This should be made configurable. */
if (has_vme)
monster_reg = 6;
else
monster_reg = 8;
/* Register write sequence: read - write - write */
*(volatile unsigned short *)MONSTER_REG = monster_reg;
*(volatile unsigned short *)MONSTER_REG = monster_reg;
KDEBUG(("xmaddalt()\n"));
xmaddalt((UBYTE *)0x400000L, monster_reg*0x100000L);
}
#endif
#ifdef MACHINE_AMIGA
KDEBUG(("amiga_add_alt_ram()\n"));
amiga_add_alt_ram();
#endif
#endif /* CONF_WITH_ALT_RAM */
KDEBUG(("bios_init() end\n"));
}
