Subversion Repositories shark

/* Project:     OSLib

 * Description: The OS Construction Kit

 * Date:                1.6.2000

 * Idea by:             Luca Abeni & Gerardo Lamastra

 *

 * OSLib is an SO project aimed at developing a common, easy-to-use

 * low-level infrastructure for developing OS kernels and Embedded

 * Applications; it partially derives from the HARTIK project but it

 * currently is independently developed.

 *

 * OSLib is distributed under GPL License, and some of its code has

 * been derived from the Linux kernel source; also some important

 * ideas come from studying the DJGPP go32 extender.

 *

 * We acknowledge the Linux Community, Free Software Foundation,

 * D.J. Delorie and all the other developers who believe in the

 * freedom of software and ideas.

 *

 * For legalese, check out the included GPL license.

 */

/* Added Advanced Timer Code

 *

 * Date:   8.4.2003

 * Author: Giacomo Guidi <giacomo@gandalf.sssup.it>

 *

 */

/*	Time Event routines	(one shot mode)	*/

#include <ll/i386/stdlib.h>

#include <ll/i386/mem.h>

#include <ll/i386/pit.h>

#include <ll/i386/apic.h>

#include <ll/i386/advtimer.h>

#include <ll/i386/error.h>

#include <ll/i386/64bit.h>

#include <ll/sys/ll/ll-data.h>

#include <ll/sys/ll/ll-func.h>

#include <ll/sys/ll/time.h>

#include <ll/sys/ll/event.h>

#include <tracer.h>

extern unsigned short int currCtx;

FILE(EventOneShot);

extern int activeInt;

int activeEvent;

extern BYTE frc;

extern struct event eventlist[MAX_EVENT];

extern WORD lastTime;

extern struct pitspec globalCounter;

extern struct event *freeevents;

extern struct event *firstevent;

extern void (*evt_prol) (void);

extern void (*evt_epil) (void);

extern unsigned int apic_clk_per_msec;

extern unsigned char use_tsc, use_apic;

/* Switched to timespec */

int oneshot_event_post(struct timespec time, void (*handler) (void *p), void *par)

{

	struct event *p;

	struct event *p1, *t;

	struct timespec now, tmp;

	int done;

	DWORD tnext;

	TRACER_LOGEVENT(FTrace_EVT_timer_post, 0, 0);

	if (!freeevents) {

		message("NO FREE EVENTS !\n");

		ll_abort(20);

		return -1;

	}

	/* Extract from the ``free events'' queue */

	p = freeevents;

	freeevents = p->next;

	/* Fill the event fields */

	p->handler = handler;

	TIMESPEC_ASSIGN(&(p->time), &time);

	p->par = par;

	/* ...And insert it in the event queue!!! */

	t = NULL;

	done = 0;

	/* walk through list, finding spot, adjusting ticks parameter */

	for (p1 = firstevent; p1; p1 = t->next) {

		if (TIMESPEC_A_GT_B((&time), (&p1->time))) {

		t = p1;

		} else

		break;

	}

	/* adjust next entry */

	if (t) {

		t->next = p;

	} else {

		firstevent = p;

		if (!activeEvent) {

			if (!use_tsc) {

				ll_gettime(TIME_NEW, &now);

			} else {

				ll_read_timespec(&now);

			}

			if (TIMESPEC_A_GT_B(&now, &(firstevent->time))) {

				NULL_TIMESPEC(&tmp);

			} else {

				SUBTIMESPEC(&(firstevent->time), &now, &tmp);

			}

			tnext = TIMESPEC2USEC(&tmp);

			if (!use_apic) {

				mul32div32to32(tnext,1193182,1000000,tnext);

				pit_setconstant(0, tnext);

			} else {

				mul32div32to32(tnext,apic_clk_per_msec,1000,tnext);

				set_APIC_timer(tnext);

			}

		}

	}

	p->next = p1;

	return p->index;

}

void oneshot_wake_up(void)

