Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 494 → Rev 495

/shark/trunk/drivers/linuxc26/timer.c
0,0 → 1,151
/*
* Copyright (c) 1996 The University of Utah and
* the Computer Systems Laboratory at the University of Utah (CSL).
* All rights reserved.
*
* Permission to use, copy, modify and distribute this software is hereby
* granted provided that (1) source code retains these copyright, permission,
* and disclaimer notices, and (2) redistributions including binaries
* reproduce the notices in supporting documentation, and (3) all advertising
* materials mentioning features or use of this software display the following
* acknowledgement: ``This product includes software developed by the
* Computer Systems Laboratory at the University of Utah.''
*
* THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
* IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
* ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* CSL requests users of this software to return to csl-dist@cs.utah.edu any
* improvements that they make and grant CSL redistribution rights.
*/
/*
* Linux timer support.
*/
 
#include <linuxcomp.h>
 
#include <linux/kernel.h>
#include <linux/timer.h>
#include <asm/param.h>
 
//#define TIMER_DEBUG
 
//#define IANPATCH
#ifndef IANPATCH
 
static inline void jiffies_to_timespec(unsigned long j, struct timespec *value)
{
value->tv_nsec = (j % HZ) * (1000000000L / HZ);
value->tv_sec = j / HZ;
}
 
void add_timer(struct timer_list *timer)
{
struct timespec timeout;
 
jiffies_to_timespec(timer->expires, &timeout);
if (timer->function)
timer->event_timer = shark_event_post(&timeout, (void (*)(void *))timer->function, (void *)timer->data);
 
#ifdef TIMER_DEBUG
cprintf("Set to %ld:%ld\n",timeout.tv_sec,timeout.tv_nsec);
#endif
}
 
 
int del_timer(struct timer_list *timer)
{
shark_event_delete(timer->event_timer);
return 0; /* TODO */
}
 
int mod_timer(struct timer_list *timer, unsigned long expires)
{
shark_event_delete(timer->event_timer);
timer->expires = expires;
add_timer(timer);
return 0; /* TODO */
}
 
void init_timer(struct timer_list * timer)
{
timer->event_timer = -1;
timer->function = NULL;
}
 
int timer_pending(struct timer_list * timer){
return timer->event_timer != -1;
}
 
#else
 
/* CHECK!!!! */
 
#include <pthread.h>
 
/*Needs to have this sort of thing in the initfile
* PTHREAD_register_module(1, 0, 1);
*
* TIMER_register_module();
* PI_register_module();
* PC_register_module();
*/
 
pthread_attr_t task_attr; /* attributtes for the task doing the callback*/
 
static inline void
jiffies_to_timespec(unsigned long j, struct timespec *value)
{
value->tv_nsec = (j % HZ) * (1000000000L / HZ);
value->tv_sec = j / HZ;
}
 
int add_timer(struct timer_list *timer)
{
int err;
struct sigevent ev;
struct sched_param task_param;
struct itimerspec timeout;
 
ev.sigev_notify = SIGEV_THREAD;
ev.sigev_value.sival_int = timer->data;
ev.sigev_notify_function = timer->function;
ev.sigev_notify_attributes = &task_attr;
 
pthread_attr_init(&task_attr);
pthread_attr_setdetachstate(&task_attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setschedpolicy(&task_attr, SCHED_RR);
task_param.sched_priority = 10;
pthread_attr_setschedparam(&task_attr, &task_param);
 
err =timer_create(CLOCK_REALTIME, &ev, &(timer->sharktimer));
if (err !=0 ) { cprintf("timer: unable to create timer\n"); }
timeout.it_interval.tv_sec=0;
timeout.it_interval.tv_nsec=0;
jiffies_to_timespec(timer->expires, &(timeout.it_value));
 
err = timer_settime(timer->sharktimer, 0, &timeout, NULL);
if (err !=0 ) { cprintf("timer: unable to timer_settime\n"); }
return err;
}
 
 
void del_timer(struct timer_list *timer)
{
timer_delete(timer->sharktimer);
}
 
void mod_timer(struct timer_list *timer, unsigned long expires)
{
timer_delete(timer->sharktimer);
timer->expires=expires;
add_timer(timer);
}
 
void init_timer(struct timer_list * timer)
{
}
 
#endif
/shark/trunk/drivers/linuxc26/int.c
0,0 → 1,60
#include <linuxcomp.h>
 
#include <asm/ptrace.h>
#include <asm-generic/errno-base.h>
#include <linux/kernel.h>
 
#define NIL -1
 
static struct {
void (*func)(int, void *dev_id, struct pt_regs *);
void *data;
int flags;
} handlers[16];
 
unsigned long intr_count = 0;
 
/*
* Generic Linux interrupt handler.
*/
static void linux_intr(int irq)
{
struct pt_regs regs;
 
//printk("linux_intr %d\n", irq);
 
intr_count++;
 
(*handlers[irq].func)(irq, handlers[irq].data, &regs);
 
intr_count--;
 
}
 
/*
* Attach a handler to an IRQ.
*/
int request_irq(unsigned int irq, void (*handler)(int, void *dev_id, struct pt_regs *), unsigned long flags, const char *device, void *dev_id)
{
if (handlers[irq].func) {
return (-EBUSY);
}
handlers[irq].func = handler;
handlers[irq].flags = flags;
handlers[irq].data = dev_id;
 
shark_handler_set(irq, linux_intr, NIL, TRUE);
 
return 0;
}
 
/*
* Deallocate an irq.
*/
void free_irq(unsigned int irq, void *a)
{
shark_handler_remove(irq);
handlers[irq].func = 0;
}