void disc_load(int drive, char *fn)
{
        int c = 0, size;
        char *p;
        FILE *f;
//        pclog("disc_load %i %s\n", drive, fn);
//        setejecttext(drive, "");
        if (!fn) return;
        p = get_extension(fn);
        if (!p) return;
//        setejecttext(drive, fn);
        pclog("Loading :%i %s %s\n", drive, fn,p);
        f = fopen(fn, "rb");
        if (!f) return;
        fseek(f, -1, SEEK_END);
        size = ftell(f) + 1;
        fclose(f);        
        while (loaders[c].ext)
        {
                if (!strcasecmp(p, loaders[c].ext) && (size == loaders[c].size || loaders[c].size == -1))
                {
                        pclog("Loading as %s\n", p);
                        driveloaders[drive] = c;
                        loaders[c].load(drive, fn);
                        drive_empty[drive] = 0;
                        disc_changed[drive] = 1;
                        strcpy(discfns[drive], fn);
                        return;
                }
                c++;
        }
        pclog("Couldn't load %s %s\n",fn,p);
        drive_empty[drive] = 1;
        discfns[drive][0] = 0;
}

void *
dynld_module(const char *name, dllimp_t *table)
{
    HMODULE h;
    dllimp_t *imp;
    void *func;
    /* char **foo; */

    /* See if we can load the desired module. */
    if ((h = LoadLibrary(name)) == NULL) {
	pclog("DynLd(\"%s\"): library not found!\n", name);
	return(NULL);
    }

    /* Now load the desired function pointers. */
    for (imp=table; imp->name!=NULL; imp++) {
	func = GetProcAddress(h, imp->name);
	if (func == NULL) {
		pclog("DynLd(\"%s\"): function '%s' not found!\n",
						name, imp->name);
		CloseHandle(h);
		return(NULL);
	}

	/* To overcome typing issues.. */
	*(char **)imp->func = (char *)func;
    }

    /* All good. */
    return((void *)h);
}

void model_init()
{
        pclog("Initting as %s\n", model_getname());
        io_init();
        
        models[model].init();

	pclog("PCI: %02X, Max IDE: %02X, 386: %02X\n", PCI, maxide, is386);
}

int rom_init_interleaved(rom_t *rom, char *fn_low, char *fn_high, uint32_t address, int size, int mask, int file_offset, uint32_t flags)
{
        FILE *f_low  = romfopen(fn_low, "rb");
        FILE *f_high = romfopen(fn_high, "rb");
        int c;
        
        if (!f_low || !f_high)
        {
#ifndef RELEASE_BUILD
                if (!f_low)
                        pclog("ROM image not found : %s\n", fn_low);
                else
#else
		if (f_low)
#endif
                        fclose(f_low);
#ifndef RELEASE_BUILD
                if (!f_high)
                        pclog("ROM image not found : %s\n", fn_high);
                else
#else
		if (f_high)
#endif
                        fclose(f_high);
                return -1;
        }
        
        rom->rom = malloc(size);
        fseek(f_low, file_offset, SEEK_SET);
        fseek(f_high, file_offset, SEEK_SET);
        for (c = 0; c < size; c += 2)
        {
                rom->rom[c]     = getc(f_low);
                rom->rom[c + 1] = getc(f_high);
        }
        fclose(f_high);
        fclose(f_low);
        
        rom->mask = mask;
        
        mem_mapping_add(&rom->mapping, address, size, rom_read,
                                                      rom_readw,
                                                      rom_readl,
                                                      mem_write_null,
                                                      mem_write_nullw,
                                                      mem_write_nulll,
                                                      rom->rom,
                                                      flags,
                                                      rom);

        return 0;
}

/* Flush the serial port. */
static void
bug_spflsh(void)
{
    *bug_bptr = '\0';
    pclog("BUGGER- serial port [%s]\n", bug_buff);
    bug_bptr = bug_buff;
}

