Subversion Repositories shark

Rev

Rev 496 | Rev 514 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
490 giacomo 1
#include <kernel/int_sem.h>
2
#include <stdlib.h>
496 giacomo 3
#include <kernel/func.h>
4
#include <ll/sys/ll/event.h>
490 giacomo 5
 
513 giacomo 6
PID intr_server = NIL;
7
 
8
#define MAX_INT_LIST 50
9
 
10
void *int_arg_table[16];
11
void *int_func_table[16];
12
 
13
int int_list[MAX_INT_LIST];
14
int next_free_int = 0;
15
int next_execute_int = 0;
16
 
17
/* FIFO add job */
18
int add_interrupt_job(int no)
19
{
20
 
21
        int_list[next_free_int] = no;
22
        next_free_int++;
23
 
24
        if (next_free_int == MAX_INT_LIST) next_free_int = 0;
25
        if (next_free_int == next_execute_int) {
26
                next_free_int--;
27
                return -1;
28
        }
29
 
30
        return 0;
31
 
32
}
33
 
34
/* FIFO get job */
35
int get_interrupt_job()
36
{
37
 
38
        int res = -1;
39
 
40
        if (next_free_int != next_execute_int) {
41
                res = int_list[next_execute_int];
42
                next_execute_int++;
43
                if (next_execute_int == MAX_INT_LIST) next_execute_int = 0;
44
        }
45
 
46
        return res;
47
 
48
}
49
 
50
extern void linux_intr(int no);
51
 
52
TASK Interrupt_Server(void *arg)
53
{
54
 
55
        int no;
56
 
57
        while(1) {
58
 
59
                no = get_interrupt_job();
60
                if (no != -1)
61
                        linux_intr(no);
62
 
63
                task_endcycle();
64
 
65
        }
66
 
67
}
68
 
69
int shark_interrupt_server() {
70
 
71
        HARD_TASK_MODEL ht;
72
        int i;
73
 
74
        for(i=0;i<16;i++) {
75
                int_arg_table[i] = NULL;
76
                int_func_table[i] = NULL;
77
        }
78
 
79
        hard_task_default_model(ht);
80
        hard_task_def_wcet(ht,10000);
81
        hard_task_def_interrupt(ht);
82
 
83
        intr_server = task_create("Interrupt Server",Interrupt_Server,&ht,NULL);
84
        if (intr_server != NIL)
85
                return 0;
86
        else
87
                return -1;
88
 
89
 
90
}
91
 
490 giacomo 92
void shark_internal_sem_create(void **sem, int init) {
496 giacomo 93
        *sem = (void *)malloc(sizeof(internal_sem_t));
94
        internal_sem_init((internal_sem_t *)(*sem),init);
490 giacomo 95
}
96
 
97
void shark_internal_sem_wait(void *sem) {
496 giacomo 98
        internal_sem_wait((internal_sem_t *)(sem));
99
}
490 giacomo 100
 
496 giacomo 101
void shark_internal_sem_post(void *sem) {
102
 internal_sem_post((internal_sem_t *)(sem));
103
}
490 giacomo 104
 
496 giacomo 105
int shark_event_post(const struct timespec *time, void (*handler)(void *p), void *par)
106
{
107
        return event_post(*time, handler, par);
490 giacomo 108
}
109
 
496 giacomo 110
int shark_event_delete(int index)
111
{
112
        return event_delete(index);
113
}
490 giacomo 114
 
513 giacomo 115
void fast_call(int no)
116
{
117
 
118
        int res;
119
 
120
        res = add_interrupt_job(no);
121
        if (intr_server != NIL && res == 0)
122
                task_activate(intr_server);
123
 
496 giacomo 124
}
490 giacomo 125
 
513 giacomo 126
int shark_handler_set(int no, void *fast, void *arg){
127
 
128
        if (no >= 1 && no < 16) {
129
                int_arg_table[no] = arg;
130
                int_func_table[no] = fast;
131
                return handler_set(no, fast_call, NIL, TRUE);
132
        } else {
133
                return -1;
134
        }
135
 
136
}
137
 
496 giacomo 138
int shark_handler_remove(int no){
139
        return handler_remove(no);
490 giacomo 140
}
496 giacomo 141