1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/* Task scheduling / events module for Chrome EC operating system */
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include "atomic.h"
#include "common.h"
#include "task.h"
#include "task_id.h"
#include "timer.h"
struct emu_task_t {
pthread_t thread;
pthread_cond_t resume;
uint32_t event;
timestamp_t wake_time;
};
struct task_args {
void (*routine)(void *);
void *d;
};
static struct emu_task_t tasks[TASK_ID_COUNT];
static pthread_cond_t scheduler_cond;
static pthread_mutex_t run_lock;
static __thread task_id_t my_task_id; /* thread local task id */
#define TASK(n, r, d, s) void r(void *);
CONFIG_TASK_LIST
CONFIG_TEST_TASK_LIST
#undef TASK
/* Idle task */
void __idle(void *d)
{
while (1)
task_wait_event(-1);
}
/* Weak reference function as an entry point for unit test */
test_mockable void run_test(void) { }
void _run_test(void *d)
{
run_test();
}
#define TASK(n, r, d, s) {r, d},
struct task_args task_info[TASK_ID_COUNT] = {
{__idle, NULL},
CONFIG_TASK_LIST
CONFIG_TEST_TASK_LIST
{_run_test, NULL},
};
#undef TASK
#define TASK(n, r, d, s) #n,
static const char * const task_names[] = {
"<< idle >>",
CONFIG_TASK_LIST
CONFIG_TEST_TASK_LIST
"<< test runner >>",
};
#undef TASK
void task_pre_init(void)
{
/* Nothing */
}
int in_interrupt_context(void)
{
return 0; /* No interrupt support yet */
}
void interrupt_disable(void)
{
/* Not supported yet */
}
void interrupt_enable(void)
{
/* Not supported yet */
}
uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
{
tasks[tskid].event = event;
if (wait)
return task_wait_event(-1);
return 0;
}
uint32_t task_wait_event(int timeout_us)
{
int tid = task_get_current();
int ret;
if (timeout_us > 0)
tasks[tid].wake_time.val = get_time().val + timeout_us;
pthread_cond_signal(&scheduler_cond);
pthread_cond_wait(&tasks[tid].resume, &run_lock);
ret = tasks[tid].event;
tasks[tid].event = 0;
return ret;
}
void mutex_lock(struct mutex *mtx)
{
int value = 0;
int id = 1 << task_get_current();
mtx->waiters |= id;
do {
if (mtx->lock == 0) {
mtx->lock = 1;
value = 1;
}
if (!value)
task_wait_event(-1);
} while (!value);
mtx->waiters &= ~id;
}
void mutex_unlock(struct mutex *mtx)
{
int v;
mtx->lock = 0;
for (v = 31; v >= 0; --v)
if ((1ul << v) & mtx->waiters) {
mtx->waiters &= ~(1ul << v);
task_set_event(v, TASK_EVENT_MUTEX, 0);
break;
}
}
task_id_t task_get_current(void)
{
return my_task_id;
}
void task_scheduler(void)
{
int i;
timestamp_t now;
while (1) {
now = get_time();
i = TASK_ID_COUNT - 1;
while (i >= 0) {
if (tasks[i].event || now.val >= tasks[i].wake_time.val)
break;
--i;
}
if (i < 0)
i = TASK_ID_IDLE;
tasks[i].wake_time.val = ~0ull;
pthread_cond_signal(&tasks[i].resume);
pthread_cond_wait(&scheduler_cond, &run_lock);
}
}
void *_task_start_impl(void *a)
{
long tid = (long)a;
struct task_args *arg = task_info + tid;
my_task_id = tid;
pthread_mutex_lock(&run_lock);
tasks[tid].event = 0;
(arg->routine)(arg->d);
while (1)
task_wait_event(-1);
}
int task_start(void)
{
int i;
pthread_mutex_init(&run_lock, NULL);
pthread_cond_init(&scheduler_cond, NULL);
pthread_mutex_lock(&run_lock);
for (i = 0; i < TASK_ID_COUNT; ++i) {
tasks[i].event = TASK_EVENT_WAKE;
tasks[i].wake_time.val = ~0ull;
pthread_cond_init(&tasks[i].resume, NULL);
pthread_create(&tasks[i].thread, NULL, _task_start_impl,
(void *)(size_t)i);
pthread_cond_wait(&scheduler_cond, &run_lock);
}
task_scheduler();
return 0;
}
|
