Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1659 giacomo 1
/*
2
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
3
 *
4
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
5
 *               Gerardo Lamastra <gerardo@sssup.it>
6
 *
7
 * Authors     : Paolo Gai <pj@hartik.sssup.it>
8
 * (see authors.txt for full list of hartik's authors)
9
 *
10
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
11
 *
12
 * http://www.sssup.it
13
 * http://retis.sssup.it
14
 * http://hartik.sssup.it
15
 */
16
 
17
/*
18
 * Copyright (C) 2000 Paolo Gai
19
 *
20
 * This program is free software; you can redistribute it and/or modify
21
 * it under the terms of the GNU General Public License as published by
22
 * the Free Software Foundation; either version 2 of the License, or
23
 * (at your option) any later version.
24
 *
25
 * This program is distributed in the hope that it will be useful,
26
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28
 * GNU General Public License for more details.
29
 *
30
 * You should have received a copy of the GNU General Public License
31
 * along with this program; if not, write to the Free Software
32
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
33
 *
34
 */
35
 
36
 
37
#include "mymod.h"
38
#include <ll/string.h>
39
#include <kernel/model.h>
40
#include <kernel/descr.h>
41
#include <kernel/var.h>
42
#include <kernel/func.h>
43
 
44
// other include files if needed
45
 
46
// NOTE: NO GLOBAL OR STATIC VARIABLES!!!
47
// (put them inside the level descriptor!)
48
 
49
/* Statuses used in the level */
50
#define MYMOD_READY         MODULE_STATUS_BASE
51
#define MYMOD_WAIT          MODULE_STATUS_BASE+3
52
#define MYMOD_IDLE          MODULE_STATUS_BASE+4
53
 
54
/* the level redefinition for the Module */
55
typedef struct {
56
  level_des l;     /* the standard level descriptor          */
57
 
58
  int myvar[100];  /* other local (private) variables of the module */
59
 
60
} MYMOD_level_des;
61
 
62
// example of OSLib event
63
static void MYMOD_timer_deadline(void *par)
64
{
65
  // usually the void *par is a pointer to a structure or a PID
66
  // if it is a PID, you can do that to retrieve it and the correspondent
67
  // level descriptor
68
  PID p = (PID) par;
69
  MYMOD_level_des *lev;
70
 
71
  lev = (MYMOD_level_des *)level_table[proc_table[p].task_level];
72
 
73
  // now you know the PID of the task and the level descriptor
74
  // ... so, you know all the things you need
75
}
76
 
77
static int MYMOD_level_accept_task_model(LEVEL l, TASK_MODEL *m)
78
{
79
  // your code here
80
  return 0; // dummy number
81
}
82
 
83
static int MYMOD_level_accept_guest_model(LEVEL l, TASK_MODEL *m)
84
{
85
  // your code here
86
  return 0; // dummy number
87
}
88
 
89
static void MYMOD_level_status(LEVEL l)
90
{
91
}
92
 
93
/* The scheduler only gets the first task in the queue */
94
static PID MYMOD_level_scheduler(LEVEL l)
95
{
96
  return 0; // dummy number
97
}
98
 
99
/* The on-line guarantee is enabled only if the appropriate flag is set... */
100
static int MYMOD_level_guarantee(LEVEL l, bandwidth_t *freebandwidth)
101
{
102
  return 0; // dummy number
103
}
104
 
105
static int MYMOD_task_create(LEVEL l, PID p, TASK_MODEL *m)
106
{
107
  return 0; // dummy number
108
}
109
 
110
static void MYMOD_task_detach(LEVEL l, PID p)
111
{
112
}
113
 
114
static int MYMOD_task_eligible(LEVEL l, PID p)
115
{
116
  return 0; // dummy number
117
}
118
 
119
static void MYMOD_task_dispatch(LEVEL l, PID p, int nostop)
120
{
121
}
122
 
123
static void MYMOD_task_epilogue(LEVEL l, PID p)
124
{
125
}
126
 
127
static void MYMOD_task_activate(LEVEL l, PID p)
128
{
129
}
130
 
131
static void MYMOD_task_insert(LEVEL l, PID p)
132
{
133
}
134
 
135
static void MYMOD_task_extract(LEVEL l, PID p)
136
{
137
}
138
 
139
static void MYMOD_task_endcycle(LEVEL l, PID p)
140
{
141
}
142
 
143
static void MYMOD_task_end(LEVEL l, PID p)
144
{
145
}
146
 
147
static void MYMOD_task_sleep(LEVEL l, PID p)
148
{
149
}
150
 
151
static void MYMOD_task_delay(LEVEL l, PID p, TIME usdelay)
152
{
153
}
154
 