{

	/* CHANGE the NAME, please... */

	struct event *p = NULL, *pp;

	struct timespec now, ttmp;

	WORD tmp;

	DWORD tnext;

	TRACER_LOGEVENT(FTrace_EVT_timer_wakeup_start, 0, 0);

	if (!use_tsc) {

		tmp = pit_read(frc);

		ADDPITSPEC((WORD) (lastTime - tmp), &globalCounter);

		lastTime = tmp;

		PITSPEC2TIMESPEC(&globalCounter, &now);

	} else {

		ll_read_timespec(&now);

	}

	if (firstevent != NULL) {

		activeEvent = 1;

		if (TIMESPEC_A_GT_B(&now, &(firstevent->time))) {

			if (!activeInt && evt_prol != NULL) {

				evt_prol();

			}

			activeInt++;

			for (p = firstevent; p != NULL; p = pp) {

				if ((p->time.tv_sec > now.tv_sec) ||

				   ((p->time.tv_sec == now.tv_sec)

				   && (p->time.tv_nsec > now.tv_nsec))) {

					break;

				}

				pp = p->next;

				p->next = freeevents;

				freeevents = p;

				firstevent = pp;

				p->handler(p->par);

			}

			if (activeInt == 1 && evt_epil != NULL) {

				evt_epil();

			}

			activeInt--;

		}

		if (!use_tsc) {

			tmp = pit_read(frc);

			ADDPITSPEC((WORD) (lastTime - tmp), &globalCounter);

			lastTime = tmp;

			PITSPEC2TIMESPEC(&globalCounter, &now);

		} else {

			ll_read_timespec(&now);

		}

		if (TIMESPEC_A_GT_B(&now, &(firstevent->time))) {

			NULL_TIMESPEC(&ttmp);

		} else {

			SUBTIMESPEC(&(firstevent->time), &now, &ttmp);

		}

		/*  SUBTIMESPEC(&(firstevent->time), &now, &ttmp); */

		tnext = TIMESPEC2USEC(&ttmp);

		if (!use_apic) {

			mul32div32to32(tnext,1193182,1000000,tnext);

			pit_setconstant(0, tnext);

		} else {

			mul32div32to32(tnext,apic_clk_per_msec,1000,tnext);

			set_APIC_timer(tnext);

		}

		activeEvent = 0;

	} else {

		if (!use_apic)

			pit_setconstant(0, 0xFFFF);

		else

			set_APIC_timer(0xFFFFFFFF);

	}

	TRACER_LOGEVENT(FTrace_EVT_timer_wakeup_end, (unsigned short int)currCtx, 0);

}

int oneshot_event_delete(int index)

{

	struct event *p1, *t;

	struct timespec tmp, now;

	DWORD tnext;

	int firstdeleted = FALSE;

	TRACER_LOGEVENT(FTrace_EVT_timer_delete, 0, 0);

	if (index == -1)

		return -1;

	t = NULL;

	/* walk through list, finding spot, adjusting ticks parameter */

	for (p1 = firstevent; (p1) && (index != p1->index); p1 = t->next) {

		t = p1;

	}

	if (p1 == NULL) {

		return -1;

	}

	if (t == NULL) {

		firstevent = p1->next;

		firstdeleted = TRUE;

	} else {

		t->next = p1->next;

	}

	p1->next = freeevents;

	freeevents = p1;

	if (!activeEvent) {

		if (firstevent == NULL) {

			if (!use_apic)

				pit_setconstant(0, 0xFFFF);

			else

				set_APIC_timer(0xFFFFFFFF);

		} else {

			if (firstdeleted) {

				if (!use_tsc)

					ll_gettime(TIME_NEW, &now);

				else

					ll_read_timespec(&now);

				if (TIMESPEC_A_GT_B(&now, &(firstevent->time))) {

					NULL_TIMESPEC(&tmp);

				} else {

					SUBTIMESPEC(&(firstevent->time), &now, &tmp);

				}

				/*SUBTIMESPEC(&now, &(firstevent->time), &tmp); */

				tnext = TIMESPEC2USEC(&tmp);

				if (!use_apic) {

					mul32div32to32(tnext,1193182,1000000,tnext);

					pit_setconstant(0, tnext);

				} else {

					mul32div32to32(tnext,apic_clk_per_msec,1000,tnext);

					set_APIC_timer(tnext);

				}

			}

		}

	}

	return 1;

}