/* Close up shop. */
void
network_pcap_close(void)
{
    pcap_t *pc;

    if (pcap != NULL) {
	pclog("Closing WinPcap\n");

	/* Tell the polling thread to shut down. */
	pc = pcap; pcap = NULL;
#if 1
	/* Terminate the polling thread. */
	if (poll_tid != NULL) {
		thread_kill(poll_tid);
		poll_tid = NULL;
	}
#else
	/* Wait for the polling thread to shut down. */
	while (poll_tid != NULL)
		;
#endif

	/* OK, now shut down WinPcap itself. */
	f_pcap_close(pc);

	/* Unload the DLL if possible. */
	if (pcap_handle != NULL) {
		dynld_close(pcap_handle);
		pcap_handle = NULL;
	}
    }
    poll_rx = NULL;
    poll_arg = NULL;
}

static void QueueByte(mpu_t *mpu, uint8_t data) 
{
	if (mpu->state.block_ack) 
	{
		mpu->state.block_ack=0;
		return;
	}
	
	if (mpu->queue_used == 0 && mpu->intelligent) 
	{
		mpu->state.irq_pending=1;
		//PIC_ActivateIRQ(mpu->irq);
		picint(1 << mpu->irq);
	}
	if (mpu->queue_used < MPU401_QUEUE) 
	{
		int pos = mpu->queue_used+mpu->queue_pos;
		
		if (mpu->queue_pos >= MPU401_QUEUE) 
			mpu->queue_pos -= MPU401_QUEUE;
		
		if (pos>=MPU401_QUEUE) 
			pos-=MPU401_QUEUE;
		
		mpu->queue_used++;
		mpu->queue[pos]=data;
	} 
	else
		pclog("MPU401:Data queue full\n");
}

/* Handle a write to the Serial Port Configuration register. */
static void
bug_wspcfg(uint8_t val)
{
    bug_spcfg = val;

    pclog("BUGGER- spcfg %02x\n", bug_spcfg);
}

//Updates counters and requests new data on "End of Input"
static void MPU401_EOIHandler(void *p)
{
	mpu_t *mpu = (mpu_t *)p;
	uint8_t i;

	pclog("MPU-401 end of input callback\n");
	
	mpu401_eoi_callback = 0;
	mpu->state.eoi_scheduled=0;
	if (mpu->state.send_now) 
	{
		mpu->state.send_now=0;
		if (mpu->state.cond_req) UpdateConductor(mpu);
		else UpdateTrack(mpu, mpu->state.channel);
	}
	mpu->state.irq_pending=0;
	if (!mpu->state.playing || !mpu->state.req_mask)  return;
	i=0;
	do {
		if (mpu->state.req_mask&(1<<i)) {
			QueueByte(mpu, 0xf0+i);
			mpu->state.req_mask&=~(1<<i);
			break;
		}
	} while ((i++)<16);
}

/* Handle a write to the data register. */
static void
bug_wdata(uint8_t val)
{
    bug_data = val;

    if (bug_ctrl & CTRL_SPCFG)
	bug_wspcfg(val);
      else if (bug_ctrl & CTRL_SPORT)
	bug_wsport(val);
      else {
	if (bug_ctrl & CTRL_SEG2)
		bug_seg2 = val;
	  else if (bug_ctrl & CTRL_SEG1)
		bug_seg1 = val;
	  else if (bug_ctrl & CTRL_GLED)
		bug_ledg = val;
	  else
		bug_ledr = val;

	pclog("BUGGER- data %02x\n", bug_data);
    }

    /* Update the UI with active settings. */
    bug_setui();
}

void keyboard_xt_write(uint16_t port, uint8_t val, void *priv)
{
        switch (port)
        {
                case 0x61:
                if (!(keyboard_xt.pb & 0x40) && (val & 0x40)) /*Reset keyboard*/
                {
                        pclog("keyboard_xt : reset keyboard\n");
			key_queue_end = key_queue_start;
                        keyboard_xt_adddata(0xaa);
                }
		if ((keyboard_xt.pb & 0x80)==0 && (val & 0x80)!=0)
		{
			keyboard_xt.pa = 0;
			keyboard_xt.blocked = 0;
			picintc(2);
		}
                keyboard_xt.pb = val;
                ppi.pb = val;

                timer_process();
                timer_update_outstanding();
        
		speaker_update();
                speaker_gated = val & 1;
                speaker_enable = val & 2;
                if (speaker_enable) 
                        was_speaker_enable = 1;
                pit_set_gate(&pit, 2, val & 1);
                   
                break;
        }
}