155
static int MYMOD_guest_create(LEVEL l, PID p, TASK_MODEL *m)
156
{
157
  return 0; // dummy number
158
}
159
 
160
static void MYMOD_guest_detach(LEVEL l, PID p)
161
{
162
}
163
 
164
static void MYMOD_guest_dispatch(LEVEL l, PID p, int nostop)
165
{
166
}
167
 
168
static void MYMOD_guest_epilogue(LEVEL l, PID p)
169
{
170
}
171
 
172
static void MYMOD_guest_activate(LEVEL l, PID p)
173
{
174
}
175
 
176
static void MYMOD_guest_insert(LEVEL l, PID p)
177
{
178
}
179
 
180
static void MYMOD_guest_extract(LEVEL l, PID p)
181
{
182
}
183
 
184
static void MYMOD_guest_endcycle(LEVEL l, PID p)
185
{
186
}
187
 
188
static void MYMOD_guest_end(LEVEL l, PID p)
189
{
190
}
191
 
192
static void MYMOD_guest_sleep(LEVEL l, PID p)
193
{
194
}
195
 
196
static void MYMOD_guest_delay(LEVEL l, PID p, TIME usdelay)
197
{
198
}
199
 
200
 
201
 
202
 
203
/* Registration functions */
204
 
205
/*+ Registration function:
206
    int flags                 the init flags ... see MYMOD.h +*/
207
void MYMOD_register_level(int flags)
208
{
209
  LEVEL l;            /* the level that we register */
210
  MYMOD_level_des *lev;  /* for readableness only */
211
  PID i;              /* a counter */
212
 
213
  /* request an entry in the level_table */
214
  l = level_alloc_descriptor();
215
 
216
  /* alloc the space needed for the MYMOD_level_des */
217
  lev = (MYMOD_level_des *)kern_alloc(sizeof(MYMOD_level_des));
218
 
219
  /* update the level_table with the new entry */
220
  level_table[l] = (level_des *)lev;
221
 
222
  /* fill the standard descriptor */
223
  strncpy(lev->l.level_name,  MYMOD_LEVELNAME, MAX_LEVELNAME);
224
  lev->l.level_code               = MYMOD_LEVEL_CODE;
225
  lev->l.level_version            = MYMOD_LEVEL_VERSION;
226
 
227
  lev->l.level_accept_task_model  = MYMOD_level_accept_task_model;
228
  lev->l.level_accept_guest_model = MYMOD_level_accept_guest_model;
229
  lev->l.level_status             = MYMOD_level_status;
230
  lev->l.level_scheduler          = MYMOD_level_scheduler;
231
  lev->l.level_guarantee          = MYMOD_level_guarantee;
232
 
233
  lev->l.task_create              = MYMOD_task_create;
234
  lev->l.task_detach              = MYMOD_task_detach;
235
  lev->l.task_eligible            = MYMOD_task_eligible;
236
  lev->l.task_dispatch            = MYMOD_task_dispatch;
237
  lev->l.task_epilogue            = MYMOD_task_epilogue;
238
  lev->l.task_activate            = MYMOD_task_activate;
239
  lev->l.task_insert              = MYMOD_task_insert;
240
  lev->l.task_extract             = MYMOD_task_extract;
241
  lev->l.task_endcycle            = MYMOD_task_endcycle;
242
  lev->l.task_end                 = MYMOD_task_end;
243
  lev->l.task_sleep               = MYMOD_task_sleep;
244
  lev->l.task_delay               = MYMOD_task_delay;
245
 
246
  lev->l.guest_create             = MYMOD_guest_create;
247
  lev->l.guest_detach             = MYMOD_guest_detach;
248
  lev->l.guest_dispatch           = MYMOD_guest_dispatch;
249
  lev->l.guest_epilogue           = MYMOD_guest_epilogue;
250
  lev->l.guest_activate           = MYMOD_guest_activate;
251
  lev->l.guest_insert             = MYMOD_guest_insert;
252
  lev->l.guest_extract            = MYMOD_guest_extract;
253
  lev->l.guest_endcycle           = MYMOD_guest_endcycle;
254
  lev->l.guest_end                = MYMOD_guest_end;
255
  lev->l.guest_sleep              = MYMOD_guest_sleep;
256
  lev->l.guest_delay              = MYMOD_guest_delay;
257
 
258
  /* fill the MYMOD descriptor part */
259
  for (i=0; i<100; i++)
260
    lev->myvar[i] = 0;
261
}
262
 
263
// put here the other interface functions added
264
 
265
 
266
 
267
 
268
 
269
 
270