/**

  * $Id$

  *

  * Simple implementation of one-shot timers. Effectively this allows IO

  * devices to wait until a particular time before completing. We expect 

  * there to be at least half a dozen or so continually scheduled events

  * (TMU and PVR2), peaking around 20+.

  *

  * Copyright (c) 2005 Nathan Keynes.

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  */

 #include <assert.h>

 #include "dreamcast.h"

 #include "eventq.h"

 #include "asic.h"

 #include "sh4.h"

 #define LONG_SCAN_PERIOD 1000000000 /* 1 second */

 typedef struct event {

     uint32_t id;

     uint32_t seconds;

     uint32_t nanosecs;

     event_func_t func;

     struct event *next;

 } *event_t;

 static struct event events[MAX_EVENT_ID];

 /**

  * Countdown to the next scan of the long-duration list (greater than 1 second).

  */

 static int long_scan_time_remaining;

 static event_t event_head;

 static event_t long_event_head;

 void event_reset();

 void event_init();

 uint32_t event_run_slice( uint32_t nanosecs );

 void event_save_state( FILE *f );

 int event_load_state( FILE * f );

 struct dreamcast_module eventq_module = { "EVENTQ", event_init, event_reset, NULL, event_run_slice,

 					NULL, event_save_state, event_load_state };

 static void event_update_pending( ) 

 {

     if( event_head == NULL ) {

 	if( !(sh4r.event_types & PENDING_IRQ) ) {

 	    sh4r.event_pending = NOT_SCHEDULED;

 	}

 	sh4r.event_types &= (~PENDING_EVENT);

     } else {

 	if( !(sh4r.event_types & PENDING_IRQ) ) {

 	    sh4r.event_pending = event_head->nanosecs;

 	}

 	sh4r.event_types |= PENDING_EVENT;

     }

 }

 uint32_t event_get_next_time( ) 

 {

     if( event_head == NULL ) {

 	return NOT_SCHEDULED;

     } else {

 	return event_head->nanosecs;

     }

 }

 /**

  * Add the event to the short queue.

  */

 static void event_enqueue( event_t event ) 

 {

     if( event_head == NULL || event->nanosecs < event_head->nanosecs ) {

 	event->next = event_head;

 	event_head = event;

 	event_update_pending();

     } else {

 	event_t cur = event_head;

 	event_t next = cur->next;

 	while( next != NULL && event->nanosecs >= next->nanosecs ) {

 	    cur = next;

 	    next = cur->next;

 	}

 	event->next = next;

 	cur->next = event;

     }

 }

 static void event_dequeue( event_t event )

 {

     if( event_head == NULL ) {

 	ERROR( "Empty event queue but should contain event %d", event->id );

     } else if( event_head == event ) {

 	/* removing queue head */

 	event_head = event_head->next;

 	event_update_pending();

     } else {

 	event_t cur = event_head;

 	event_t next = cur->next;

 	while( next != NULL ) {

 	    if( next == event ) {

 		cur->next = next->next;

 		break;

 	    }

 	    cur = next;

 	    next = cur->next;

 	}

     }

 }

 static void event_dequeue_long( event_t event ) 

 {

     if( long_event_head == NULL ) {

 	ERROR( "Empty long event queue but should contain event %d", event->id );

     } else if( long_event_head == event ) {

 	/* removing queue head */

 	long_event_head = long_event_head->next;

     } else {

 	event_t cur = long_event_head;

 	event_t next = cur->next;

 	while( next != NULL ) {

 	    if( next == event ) {

 		cur->next = next->next;

 		break;

 	    }

 	    cur = next;

 	    next = cur->next;

 	}

     }

 }

 void register_event_callback( int eventid, event_func_t func )

 {

     events[eventid].func = func;

 }

 void event_schedule( int eventid, uint32_t nanosecs )

 {

     nanosecs += sh4r.slice_cycle;

     event_t event = &events[eventid];

     if( event->nanosecs != NOT_SCHEDULED ) {

 	/* Event is already scheduled. Remove it from the list first */

 	event_cancel(eventid);

     }

     event->id = eventid;

     event->seconds = 0;

     event->nanosecs = nanosecs;

     event_enqueue( event );

 }

 void event_schedule_long( int eventid, uint32_t seconds, uint32_t nanosecs ) {

     if( seconds == 0 ) {

 	event_schedule( eventid, nanosecs );

     } else {

 	event_t event = &events[eventid];

 	if( event->nanosecs != NOT_SCHEDULED ) {

 	    /* Event is already scheduled. Remove it from the list first */

 	    event_cancel(eventid);

 	}

 	event->id = eventid;

 	event->seconds = seconds;

 	event->nanosecs = nanosecs;

 	event->next = long_event_head;

 	long_event_head = event;

     }

 }

 void event_cancel( int eventid )

 {

     event_t event = &events[eventid];

     if( event->nanosecs == NOT_SCHEDULED ) {

 	return; /* not scheduled */

     } else {

 	event->nanosecs = NOT_SCHEDULED;

 	if( event->seconds != 0 ) { /* long term event */

 	    event_dequeue_long( event );

 	} else {

 	    event_dequeue( event );

 	}

     }

 }

 void event_execute()

 {

     /* Loop in case we missed some or got a couple scheduled for the same time */

     while( event_head != NULL && event_head->nanosecs <= sh4r.slice_cycle ) {

 	event_t event = event_head;

 	event_head = event->next;

 	event->nanosecs = NOT_SCHEDULED;

 	// Note: Make sure the internal state is consistent before calling the

 	// user function, as it will (quite likely) enqueue another event.

 	event->func( event->id );

     }

     event_update_pending();

 }

 void event_asic_callback( int eventid )

 {

     asic_event( eventid );

 }

 void event_init()

 {

     int i;

     for( i=0; i<MAX_EVENT_ID; i++ ) {

 	events[i].id = i;

 	events[i].nanosecs = NOT_SCHEDULED;

 	if( i < 96 ) {

 	    events[i].func = event_asic_callback;

 	} else {

 	    events[i].func = NULL;

 	}

 	events[i].next = NULL;

     }

     event_head = NULL;

     long_event_head = NULL;

     long_scan_time_remaining = LONG_SCAN_PERIOD;

 }

 void event_reset()

 {

     int i;

     event_head = NULL;

     long_event_head = NULL;

     long_scan_time_remaining = LONG_SCAN_PERIOD;

     for( i=0; i<MAX_EVENT_ID; i++ ) {

 	events[i].nanosecs = NOT_SCHEDULED;

     }

 }

 void event_save_state( FILE *f )

 {

     int32_t id, i;

     id = event_head == NULL ? -1 : event_head->id;

     fwrite( &id, sizeof(id), 1, f );

     id = long_event_head == NULL ? -1 : long_event_head->id;

     fwrite( &id, sizeof(id), 1, f );

     fwrite( &long_scan_time_remaining, sizeof(long_scan_time_remaining), 1, f );

     for( i=0; i<MAX_EVENT_ID; i++ ) {

 	fwrite( &events[i].id, sizeof(uint32_t), 3, f ); /* First 3 words from structure */

 	id = events[i].next == NULL ? -1 : events[i].next->id;

 	fwrite( &id, sizeof(id), 1, f );

     }

 }

 int event_load_state( FILE *f )

 {

     int32_t id, i;

     fread( &id, sizeof(id), 1, f );

     event_head = id == -1 ? NULL : &events[id];

     fread( &id, sizeof(id), 1, f );

     long_event_head = id == -1 ? NULL : &events[id];

     fread( &long_scan_time_remaining, sizeof(long_scan_time_remaining), 1, f );

     for( i=0; i<MAX_EVENT_ID; i++ ) {

 	fread( &events[i].id, sizeof(uint32_t), 3, f );

 	fread( &id, sizeof(id), 1, f );

 	events[i].next = id == -1 ? NULL : &events[id];

     }

     return 0;

 }

 /**

  * Scan all entries in the long queue, decrementing each by 1 second. Entries

  * that are now < 1 second are moved to the short queue.

  */

 static void event_scan_long()

 {

     while( long_event_head != NULL && --long_event_head->seconds == 0 ) {

 	event_t event = long_event_head;

 	long_event_head = event->next;

 	event_enqueue(event);

     }

     if( long_event_head != NULL ) {

 	event_t last = long_event_head;

 	event_t cur = last->next;

 	while( cur != NULL ) {

 	    if( --cur->seconds == 0 ) {

 		last->next = cur->next;

 		event_enqueue(cur);

 	    } else {

 		last = cur;

 	    }

 	    cur = last->next;

 	}

     }

 }

 /**

  * Decrement the event time on all pending events by the supplied nanoseconds.

  * It may or may not be faster to wrap around instead, but this has the benefit

  * of simplicity.

  */

 uint32_t event_run_slice( uint32_t nanosecs )

 {

     event_t event = event_head;

     while( event != NULL ) {

 	if( event->nanosecs <= nanosecs ) {

 	    event->nanosecs = 0;

 	} else {

 	    event->nanosecs -= nanosecs;

 	}

 	event = event->next;

     }

     long_scan_time_remaining -= nanosecs;

     if( long_scan_time_remaining <= 0 ) {

 	long_scan_time_remaining += LONG_SCAN_PERIOD;

 	event_scan_long();

     }

     event_update_pending();

     return nanosecs;

 }