void keyboard_xt_adddata(uint8_t val)
{
        key_queue[key_queue_end] = val;
        pclog("keyboard_xt : %02X added to key queue at %i\n", val, key_queue_end);
        key_queue_end = (key_queue_end + 1) & 0xf;
        return;
}

void mpu401_init(mpu_t *mpu, uint16_t addr, int irq, int mode)
{
#if 0
	if (mode != M_INTELLIGENT)
	{
		mpu401_uart_init(mpu, addr);
		return;
	}
#endif

	mpu->status = STATUS_INPUT_NOT_READY;
	mpu->irq = irq;
	mpu->queue_used = 0;
	mpu->queue_pos = 0;
	mpu->mode = M_UART;

	mpu->intelligent = (mode == M_INTELLIGENT) ? 1 : 0;
	pclog("Starting as %s (mode is %s)\n", mpu->intelligent ? "INTELLIGENT" : "UART", (mode == M_INTELLIGENT) ? "INTELLIGENT" : "UART");

	mpu401_event_callback = 0;
	mpu401_eoi_callback = 0;
	mpu401_reset_callback = 0;

	io_sethandler(addr, 0x0002, mpu401_read, NULL, NULL, mpu401_write, NULL, NULL, mpu);
	io_sethandler(0x2A20, 0x0010, NULL, NULL, NULL, imf_write, NULL, NULL, mpu);
	timer_add(MPU401_Event, &mpu401_event_callback, &mpu401_event_callback, mpu);
	timer_add(MPU401_EOIHandler, &mpu401_eoi_callback, &mpu401_eoi_callback, mpu);
	timer_add(MPU401_ResetDone, &mpu401_reset_callback, &mpu401_reset_callback, mpu);
	
	MPU401_Reset(mpu);
}

/* Initialize the (Win)Pcap module for use. */
int
network_pcap_init(netdev_t *list)
{
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_if_t *devlist, *dev;
    int i = 0;

    /* Local variables. */
    pcap = NULL;

    /* Try loading the DLL. */
    pcap_handle = dynld_module("wpcap.dll", pcap_imports);
    if (pcap_handle == NULL) return(-1);

    /* Retrieve the device list from the local machine */
    if (f_pcap_findalldevs(&devlist, errbuf) == -1) {
	pclog("PCAP: error in pcap_findalldevs: %s\n", errbuf);
	return(-1);
    }

    for (dev=devlist; dev!=NULL; dev=dev->next) {
	strcpy(list->device, dev->name);
	if (dev->description)
		strcpy(list->description, dev->description);
	  else
		memset(list->description, '\0', sizeof(list->description));
	list++; i++;
    }

    /* Release the memory. */
    f_pcap_freealldevs(devlist);

    return(i);
}

uint8_t keyboard_pcjr_read(uint16_t port, void *priv)
{
        uint8_t temp;
        switch (port)
        {
                case 0x60:
                temp = keyboard_pcjr.pa;
                break;
                
                case 0x61:
                temp = keyboard_pcjr.pb;
                break;
                
                case 0x62:
                temp = (keyboard_pcjr.latched ? 1 : 0);
                temp |= 0x02; /*Modem card not installed*/
                temp |= (ppispeakon ? 0x10 : 0);
                temp |= (ppispeakon ? 0x20 : 0);
                temp |= (keyboard_pcjr.data ? 0x40: 0);
                if (keyboard_pcjr.data)
                        temp |= 0x40;
                break;
                
                case 0xa0:
                keyboard_pcjr.latched = 0;
		temp = 0;
                break;
                
                default:
                pclog("\nBad XT keyboard read %04X\n", port);
		temp = 0xff;
        }
        return temp;
}

