Kev Mann / mbed-dev-OS5_10_4

RTC auf true

hal/mbed_ticker_api.c@2:7aab896b1a3b, 2019-03-13 (annotated)

Committer:
kevman
Date:
Wed Mar 13 11:03:24 2019 +0000
Revision:
2:7aab896b1a3b
Parent:
0:38ceb79fef03 
2019-03-13

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kevman 0:38ceb79fef03 1 /* mbed Microcontroller Library
kevman 0:38ceb79fef03 2 * Copyright (c) 2015 ARM Limited
kevman 0:38ceb79fef03 3 *
kevman 0:38ceb79fef03 4 * Licensed under the Apache License, Version 2.0 (the "License");
kevman 0:38ceb79fef03 5 * you may not use this file except in compliance with the License.
kevman 0:38ceb79fef03 6 * You may obtain a copy of the License at
kevman 0:38ceb79fef03 7 *
kevman 0:38ceb79fef03 8 * http://www.apache.org/licenses/LICENSE-2.0
kevman 0:38ceb79fef03 9 *
kevman 0:38ceb79fef03 10 * Unless required by applicable law or agreed to in writing, software
kevman 0:38ceb79fef03 11 * distributed under the License is distributed on an "AS IS" BASIS,
kevman 0:38ceb79fef03 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
kevman 0:38ceb79fef03 13 * See the License for the specific language governing permissions and
kevman 0:38ceb79fef03 14 * limitations under the License.
kevman 0:38ceb79fef03 15 */
kevman 0:38ceb79fef03 16 #include <stdio.h>
kevman 0:38ceb79fef03 17 #include <stddef.h>
kevman 0:38ceb79fef03 18 #include "hal/ticker_api.h"
kevman 0:38ceb79fef03 19 #include "platform/mbed_critical.h"
kevman 0:38ceb79fef03 20 #include "platform/mbed_assert.h"
kevman 0:38ceb79fef03 21
kevman 0:38ceb79fef03 22 static void schedule_interrupt(const ticker_data_t *const ticker);
kevman 0:38ceb79fef03 23 static void update_present_time(const ticker_data_t *const ticker);
kevman 0:38ceb79fef03 24
kevman 0:38ceb79fef03 25 /*
kevman 0:38ceb79fef03 26 * Initialize a ticker instance.
kevman 0:38ceb79fef03 27 */
kevman 0:38ceb79fef03 28 static void initialize(const ticker_data_t *ticker)
kevman 0:38ceb79fef03 29 {
kevman 0:38ceb79fef03 30 // return if the queue has already been initialized, in that case the
kevman 0:38ceb79fef03 31 // interface used by the queue is already initialized.
kevman 0:38ceb79fef03 32 if (ticker->queue->initialized) {
kevman 0:38ceb79fef03 33 return;
kevman 0:38ceb79fef03 34 }
kevman 0:38ceb79fef03 35 if (ticker->queue->suspended) {
kevman 0:38ceb79fef03 36 return;
kevman 0:38ceb79fef03 37 }
kevman 0:38ceb79fef03 38
kevman 0:38ceb79fef03 39 ticker->interface->init();
kevman 0:38ceb79fef03 40
kevman 0:38ceb79fef03 41 const ticker_info_t *info = ticker->interface->get_info();
kevman 0:38ceb79fef03 42 uint32_t frequency = info->frequency;
kevman 0:38ceb79fef03 43 if (info->frequency == 0) {
kevman 0:38ceb79fef03 44 MBED_ASSERT(0);
kevman 0:38ceb79fef03 45 frequency = 1000000;
kevman 0:38ceb79fef03 46 }
kevman 0:38ceb79fef03 47
kevman 0:38ceb79fef03 48 uint8_t frequency_shifts = 0;
kevman 0:38ceb79fef03 49 for (uint8_t i = 31; i > 0; --i) {
kevman 0:38ceb79fef03 50 if ((1U << i) == frequency) {
kevman 0:38ceb79fef03 51 frequency_shifts = i;
kevman 0:38ceb79fef03 52 break;
kevman 0:38ceb79fef03 53 }
kevman 0:38ceb79fef03 54 }
kevman 0:38ceb79fef03 55
kevman 0:38ceb79fef03 56 uint32_t bits = info->bits;
kevman 0:38ceb79fef03 57 if ((info->bits > 32) || (info->bits < 4)) {
kevman 0:38ceb79fef03 58 MBED_ASSERT(0);
kevman 0:38ceb79fef03 59 bits = 32;
kevman 0:38ceb79fef03 60 }
kevman 0:38ceb79fef03 61 uint32_t max_delta = 0x7 << (bits - 4); // 7/16th
kevman 0:38ceb79fef03 62 uint64_t max_delta_us =
kevman 0:38ceb79fef03 63 ((uint64_t)max_delta * 1000000 + frequency - 1) / frequency;
kevman 0:38ceb79fef03 64
kevman 0:38ceb79fef03 65 ticker->queue->event_handler = NULL;
kevman 0:38ceb79fef03 66 ticker->queue->head = NULL;
kevman 0:38ceb79fef03 67 ticker->queue->tick_last_read = ticker->interface->read();
kevman 0:38ceb79fef03 68 ticker->queue->tick_remainder = 0;
kevman 0:38ceb79fef03 69 ticker->queue->frequency = frequency;
kevman 0:38ceb79fef03 70 ticker->queue->frequency_shifts = frequency_shifts;
kevman 0:38ceb79fef03 71 ticker->queue->bitmask = ((uint64_t)1 << bits) - 1;
kevman 0:38ceb79fef03 72 ticker->queue->max_delta = max_delta;
kevman 0:38ceb79fef03 73 ticker->queue->max_delta_us = max_delta_us;
kevman 0:38ceb79fef03 74 ticker->queue->present_time = 0;
kevman 0:38ceb79fef03 75 ticker->queue->dispatching = false;
kevman 0:38ceb79fef03 76 ticker->queue->suspended = false;
kevman 0:38ceb79fef03 77 ticker->queue->initialized = true;
kevman 0:38ceb79fef03 78
kevman 0:38ceb79fef03 79 update_present_time(ticker);
kevman 0:38ceb79fef03 80 schedule_interrupt(ticker);
kevman 0:38ceb79fef03 81 }
kevman 0:38ceb79fef03 82
kevman 0:38ceb79fef03 83 /**
kevman 0:38ceb79fef03 84 * Set the event handler function of a ticker instance.
kevman 0:38ceb79fef03 85 */
kevman 0:38ceb79fef03 86 static void set_handler(const ticker_data_t *const ticker, ticker_event_handler handler)
kevman 0:38ceb79fef03 87 {
kevman 0:38ceb79fef03 88 ticker->queue->event_handler = handler;
kevman 0:38ceb79fef03 89 }
kevman 0:38ceb79fef03 90
kevman 0:38ceb79fef03 91 /*
kevman 0:38ceb79fef03 92 * Convert a 32 bit timestamp into a 64 bit timestamp.
kevman 0:38ceb79fef03 93 *
kevman 0:38ceb79fef03 94 * A 64 bit timestamp is used as the point of time of reference while the
kevman 0:38ceb79fef03 95 * timestamp to convert is relative to this point of time.
kevman 0:38ceb79fef03 96 *
kevman 0:38ceb79fef03 97 * The lower 32 bits of the timestamp returned will be equal to the timestamp to
kevman 0:38ceb79fef03 98 * convert.
kevman 0:38ceb79fef03 99 *
kevman 0:38ceb79fef03 100 * If the timestamp to convert is less than the lower 32 bits of the time
kevman 0:38ceb79fef03 101 * reference then the timestamp to convert is seen as an overflowed value and
kevman 0:38ceb79fef03 102 * the upper 32 bit of the timestamp returned will be equal to the upper 32 bit
kevman 0:38ceb79fef03 103 * of the reference point + 1.
kevman 0:38ceb79fef03 104 * Otherwise, the upper 32 bit returned will be equal to the upper 32 bit of the
kevman 0:38ceb79fef03 105 * reference point.
kevman 0:38ceb79fef03 106 *
kevman 0:38ceb79fef03 107 * @param ref: The 64 bit timestamp of reference.
kevman 0:38ceb79fef03 108 * @param timestamp: The timestamp to convert.
kevman 0:38ceb79fef03 109 */
kevman 0:38ceb79fef03 110 static us_timestamp_t convert_timestamp(us_timestamp_t ref, timestamp_t timestamp)
kevman 0:38ceb79fef03 111 {
kevman 0:38ceb79fef03 112 bool overflow = timestamp < ((timestamp_t) ref) ? true : false;
kevman 0:38ceb79fef03 113
kevman 0:38ceb79fef03 114 us_timestamp_t result = (ref & ~((us_timestamp_t)UINT32_MAX)) | timestamp;
kevman 0:38ceb79fef03 115 if (overflow) {
kevman 0:38ceb79fef03 116 result += (1ULL << 32);
kevman 0:38ceb79fef03 117 }
kevman 0:38ceb79fef03 118
kevman 0:38ceb79fef03 119 return result;
kevman 0:38ceb79fef03 120 }
kevman 0:38ceb79fef03 121
kevman 0:38ceb79fef03 122 /**
kevman 0:38ceb79fef03 123 * Update the present timestamp value of a ticker.
kevman 0:38ceb79fef03 124 */
kevman 0:38ceb79fef03 125 static void update_present_time(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 126 {
kevman 0:38ceb79fef03 127 ticker_event_queue_t *queue = ticker->queue;
kevman 0:38ceb79fef03 128 if (queue->suspended) {
kevman 0:38ceb79fef03 129 return;
kevman 0:38ceb79fef03 130 }
kevman 0:38ceb79fef03 131 uint32_t ticker_time = ticker->interface->read();
kevman 0:38ceb79fef03 132 if (ticker_time == ticker->queue->tick_last_read) {
kevman 0:38ceb79fef03 133 // No work to do
kevman 0:38ceb79fef03 134 return;
kevman 0:38ceb79fef03 135 }
kevman 0:38ceb79fef03 136
kevman 0:38ceb79fef03 137 uint64_t elapsed_ticks = (ticker_time - queue->tick_last_read) & queue->bitmask;
kevman 0:38ceb79fef03 138 queue->tick_last_read = ticker_time;
kevman 0:38ceb79fef03 139
kevman 0:38ceb79fef03 140 uint64_t elapsed_us;
kevman 0:38ceb79fef03 141 if (1000000 == queue->frequency) {
kevman 0:38ceb79fef03 142 // Optimized for 1MHz
kevman 0:38ceb79fef03 143
kevman 0:38ceb79fef03 144 elapsed_us = elapsed_ticks;
kevman 0:38ceb79fef03 145 } else if (0 != queue->frequency_shifts) {
kevman 0:38ceb79fef03 146 // Optimized for frequencies divisible by 2
kevman 0:38ceb79fef03 147 uint64_t us_x_ticks = elapsed_ticks * 1000000;
kevman 0:38ceb79fef03 148 elapsed_us = us_x_ticks >> queue->frequency_shifts;
kevman 0:38ceb79fef03 149
kevman 0:38ceb79fef03 150 // Update remainder
kevman 0:38ceb79fef03 151 queue->tick_remainder += us_x_ticks - (elapsed_us << queue->frequency_shifts);
kevman 0:38ceb79fef03 152 if (queue->tick_remainder >= queue->frequency) {
kevman 0:38ceb79fef03 153 elapsed_us += 1;
kevman 0:38ceb79fef03 154 queue->tick_remainder -= queue->frequency;
kevman 0:38ceb79fef03 155 }
kevman 0:38ceb79fef03 156 } else {
kevman 0:38ceb79fef03 157 // General case
kevman 0:38ceb79fef03 158
kevman 0:38ceb79fef03 159 uint64_t us_x_ticks = elapsed_ticks * 1000000;
kevman 0:38ceb79fef03 160 elapsed_us = us_x_ticks / queue->frequency;
kevman 0:38ceb79fef03 161
kevman 0:38ceb79fef03 162 // Update remainder
kevman 0:38ceb79fef03 163 queue->tick_remainder += us_x_ticks - elapsed_us * queue->frequency;
kevman 0:38ceb79fef03 164 if (queue->tick_remainder >= queue->frequency) {
kevman 0:38ceb79fef03 165 elapsed_us += 1;
kevman 0:38ceb79fef03 166 queue->tick_remainder -= queue->frequency;
kevman 0:38ceb79fef03 167 }
kevman 0:38ceb79fef03 168 }
kevman 0:38ceb79fef03 169
kevman 0:38ceb79fef03 170 // Update current time
kevman 0:38ceb79fef03 171 queue->present_time += elapsed_us;
kevman 0:38ceb79fef03 172 }
kevman 0:38ceb79fef03 173
kevman 0:38ceb79fef03 174 /**
kevman 0:38ceb79fef03 175 * Given the absolute timestamp compute the hal tick timestamp rounded up.
kevman 0:38ceb79fef03 176 */
kevman 0:38ceb79fef03 177 static timestamp_t compute_tick_round_up(const ticker_data_t *const ticker, us_timestamp_t timestamp)
kevman 0:38ceb79fef03 178 {
kevman 0:38ceb79fef03 179 ticker_event_queue_t *queue = ticker->queue;
kevman 0:38ceb79fef03 180 us_timestamp_t delta_us = timestamp - queue->present_time;
kevman 0:38ceb79fef03 181
kevman 0:38ceb79fef03 182 timestamp_t delta = ticker->queue->max_delta;
kevman 0:38ceb79fef03 183 if (delta_us <= ticker->queue->max_delta_us) {
kevman 0:38ceb79fef03 184 // Checking max_delta_us ensures the operation will not overflow
kevman 0:38ceb79fef03 185
kevman 0:38ceb79fef03 186 if (1000000 == queue->frequency) {
kevman 0:38ceb79fef03 187 // Optimized for 1MHz
kevman 0:38ceb79fef03 188
kevman 0:38ceb79fef03 189 delta = delta_us;
kevman 0:38ceb79fef03 190 if (delta > ticker->queue->max_delta) {
kevman 0:38ceb79fef03 191 delta = ticker->queue->max_delta;
kevman 0:38ceb79fef03 192 }
kevman 0:38ceb79fef03 193 } else if (0 != queue->frequency_shifts) {
kevman 0:38ceb79fef03 194 // Optimized frequencies divisible by 2
kevman 0:38ceb79fef03 195
kevman 0:38ceb79fef03 196 delta = ((delta_us << ticker->queue->frequency_shifts) + 1000000 - 1) / 1000000;
kevman 0:38ceb79fef03 197 if (delta > ticker->queue->max_delta) {
kevman 0:38ceb79fef03 198 delta = ticker->queue->max_delta;
kevman 0:38ceb79fef03 199 }
kevman 0:38ceb79fef03 200 } else {
kevman 0:38ceb79fef03 201 // General case
kevman 0:38ceb79fef03 202
kevman 0:38ceb79fef03 203 delta = (delta_us * queue->frequency + 1000000 - 1) / 1000000;
kevman 0:38ceb79fef03 204 if (delta > ticker->queue->max_delta) {
kevman 0:38ceb79fef03 205 delta = ticker->queue->max_delta;
kevman 0:38ceb79fef03 206 }
kevman 0:38ceb79fef03 207 }
kevman 0:38ceb79fef03 208 }
kevman 0:38ceb79fef03 209 return (queue->tick_last_read + delta) & queue->bitmask;
kevman 0:38ceb79fef03 210 }
kevman 0:38ceb79fef03 211
kevman 0:38ceb79fef03 212 /**
kevman 0:38ceb79fef03 213 * Return 1 if the tick has incremented to or past match_tick, otherwise 0.
kevman 0:38ceb79fef03 214 */
kevman 0:38ceb79fef03 215 int _ticker_match_interval_passed(timestamp_t prev_tick, timestamp_t cur_tick, timestamp_t match_tick)
kevman 0:38ceb79fef03 216 {
kevman 0:38ceb79fef03 217 if (match_tick > prev_tick) {
kevman 0:38ceb79fef03 218 return (cur_tick >= match_tick) || (cur_tick < prev_tick);
kevman 0:38ceb79fef03 219 } else {
kevman 0:38ceb79fef03 220 return (cur_tick < prev_tick) && (cur_tick >= match_tick);
kevman 0:38ceb79fef03 221 }
kevman 0:38ceb79fef03 222 }
kevman 0:38ceb79fef03 223
kevman 0:38ceb79fef03 224 /**
kevman 0:38ceb79fef03 225 * Compute the time when the interrupt has to be triggered and schedule it.
kevman 0:38ceb79fef03 226 *
kevman 0:38ceb79fef03 227 * If there is no event in the queue or the next event to execute is in more
kevman 0:38ceb79fef03 228 * than ticker.queue.max_delta ticks from now then the ticker irq will be
kevman 0:38ceb79fef03 229 * scheduled in ticker.queue.max_delta ticks. Otherwise the irq will be
kevman 0:38ceb79fef03 230 * scheduled to happen when the running counter reach the timestamp of the
kevman 0:38ceb79fef03 231 * first event in the queue.
kevman 0:38ceb79fef03 232 *
kevman 0:38ceb79fef03 233 * @note If there is no event in the queue then the interrupt is scheduled to
kevman 0:38ceb79fef03 234 * in ticker.queue.max_delta. This is necessary to keep track
kevman 0:38ceb79fef03 235 * of the timer overflow.
kevman 0:38ceb79fef03 236 */
kevman 0:38ceb79fef03 237 static void schedule_interrupt(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 238 {
kevman 0:38ceb79fef03 239 ticker_event_queue_t *queue = ticker->queue;
kevman 0:38ceb79fef03 240 if (queue->suspended || ticker->queue->dispatching) {
kevman 0:38ceb79fef03 241 // Don't schedule the next interrupt until dispatching is
kevman 0:38ceb79fef03 242 // finished. This prevents repeated calls to interface->set_interrupt
kevman 0:38ceb79fef03 243 return;
kevman 0:38ceb79fef03 244 }
kevman 0:38ceb79fef03 245
kevman 0:38ceb79fef03 246 update_present_time(ticker);
kevman 0:38ceb79fef03 247
kevman 0:38ceb79fef03 248 if (ticker->queue->head) {
kevman 0:38ceb79fef03 249 us_timestamp_t present = ticker->queue->present_time;
kevman 0:38ceb79fef03 250 us_timestamp_t match_time = ticker->queue->head->timestamp;
kevman 0:38ceb79fef03 251
kevman 0:38ceb79fef03 252 // if the event at the head of the queue is in the past then schedule
kevman 0:38ceb79fef03 253 // it immediately.
kevman 0:38ceb79fef03 254 if (match_time <= present) {
kevman 0:38ceb79fef03 255 ticker->interface->fire_interrupt();
kevman 0:38ceb79fef03 256 return;
kevman 0:38ceb79fef03 257 }
kevman 0:38ceb79fef03 258
kevman 0:38ceb79fef03 259 timestamp_t match_tick = compute_tick_round_up(ticker, match_time);
kevman 0:38ceb79fef03 260
kevman 0:38ceb79fef03 261 // The same tick should never occur since match_tick is rounded up.
kevman 0:38ceb79fef03 262 // If the same tick is returned scheduling will not work correctly.
kevman 0:38ceb79fef03 263 MBED_ASSERT(match_tick != queue->tick_last_read);
kevman 0:38ceb79fef03 264
kevman 0:38ceb79fef03 265 ticker->interface->set_interrupt(match_tick);
kevman 0:38ceb79fef03 266 timestamp_t cur_tick = ticker->interface->read();
kevman 0:38ceb79fef03 267
kevman 0:38ceb79fef03 268 if (_ticker_match_interval_passed(queue->tick_last_read, cur_tick, match_tick)) {
kevman 0:38ceb79fef03 269 ticker->interface->fire_interrupt();
kevman 0:38ceb79fef03 270 }
kevman 0:38ceb79fef03 271 } else {
kevman 0:38ceb79fef03 272 uint32_t match_tick =
kevman 0:38ceb79fef03 273 (queue->tick_last_read + queue->max_delta) & queue->bitmask;
kevman 0:38ceb79fef03 274 ticker->interface->set_interrupt(match_tick);
kevman 0:38ceb79fef03 275 }
kevman 0:38ceb79fef03 276 }
kevman 0:38ceb79fef03 277
kevman 0:38ceb79fef03 278 void ticker_set_handler(const ticker_data_t *const ticker, ticker_event_handler handler)
kevman 0:38ceb79fef03 279 {
kevman 0:38ceb79fef03 280 initialize(ticker);
kevman 0:38ceb79fef03 281
kevman 0:38ceb79fef03 282 core_util_critical_section_enter();
kevman 0:38ceb79fef03 283 set_handler(ticker, handler);
kevman 0:38ceb79fef03 284 core_util_critical_section_exit();
kevman 0:38ceb79fef03 285 }
kevman 0:38ceb79fef03 286
kevman 0:38ceb79fef03 287 void ticker_irq_handler(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 288 {
kevman 0:38ceb79fef03 289 core_util_critical_section_enter();
kevman 0:38ceb79fef03 290
kevman 0:38ceb79fef03 291 ticker->interface->clear_interrupt();
kevman 0:38ceb79fef03 292 if (ticker->queue->suspended) {
kevman 0:38ceb79fef03 293 core_util_critical_section_exit();
kevman 0:38ceb79fef03 294 return;
kevman 0:38ceb79fef03 295 }
kevman 0:38ceb79fef03 296
kevman 0:38ceb79fef03 297 /* Go through all the pending TimerEvents */
kevman 0:38ceb79fef03 298 ticker->queue->dispatching = true;
kevman 0:38ceb79fef03 299 while (1) {
kevman 0:38ceb79fef03 300 if (ticker->queue->head == NULL) {
kevman 0:38ceb79fef03 301 break;
kevman 0:38ceb79fef03 302 }
kevman 0:38ceb79fef03 303
kevman 0:38ceb79fef03 304 // update the current timestamp used by the queue
kevman 0:38ceb79fef03 305 update_present_time(ticker);
kevman 0:38ceb79fef03 306
kevman 0:38ceb79fef03 307 if (ticker->queue->head->timestamp <= ticker->queue->present_time) {
kevman 0:38ceb79fef03 308 // This event was in the past:
kevman 0:38ceb79fef03 309 // point to the following one and execute its handler
kevman 0:38ceb79fef03 310 ticker_event_t *p = ticker->queue->head;
kevman 0:38ceb79fef03 311 ticker->queue->head = ticker->queue->head->next;
kevman 0:38ceb79fef03 312 if (ticker->queue->event_handler != NULL) {
kevman 0:38ceb79fef03 313 (*ticker->queue->event_handler)(p->id); // NOTE: the handler can set new events
kevman 0:38ceb79fef03 314 }
kevman 0:38ceb79fef03 315 /* Note: We continue back to examining the head because calling the
kevman 0:38ceb79fef03 316 * event handler may have altered the chain of pending events. */
kevman 0:38ceb79fef03 317 } else {
kevman 0:38ceb79fef03 318 break;
kevman 0:38ceb79fef03 319 }
kevman 0:38ceb79fef03 320 }
kevman 0:38ceb79fef03 321 ticker->queue->dispatching = false;
kevman 0:38ceb79fef03 322
kevman 0:38ceb79fef03 323 schedule_interrupt(ticker);
kevman 0:38ceb79fef03 324
kevman 0:38ceb79fef03 325 core_util_critical_section_exit();
kevman 0:38ceb79fef03 326 }
kevman 0:38ceb79fef03 327
kevman 0:38ceb79fef03 328 void ticker_insert_event(const ticker_data_t *const ticker, ticker_event_t *obj, timestamp_t timestamp, uint32_t id)
kevman 0:38ceb79fef03 329 {
kevman 0:38ceb79fef03 330 core_util_critical_section_enter();
kevman 0:38ceb79fef03 331
kevman 0:38ceb79fef03 332 // update the current timestamp
kevman 0:38ceb79fef03 333 update_present_time(ticker);
kevman 0:38ceb79fef03 334 us_timestamp_t absolute_timestamp = convert_timestamp(
kevman 0:38ceb79fef03 335 ticker->queue->present_time,
kevman 0:38ceb79fef03 336 timestamp
kevman 0:38ceb79fef03 337 );
kevman 0:38ceb79fef03 338
kevman 0:38ceb79fef03 339 // defer to ticker_insert_event_us
kevman 0:38ceb79fef03 340 ticker_insert_event_us(
kevman 0:38ceb79fef03 341 ticker,
kevman 0:38ceb79fef03 342 obj, absolute_timestamp, id
kevman 0:38ceb79fef03 343 );
kevman 0:38ceb79fef03 344
kevman 0:38ceb79fef03 345 core_util_critical_section_exit();
kevman 0:38ceb79fef03 346 }
kevman 0:38ceb79fef03 347
kevman 0:38ceb79fef03 348 void ticker_insert_event_us(const ticker_data_t *const ticker, ticker_event_t *obj, us_timestamp_t timestamp, uint32_t id)
kevman 0:38ceb79fef03 349 {
kevman 0:38ceb79fef03 350 core_util_critical_section_enter();
kevman 0:38ceb79fef03 351
kevman 0:38ceb79fef03 352 // update the current timestamp
kevman 0:38ceb79fef03 353 update_present_time(ticker);
kevman 0:38ceb79fef03 354
kevman 0:38ceb79fef03 355 // initialise our data
kevman 0:38ceb79fef03 356 obj->timestamp = timestamp;
kevman 0:38ceb79fef03 357 obj->id = id;
kevman 0:38ceb79fef03 358
kevman 0:38ceb79fef03 359 /* Go through the list until we either reach the end, or find
kevman 0:38ceb79fef03 360 an element this should come before (which is possibly the
kevman 0:38ceb79fef03 361 head). */
kevman 0:38ceb79fef03 362 ticker_event_t *prev = NULL, *p = ticker->queue->head;
kevman 0:38ceb79fef03 363 while (p != NULL) {
kevman 0:38ceb79fef03 364 /* check if we come before p */
kevman 0:38ceb79fef03 365 if (timestamp < p->timestamp) {
kevman 0:38ceb79fef03 366 break;
kevman 0:38ceb79fef03 367 }
kevman 0:38ceb79fef03 368 /* go to the next element */
kevman 0:38ceb79fef03 369 prev = p;
kevman 0:38ceb79fef03 370 p = p->next;
kevman 0:38ceb79fef03 371 }
kevman 0:38ceb79fef03 372
kevman 0:38ceb79fef03 373 /* if we're at the end p will be NULL, which is correct */
kevman 0:38ceb79fef03 374 obj->next = p;
kevman 0:38ceb79fef03 375
kevman 0:38ceb79fef03 376 /* if prev is NULL we're at the head */
kevman 0:38ceb79fef03 377 if (prev == NULL) {
kevman 0:38ceb79fef03 378 ticker->queue->head = obj;
kevman 0:38ceb79fef03 379 schedule_interrupt(ticker);
kevman 0:38ceb79fef03 380 } else {
kevman 0:38ceb79fef03 381 prev->next = obj;
kevman 0:38ceb79fef03 382 }
kevman 0:38ceb79fef03 383
kevman 0:38ceb79fef03 384 core_util_critical_section_exit();
kevman 0:38ceb79fef03 385 }
kevman 0:38ceb79fef03 386
kevman 0:38ceb79fef03 387 void ticker_remove_event(const ticker_data_t *const ticker, ticker_event_t *obj)
kevman 0:38ceb79fef03 388 {
kevman 0:38ceb79fef03 389 core_util_critical_section_enter();
kevman 0:38ceb79fef03 390
kevman 0:38ceb79fef03 391 // remove this object from the list
kevman 0:38ceb79fef03 392 if (ticker->queue->head == obj) {
kevman 0:38ceb79fef03 393 // first in the list, so just drop me
kevman 0:38ceb79fef03 394 ticker->queue->head = obj->next;
kevman 0:38ceb79fef03 395 schedule_interrupt(ticker);
kevman 0:38ceb79fef03 396 } else {
kevman 0:38ceb79fef03 397 // find the object before me, then drop me
kevman 0:38ceb79fef03 398 ticker_event_t *p = ticker->queue->head;
kevman 0:38ceb79fef03 399 while (p != NULL) {
kevman 0:38ceb79fef03 400 if (p->next == obj) {
kevman 0:38ceb79fef03 401 p->next = obj->next;
kevman 0:38ceb79fef03 402 break;
kevman 0:38ceb79fef03 403 }
kevman 0:38ceb79fef03 404 p = p->next;
kevman 0:38ceb79fef03 405 }
kevman 0:38ceb79fef03 406 }
kevman 0:38ceb79fef03 407
kevman 0:38ceb79fef03 408 core_util_critical_section_exit();
kevman 0:38ceb79fef03 409 }
kevman 0:38ceb79fef03 410
kevman 0:38ceb79fef03 411 timestamp_t ticker_read(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 412 {
kevman 0:38ceb79fef03 413 return ticker_read_us(ticker);
kevman 0:38ceb79fef03 414 }
kevman 0:38ceb79fef03 415
kevman 0:38ceb79fef03 416 us_timestamp_t ticker_read_us(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 417 {
kevman 0:38ceb79fef03 418 initialize(ticker);
kevman 0:38ceb79fef03 419
kevman 0:38ceb79fef03 420 core_util_critical_section_enter();
kevman 0:38ceb79fef03 421 update_present_time(ticker);
kevman 0:38ceb79fef03 422 core_util_critical_section_exit();
kevman 0:38ceb79fef03 423
kevman 0:38ceb79fef03 424 return ticker->queue->present_time;
kevman 0:38ceb79fef03 425 }
kevman 0:38ceb79fef03 426
kevman 0:38ceb79fef03 427 int ticker_get_next_timestamp(const ticker_data_t *const data, timestamp_t *timestamp)
kevman 0:38ceb79fef03 428 {
kevman 0:38ceb79fef03 429 int ret = 0;
kevman 0:38ceb79fef03 430
kevman 0:38ceb79fef03 431 /* if head is NULL, there are no pending events */
kevman 0:38ceb79fef03 432 core_util_critical_section_enter();
kevman 0:38ceb79fef03 433 if (data->queue->head != NULL) {
kevman 0:38ceb79fef03 434 *timestamp = data->queue->head->timestamp;
kevman 0:38ceb79fef03 435 ret = 1;
kevman 0:38ceb79fef03 436 }
kevman 0:38ceb79fef03 437 core_util_critical_section_exit();
kevman 0:38ceb79fef03 438
kevman 0:38ceb79fef03 439 return ret;
kevman 0:38ceb79fef03 440 }
kevman 0:38ceb79fef03 441
kevman 0:38ceb79fef03 442 void ticker_suspend(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 443 {
kevman 0:38ceb79fef03 444 core_util_critical_section_enter();
kevman 0:38ceb79fef03 445
kevman 0:38ceb79fef03 446 ticker->queue->suspended = true;
kevman 0:38ceb79fef03 447
kevman 0:38ceb79fef03 448 core_util_critical_section_exit();
kevman 0:38ceb79fef03 449 }
kevman 0:38ceb79fef03 450
kevman 0:38ceb79fef03 451 void ticker_resume(const ticker_data_t *const ticker)
kevman 0:38ceb79fef03 452 {
kevman 0:38ceb79fef03 453 core_util_critical_section_enter();
kevman 0:38ceb79fef03 454
kevman 0:38ceb79fef03 455 ticker->queue->suspended = false;
kevman 0:38ceb79fef03 456 if (ticker->queue->initialized) {
kevman 0:38ceb79fef03 457 ticker->queue->tick_last_read = ticker->interface->read();
kevman 0:38ceb79fef03 458
kevman 0:38ceb79fef03 459 update_present_time(ticker);
kevman 0:38ceb79fef03 460 schedule_interrupt(ticker);
kevman 0:38ceb79fef03 461 } else {
kevman 0:38ceb79fef03 462 initialize(ticker);
kevman 0:38ceb79fef03 463 }
kevman 0:38ceb79fef03 464
kevman 0:38ceb79fef03 465 core_util_critical_section_exit();
kevman 0:38ceb79fef03 466 }