FreeCalypso > hg > freecalypso-sw

comparison gsm-fw/gpf/osl/os_tim_ir.c @ 482:9d80090a9e0c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
os_tim_{fl,ir}.c: timer list concurrency interlocks redesigned to something sensible
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Sun, 29 Jun 2014 07:37:22 +0000
parents 5639b4fa8672
children
comparison
equal deleted inserted replaced
481:5639b4fa8672 482:9d80090a9e0c
1 /* 1 /*
2 * This C module is a reconstruction based on the disassembly of 2 * This C module is a reconstruction based on the disassembly of
3 * os_tim.obj in frame_na7_db_ir.lib from the Leonardo package. 3 * os_tim.obj in frame_na7_db_ir.lib from the Leonardo package,
4 * subsequently reworked by Space Falcon.
5 *
6 * The original decompilation has been contributed by Das Signal.
4 */ 7 */
5 8
6 /* set of included headers from COFF symtab: */ 9 /* set of included headers from COFF symtab: */
7 #include <stdio.h> 10 #include <stdio.h>
8 #include "gpfconf.h" /* FreeCalypso addition */ 11 #include "gpfconf.h" /* FreeCalypso addition */
17 extern T_OS_TIMER_TABLE_ENTRY *p_list[]; 20 extern T_OS_TIMER_TABLE_ENTRY *p_list[];
18 21
19 extern unsigned os_time_to_tick_multiplier; 22 extern unsigned os_time_to_tick_multiplier;
20 extern unsigned os_tick_to_time_multiplier; 23 extern unsigned os_tick_to_time_multiplier;
21 24
22 extern unsigned t_start_ticks; 25 extern unsigned volatile t_start_ticks;
23 extern T_OS_TIMER_TABLE_ENTRY * volatile t_running; 26 extern T_OS_TIMER_TABLE_ENTRY *t_running;
24 extern int used_timers; 27 extern int used_timers;
25 extern int next_t_handle; 28 extern int next_t_handle;
26 extern int volatile t_list_access; 29 extern int volatile t_list_access;
27 extern int max_used_timers; 30 extern int max_used_timers;
28 extern NU_SEMAPHORE TimSemCB; 31 extern NU_SEMAPHORE TimSemCB;
29 extern NU_TIMER os_timer_cb; 32 extern NU_TIMER os_timer_cb;
30 33
34 #define BARRIER asm volatile ("": : :"memory")
35
31 void 36 void
32 timer_error(int err) 37 timer_error(int err)
33 { 38 {
34 } 39 }
35 40
36 /* 41 /* forward declaration */
37 * The following function reconstructions have been contributed by Das Signal, 42 void os_Timeout(UNSIGNED t_handle);
38 * then reviewed and fixed in a few places by Space Falcon. 43
39 */ 44 static int
45 os_remove_timer_from_list(T_OS_TIMER_TABLE_ENTRY *timer)
46 {
47 OS_TICK c_ticks;
48
49 if (timer != t_running) {
50 if (timer->next != t_running)
51 timer->next->r_ticks += timer->r_ticks;
52 } else {
53 c_ticks = NU_Retrieve_Clock();
54 if (timer->next == timer) {
55 t_running = 0;
56 } else {
57 timer->next->r_ticks =
58 t_start_ticks + timer->r_ticks +
59 timer->next->r_ticks - c_ticks;
60 t_running = timer->next;
61 }
62 NU_Control_Timer(&os_timer_cb, NU_DISABLE_TIMER);
63 if (t_running != NULL) {
64 t_start_ticks = c_ticks;
65 if (t_running->r_ticks != 0)
66 NU_Reset_Timer(&os_timer_cb, os_Timeout,
67 t_running->r_ticks, 0,
68 NU_ENABLE_TIMER);
69 }
70 }
71 if (timer->next != timer) {
72 timer->prev->next = timer->next;
73 timer->next->prev = timer->prev;
74 }
75 timer->next = NULL;
76 timer->prev = NULL;
77 timer->status = TMR_USED;
78 return TMR_USED;
79 }
80
81 static unsigned
82 os_add_timer_to_list(T_OS_TIMER_TABLE_ENTRY *timer, OS_TICK ticks)
83 {
84 T_OS_TIMER_TABLE_ENTRY *t_list;
85 OS_TICK c_ticks, e_ticks, r1_ticks, return_ticks;
86
87 if (ticks == 0)
88 ticks = 1;
89
90 c_ticks = NU_Retrieve_Clock();
91 t_list = t_running;
92 if (t_list != NULL) {
93 e_ticks = c_ticks - t_start_ticks;
94 if (t_list->r_ticks >= e_ticks) {
95 r1_ticks = t_list->r_ticks - e_ticks;
96 t_list->r_ticks = r1_ticks;
97 } else {
98 r1_ticks = 0;
99 t_list->r_ticks = 0;
100 }
101 t_start_ticks = c_ticks;
102 return_ticks = 0;
103 while (ticks >= r1_ticks) {
104 ticks -= r1_ticks;
105 t_list = t_list->next;
106 if (t_list == t_running)
107 goto out;
108 r1_ticks = t_list->r_ticks;
109 }
110 t_list->r_ticks -= ticks;
111 if (t_list == t_running) {
112 t_running = timer;
113 t_start_ticks = c_ticks;
114 NU_Control_Timer(&os_timer_cb, NU_DISABLE_TIMER);
115 return_ticks = ticks;
116 }
117 out:
118 timer->next = t_list;
119 timer->prev = t_list->prev;
120 t_list->prev->next = timer;
121 t_list->prev = timer;
122 timer->r_ticks = ticks;
123 } else {
124 timer->next = timer;
125 timer->prev = timer;
126 timer->r_ticks = ticks;
127 t_start_ticks = c_ticks;
128 t_running = timer;
129 return_ticks = ticks;
130 }
131 timer->status = TMR_ACTIVE;
132 return return_ticks;
133 }
40 134
41 void 135 void
42 os_Timeout(UNSIGNED t_handle) /* argument is unused */ 136 os_Timeout(UNSIGNED t_handle) /* argument is unused */
43 { 137 {
44 ULONG s_ticks; 138 ULONG s_ticks;
46 USHORT t_index; 140 USHORT t_index;
47 int i, done; 141 int i, done;
48 T_OS_TIMER_TABLE_ENTRY **t_r4; 142 T_OS_TIMER_TABLE_ENTRY **t_r4;
49 T_OS_TIMER_TABLE_ENTRY *timer; 143 T_OS_TIMER_TABLE_ENTRY *timer;
50 void (*timeout_func) (OS_HANDLE, OS_HANDLE, USHORT); 144 void (*timeout_func) (OS_HANDLE, OS_HANDLE, USHORT);
51 OS_TIME resched_time;
52 145
53 if (t_list_access) { 146 if (t_list_access) {
54 t_start_ticks++; 147 t_start_ticks++;
55 NU_Reset_Timer(&os_timer_cb, os_Timeout, 1, 0, 148 NU_Reset_Timer(&os_timer_cb, os_Timeout, 1, 0,
56 NU_ENABLE_TIMER); 149 NU_ENABLE_TIMER);
57 return; 150 return;
58 } 151 }
59 152
60 t_list_access = 1;
61 timer = t_running; 153 timer = t_running;
62 if (timer) { 154 if (timer) {
63 s_ticks = 0; 155 s_ticks = 0;
64 done = 0; 156 done = 0;
65 i = 0; 157 i = 0;
94 NU_ENABLE_TIMER); 186 NU_ENABLE_TIMER);
95 } 187 }
96 } 188 }
97 for (t_r4 = p_list; *t_r4; t_r4++) { 189 for (t_r4 = p_list; *t_r4; t_r4++) {
98 timer = *t_r4; 190 timer = *t_r4;
99 resched_time = SYSTEM_TICKS_TO_TIME(timer->p_ticks); 191 s_ticks = os_add_timer_to_list(timer, timer->p_ticks);
100 os_StartTimer(timer->entity_handle, timer->t_handle, 192 if (s_ticks)
101 timer->t_index, resched_time, resched_time); 193 NU_Reset_Timer(&os_timer_cb, os_Timeout, s_ticks, 0,
194 NU_ENABLE_TIMER);
102 *t_r4 = NULL; 195 *t_r4 = NULL;
103 } 196 }
104
105 t_list_access = 0;
106 return;
107 }
108
109 static int
110 os_remove_timer_from_list(T_OS_TIMER_TABLE_ENTRY *timer)
111 {
112 OS_TICK c_ticks;
113
114 if (timer != t_running) {
115 if (timer->next != t_running)
116 timer->next->r_ticks += timer->r_ticks;
117 } else {
118 c_ticks = NU_Retrieve_Clock();
119 if (timer->next == timer) {
120 t_running = 0;
121 } else {
122 timer->next->r_ticks =
123 t_start_ticks + timer->r_ticks +
124 timer->next->r_ticks - c_ticks;
125 t_running = timer->next;
126 }
127 NU_Control_Timer(&os_timer_cb, NU_DISABLE_TIMER);
128 if (t_running != NULL) {
129 t_start_ticks = c_ticks;
130 if (t_running->r_ticks != 0)
131 NU_Reset_Timer(&os_timer_cb, os_Timeout,
132 t_running->r_ticks, 0,
133 NU_ENABLE_TIMER);
134 }
135 }
136 if (timer->next != timer) {
137 timer->prev->next = timer->next;
138 timer->next->prev = timer->prev;
139 }
140 timer->next = NULL;
141 timer->prev = NULL;
142 timer->status = TMR_USED;
143 return TMR_USED;
144 }
145
146 static unsigned
147 os_add_timer_to_list(T_OS_TIMER_TABLE_ENTRY *timer, OS_TICK ticks)
148 {
149 T_OS_TIMER_TABLE_ENTRY *t_list;
150 OS_TICK c_ticks, r1_ticks, return_ticks;
151
152 if (ticks == 0)
153 ticks = 1;
154
155 c_ticks = NU_Retrieve_Clock();
156 t_list = t_running;
157 if (t_list != NULL) {
158 if (t_list->r_ticks >= c_ticks - t_start_ticks) {
159 r1_ticks = t_list->r_ticks - c_ticks + t_start_ticks;
160 t_list->r_ticks = r1_ticks;
161 } else {
162 r1_ticks = 0;
163 t_list->r_ticks = 0;
164 }
165 t_start_ticks = c_ticks;
166 return_ticks = 0;
167 while (ticks >= r1_ticks) {
168 ticks -= r1_ticks;
169 t_list = t_list->next;
170 if (t_list == t_running)
171 goto out;
172 r1_ticks = t_list->r_ticks;
173 }
174 t_list->r_ticks -= ticks;
175 if (t_list == t_running) {
176 t_running = timer;
177 t_start_ticks = c_ticks;
178 NU_Control_Timer(&os_timer_cb, NU_DISABLE_TIMER);
179 return_ticks = ticks;
180 }
181 out:
182 timer->next = t_list;
183 timer->prev = t_list->prev;
184 t_list->prev->next = timer;
185 t_list->prev = timer;
186 timer->r_ticks = ticks;
187 } else {
188 timer->next = timer;
189 timer->prev = timer;
190 timer->r_ticks = ticks;
191 t_start_ticks = c_ticks;
192 t_running = timer;
193 return_ticks = ticks;
194 }
195 timer->status = TMR_ACTIVE;
196 return return_ticks;
197 } 197 }
198 198
199 GLOBAL LONG os_StartTimer(OS_HANDLE TaskHandle, OS_HANDLE TimerHandle, 199 GLOBAL LONG os_StartTimer(OS_HANDLE TaskHandle, OS_HANDLE TimerHandle,
200 USHORT Index, OS_TIME InitialTime, 200 USHORT Index, OS_TIME InitialTime,
201 OS_TIME RescheduleTime) 201 OS_TIME RescheduleTime)
202 { 202 {
203 T_OS_TIMER_TABLE_ENTRY *timer; 203 T_OS_TIMER_TABLE_ENTRY *timer;
204 OS_TICK ticks; 204 OS_TICK ticks;
205 USHORT status;
206 STATUS sts; 205 STATUS sts;
207 206
207 if (TimerHandle > MaxSimultaneousTimer)
208 return(OS_ERROR);
209 timer = &TimerTable[TimerHandle].entry;
210 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
211 if (timer->status == TMR_FREE) {
212 if (sts == NU_SUCCESS)
213 NU_Release_Semaphore(&TimSemCB);
214 return(OS_ERROR);
215 }
208 t_list_access = 1; 216 t_list_access = 1;
209 timer = &TimerTable[TimerHandle].entry; 217 BARRIER;
210 if (TimerHandle > MaxSimultaneousTimer || timer->status == TMR_FREE) { 218 if (timer->status == TMR_ACTIVE)
211 t_list_access = 0; 219 os_remove_timer_from_list(timer);
212 return OS_ERROR;
213 }
214
215 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
216 /* Disassembly reveals this bogon in the original code:
217 if (sts != NU_SUCCESS)
218 os_MyHandle();
219 */
220 status = timer->status;
221 if (status == TMR_ACTIVE)
222 status = os_remove_timer_from_list(timer);
223 timer->t_handle = TimerHandle; 220 timer->t_handle = TimerHandle;
224 timer->task_handle = os_MyHandle(); 221 timer->task_handle = os_MyHandle();
225 timer->entity_handle = TaskHandle; 222 timer->entity_handle = TaskHandle;
226 timer->t_index = Index; 223 timer->t_index = Index;
227 timer->p_ticks = TIME_TO_SYSTEM_TICKS(RescheduleTime); 224 timer->p_ticks = TIME_TO_SYSTEM_TICKS(RescheduleTime);
228 ticks = os_add_timer_to_list(timer, TIME_TO_SYSTEM_TICKS(InitialTime)); 225 ticks = os_add_timer_to_list(timer, TIME_TO_SYSTEM_TICKS(InitialTime));
229 if (ticks) 226 if (ticks)
230 NU_Reset_Timer(&os_timer_cb, os_Timeout, ticks, 0, 227 NU_Reset_Timer(&os_timer_cb, os_Timeout, ticks, 0,
231 NU_ENABLE_TIMER); 228 NU_ENABLE_TIMER);
229 BARRIER;
230 t_list_access = 0;
232 if (sts == NU_SUCCESS) 231 if (sts == NU_SUCCESS)
233 NU_Release_Semaphore(&TimSemCB); 232 NU_Release_Semaphore(&TimSemCB);
234 t_list_access = 0;
235 return OS_OK; 233 return OS_OK;
236 } 234 }
237 235
238 GLOBAL LONG os_StopTimer(OS_HANDLE TaskHandle, OS_HANDLE TimerHandle) 236 GLOBAL LONG os_StopTimer(OS_HANDLE TaskHandle, OS_HANDLE TimerHandle)
239 /* TaskHandle argument is unused */ 237 /* TaskHandle argument is unused */
240 { 238 {
241 T_OS_TIMER_ENTRY *timer_e; 239 T_OS_TIMER_ENTRY *timer_e;
242 STATUS sts; 240 STATUS sts;
243 241
242 if (TimerHandle > MaxSimultaneousTimer)
243 return(OS_ERROR);
244 timer_e = &TimerTable[TimerHandle];
245 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
246 if (timer_e->entry.status == TMR_FREE) {
247 if (sts == NU_SUCCESS)
248 NU_Release_Semaphore(&TimSemCB);
249 return OS_ERROR;
250 }
244 t_list_access = 1; 251 t_list_access = 1;
245 timer_e = &TimerTable[TimerHandle]; 252 BARRIER;
246 if (TimerHandle > MaxSimultaneousTimer ||
247 timer_e->entry.status == TMR_FREE) {
248 t_list_access = 0;
249 return OS_ERROR;
250 }
251 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
252 if (timer_e->entry.status == TMR_ACTIVE) 253 if (timer_e->entry.status == TMR_ACTIVE)
253 os_remove_timer_from_list(&timer_e->entry); 254 os_remove_timer_from_list(&timer_e->entry);
255 BARRIER;
256 t_list_access = 0;
254 if (sts == NU_SUCCESS) 257 if (sts == NU_SUCCESS)
255 NU_Release_Semaphore(&TimSemCB); 258 NU_Release_Semaphore(&TimSemCB);
256 t_list_access = 0;
257 return OS_OK; 259 return OS_OK;
258 } 260 }
259 261
260 GLOBAL LONG os_IncrementTick(OS_TICK ticks) 262 GLOBAL LONG os_IncrementTick(OS_TICK ticks)
261 { 263 {
266 /* TaskHandle argument is unused */ 268 /* TaskHandle argument is unused */
267 { 269 {
268 STATUS sts; 270 STATUS sts;
269 T_OS_TIMER_ENTRY *timer_e; 271 T_OS_TIMER_ENTRY *timer_e;
270 272
271 t_list_access = 1; 273 if (TimerHandle > MaxSimultaneousTimer)
274 return(OS_ERROR);
272 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND); 275 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
273 timer_e = &TimerTable[TimerHandle]; 276 timer_e = &TimerTable[TimerHandle];
274 if (TimerHandle > MaxSimultaneousTimer || 277 if (timer_e->entry.status != TMR_USED) {
275 timer_e->entry.status == TMR_FREE) {
276 if (sts == NU_SUCCESS) 278 if (sts == NU_SUCCESS)
277 NU_Release_Semaphore(&TimSemCB); 279 NU_Release_Semaphore(&TimSemCB);
278 t_list_access = 0;
279 return OS_ERROR; 280 return OS_ERROR;
280 } 281 }
281 timer_e->next_t_handle = next_t_handle; 282 timer_e->next_t_handle = next_t_handle;
282 next_t_handle = TimerHandle; 283 next_t_handle = TimerHandle;
283 timer_e->entry.status = TMR_FREE; 284 timer_e->entry.status = TMR_FREE;
284 used_timers--; 285 used_timers--;
285 t_list_access = 0;
286 if (sts == NU_SUCCESS) 286 if (sts == NU_SUCCESS)
287 NU_Release_Semaphore(&TimSemCB); 287 NU_Release_Semaphore(&TimSemCB);
288 return OS_OK; 288 return OS_OK;
289 } 289 }
290 290
294 /* TaskHandle and MemPoolHandle arguments are unused */ 294 /* TaskHandle and MemPoolHandle arguments are unused */
295 { 295 {
296 STATUS sts; 296 STATUS sts;
297 T_OS_TIMER_ENTRY *timer_e; 297 T_OS_TIMER_ENTRY *timer_e;
298 298
299 t_list_access = 1;
300 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND); 299 sts = NU_Obtain_Semaphore(&TimSemCB, NU_SUSPEND);
301 if (next_t_handle == 0) { /* no free timers left */ 300 if (next_t_handle == 0) { /* no free timers left */
302 if (sts == NU_SUCCESS) 301 if (sts == NU_SUCCESS)
303 NU_Release_Semaphore(&TimSemCB); 302 NU_Release_Semaphore(&TimSemCB);
304 t_list_access = 0;
305 return OS_ERROR; 303 return OS_ERROR;
306 } 304 }
307 305
308 timer_e = &TimerTable[next_t_handle]; 306 timer_e = &TimerTable[next_t_handle];
309 timer_e->entry.status = TMR_USED; 307 timer_e->entry.status = TMR_USED;
313 used_timers++; 311 used_timers++;
314 if (max_used_timers < used_timers) 312 if (max_used_timers < used_timers)
315 max_used_timers = used_timers; 313 max_used_timers = used_timers;
316 if (sts == NU_SUCCESS) 314 if (sts == NU_SUCCESS)
317 NU_Release_Semaphore(&TimSemCB); 315 NU_Release_Semaphore(&TimSemCB);
318 t_list_access = 0; 316 return OS_OK;
319 return OS_OK; 317 }
320 }