int rom_init(rom_t *rom, char *fn, uint32_t address, int size, int mask, int file_offset, uint32_t flags)
{
        FILE *f = romfopen(fn, "rb");
        
        if (!f)
        {
#ifndef RELEASE_BUILD
                pclog("ROM image not found : %s\n", fn);
#endif
                return -1;
        }
        
        rom->rom = malloc(size);
        fseek(f, file_offset, SEEK_SET);
        fread(rom->rom, size, 1, f);
        fclose(f);
        
        rom->mask = mask;
        
        mem_mapping_add(&rom->mapping, address, size, rom_read,
                                                      rom_readw,
                                                      rom_readl,
                                                      mem_write_null,
                                                      mem_write_nullw,
                                                      mem_write_nulll,
                                                      rom->rom,
                                                      flags,
                                                      rom);

        return 0;
}

void timer_reset()
{
	pclog("timer_reset\n");
	timers_present = 0;
	timer_latch = timer_count = 0;
//	timer_process();
}

/* Handle the receiving of frames from the channel. */
static void
poll_thread(void *arg)
{
    uint8_t *mac = (uint8_t *)arg;
    const uint8_t *data = NULL;
    struct pcap_pkthdr h;
    uint32_t mac_cmp32[2];
    uint16_t mac_cmp16[2];
    event_t *evt;

    pclog("PCAP: polling thread started, arg %08lx\n", arg);

    /* Create a waitable event. */
    evt = thread_create_event();

    /* As long as the channel is open.. */
    while (pcap != NULL) {
	/* Wait for the next packet to arrive. */
	data = f_pcap_next(pcap, &h);
	if (data != NULL) {
		/* Received MAC. */
		mac_cmp32[0] = *(uint32_t *)(data+6);
		mac_cmp16[0] = *(uint16_t *)(data+10);

		/* Local MAC. */
		mac_cmp32[1] = *(uint32_t *)mac;
		mac_cmp16[1] = *(uint16_t *)(mac+4);
		if ((mac_cmp32[0] != mac_cmp32[1]) ||
		    (mac_cmp16[0] != mac_cmp16[1])) {
			if (poll_rx != NULL)
				poll_rx(poll_arg, (uint8_t *)data, h.caplen); 
		} else {
			/* Mark as invalid packet. */
			data = NULL;
		}
	}

	/* If we did not get anything, wait a while. */
	if (data == NULL)
		thread_wait_event(evt, 10);
    }

    thread_destroy_event(evt);
    poll_tid = NULL;

    pclog("PCAP: polling stopped.\n");
}

void model_init()
{
        pclog("Initting as %s\n", model_getname());
        AMSTRAD = AT = PCI = TANDY = 0;
        io_init();
        
        models[model].init();
}

static void MPU401_Event(void *p) 
{
	mpu_t *mpu = (mpu_t *)p;
	uint8_t i;
	int new_time;

	pclog("MPU-401 event callback\n");
	
	if (mpu->mode==M_UART)
	{
		mpu401_event_callback = 0;
		return;
	}
	if (mpu->state.irq_pending) goto next_event;
	for (i=0;i<8;i++) { /* Decrease counters */
		if (mpu->state.amask&(1<<i)) {
			mpu->playbuf[i].counter--;
			if (mpu->playbuf[i].counter<=0) UpdateTrack(mpu, i);
		}
	}		
	if (mpu->state.conductor) {
		mpu->condbuf.counter--;
		if (mpu->condbuf.counter<=0) UpdateConductor(mpu);
	}
	if (mpu->clock.clock_to_host) {
		mpu->clock.cth_counter++;
		if (mpu->clock.cth_counter >= mpu->clock.cth_rate) {
			mpu->clock.cth_counter=0;
			mpu->state.req_mask|=(1<<13);
		}
	}
	if (!mpu->state.irq_pending && mpu->state.req_mask) MPU401_EOIHandler(mpu);
next_event:
	/* mpu401_event_callback = 0; */
	new_time = (mpu->clock.tempo * mpu->clock.timebase);
	if (new_time == 0)
	{
		mpu401_event_callback = 0;
		return;
	}
	else
	{
		mpu401_event_callback += (MPU401_TIMECONSTANT/new_time) * 1000 * TIMER_USEC;
		pclog("Next event after %i us (time constant: %i)\n", (int) ((MPU401_TIMECONSTANT/new_time) * 1000 * TIMER_USEC), (int) MPU401_TIMECONSTANT);
	}
}