1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "timer_core.h"
10 #include "hdf_device_object.h"
11 #include "hdf_log.h"
12 #include "osal_mem.h"
13 #include "osal_time.h"
14 #include "platform_listener_common.h"
15 #include "platform_trace.h"
16 #include "securec.h"
17
18 #define HDF_LOG_TAG timer_core
19
20 struct TimerManager {
21 struct IDeviceIoService service;
22 struct HdfDeviceObject *device;
23 struct DListHead timerListHead;
24 struct OsalMutex lock;
25 };
26
27 static struct TimerManager *g_timerManager = NULL;
28 #define TIMER_HANDLE_SHIFT ((uintptr_t)(-1) << 16)
29 #define TIMER_TRACE_PARAM_NUM 5
30 #define TIMER_TRACE_BASIC_PARAM_NUM 3
31 #define TIMER_TRACE_PARAM_STOP_NUM 3
32
TimerCntrlOpen(const uint32_t number)33 struct TimerCntrl *TimerCntrlOpen(const uint32_t number)
34 {
35 struct TimerCntrl *pos = NULL;
36 struct TimerManager *manager = g_timerManager;
37 CHECK_NULL_PTR_RETURN_VALUE(manager, NULL);
38
39 if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) {
40 HDF_LOGE("%s: OsalMutexLock failed", __func__);
41 return NULL;
42 }
43
44 DLIST_FOR_EACH_ENTRY(pos, &manager->timerListHead, struct TimerCntrl, node) {
45 if (number == pos->info.number) {
46 (void)OsalMutexUnlock(&manager->lock);
47 return pos;
48 }
49 }
50
51 (void)OsalMutexUnlock(&manager->lock);
52 HDF_LOGE("%s: open %u failed", __func__, number);
53 return NULL;
54 }
55
TimerCntrlClose(struct TimerCntrl * cntrl)56 int32_t TimerCntrlClose(struct TimerCntrl *cntrl)
57 {
58 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
59 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
60 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
61 return HDF_ERR_DEVICE_BUSY;
62 }
63 if ((cntrl->ops->Close != NULL) && (cntrl->ops->Close(cntrl) != HDF_SUCCESS)) {
64 HDF_LOGE("%s: close %u failed", __func__, cntrl->info.number);
65 (void)OsalMutexUnlock(&cntrl->lock);
66 return HDF_FAILURE;
67 }
68 (void)OsalMutexUnlock(&cntrl->lock);
69 return HDF_SUCCESS;
70 }
71
TimerCntrlSet(struct TimerCntrl * cntrl,uint32_t useconds,TimerHandleCb cb)72 int32_t TimerCntrlSet(struct TimerCntrl *cntrl, uint32_t useconds, TimerHandleCb cb)
73 {
74 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
75 CHECK_NULL_PTR_RETURN_VALUE(cb, HDF_ERR_INVALID_OBJECT);
76 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
77 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
78 return HDF_ERR_DEVICE_BUSY;
79 }
80 if ((cntrl->ops->Set != NULL) && (cntrl->ops->Set(cntrl, useconds, cb) != HDF_SUCCESS)) {
81 HDF_LOGE("%s: set %u failed", __func__, cntrl->info.number);
82 (void)OsalMutexUnlock(&cntrl->lock);
83 return HDF_FAILURE;
84 }
85
86 (void)OsalMutexUnlock(&cntrl->lock);
87 return HDF_SUCCESS;
88 }
89
TimerCntrlSetOnce(struct TimerCntrl * cntrl,uint32_t useconds,TimerHandleCb cb)90 int32_t TimerCntrlSetOnce(struct TimerCntrl *cntrl, uint32_t useconds, TimerHandleCb cb)
91 {
92 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
93 CHECK_NULL_PTR_RETURN_VALUE(cb, HDF_ERR_INVALID_OBJECT);
94
95 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
96 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
97 return HDF_ERR_DEVICE_BUSY;
98 }
99 if ((cntrl->ops->SetOnce != NULL) && (cntrl->ops->SetOnce(cntrl, useconds, cb) != HDF_SUCCESS)) {
100 HDF_LOGE("%s: setOnce %u failed", __func__, cntrl->info.number);
101 (void)OsalMutexUnlock(&cntrl->lock);
102 return HDF_FAILURE;
103 }
104
105 (void)OsalMutexUnlock(&cntrl->lock);
106 return HDF_SUCCESS;
107 }
108
TimerCntrlGet(struct TimerCntrl * cntrl,uint32_t * useconds,bool * isPeriod)109 int32_t TimerCntrlGet(struct TimerCntrl *cntrl, uint32_t *useconds, bool *isPeriod)
110 {
111 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
112 CHECK_NULL_PTR_RETURN_VALUE(useconds, HDF_ERR_INVALID_OBJECT);
113 CHECK_NULL_PTR_RETURN_VALUE(isPeriod, HDF_ERR_INVALID_OBJECT);
114
115 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
116 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
117 return HDF_ERR_DEVICE_BUSY;
118 }
119 *useconds = cntrl->info.useconds;
120 *isPeriod = cntrl->info.isPeriod;
121 (void)OsalMutexUnlock(&cntrl->lock);
122 return HDF_SUCCESS;
123 }
124
TimerCntrlStart(struct TimerCntrl * cntrl)125 int32_t TimerCntrlStart(struct TimerCntrl *cntrl)
126 {
127 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
128
129 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
130 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
131 return HDF_ERR_DEVICE_BUSY;
132 }
133 if ((cntrl->ops->Start != NULL) && (cntrl->ops->Start(cntrl) != HDF_SUCCESS)) {
134 HDF_LOGE("%s: start %u failed", __func__, cntrl->info.number);
135 (void)OsalMutexUnlock(&cntrl->lock);
136 return HDF_FAILURE;
137 }
138
139 int32_t ret = PlatformTraceStart();
140 if (ret == HDF_SUCCESS) {
141 uint infos[TIMER_TRACE_BASIC_PARAM_NUM];
142 infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntrl->info.number;
143 infos[PLATFORM_TRACE_UINT_PARAM_SIZE_2 - 1] = cntrl->info.useconds;
144 infos[PLATFORM_TRACE_UINT_PARAM_SIZE_3 - 1] = cntrl->info.isPeriod;
145 PlatformTraceAddUintMsg(
146 PLATFORM_TRACE_MODULE_TIMER, PLATFORM_TRACE_MODULE_TIMER_FUN_START, infos, TIMER_TRACE_BASIC_PARAM_NUM);
147 PlatformTraceStop();
148 PlatformTraceInfoDump();
149 }
150
151 (void)OsalMutexUnlock(&cntrl->lock);
152 return HDF_SUCCESS;
153 }
154
TimerCntrlStop(struct TimerCntrl * cntrl)155 int32_t TimerCntrlStop(struct TimerCntrl *cntrl)
156 {
157 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_OBJECT);
158
159 if (OsalMutexLock(&cntrl->lock) != HDF_SUCCESS) {
160 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
161 return HDF_ERR_DEVICE_BUSY;
162 }
163 if ((cntrl->ops->Stop != NULL) && (cntrl->ops->Stop(cntrl) != HDF_SUCCESS)) {
164 HDF_LOGE("%s: stop %u failed", __func__, cntrl->info.number);
165 (void)OsalMutexUnlock(&cntrl->lock);
166 return HDF_FAILURE;
167 }
168
169 int32_t ret = PlatformTraceStart();
170 if (ret == HDF_SUCCESS) {
171 uint infos[TIMER_TRACE_PARAM_STOP_NUM];
172 infos[0] = cntrl->info.number;
173 PlatformTraceAddUintMsg(
174 PLATFORM_TRACE_MODULE_TIMER, PLATFORM_TRACE_MODULE_TIMER_FUN_STOP, infos, TIMER_TRACE_PARAM_STOP_NUM);
175 PlatformTraceStop();
176 PlatformTraceInfoDump();
177 }
178 (void)OsalMutexUnlock(&cntrl->lock);
179 return HDF_SUCCESS;
180 }
181
TimerIoOpen(struct HdfSBuf * data,struct HdfSBuf * reply)182 static int32_t TimerIoOpen(struct HdfSBuf *data, struct HdfSBuf *reply)
183 {
184 int16_t number;
185 uint32_t handle;
186
187 if ((data == NULL) || (reply == NULL)) {
188 HDF_LOGE("%s: param invalid", __func__);
189 return HDF_ERR_INVALID_PARAM;
190 }
191 if (!HdfSbufReadUint16(data, (uint16_t *)&number)) {
192 HDF_LOGE("%s: HdfSbufReadUint16 failed", __func__);
193 return HDF_ERR_IO;
194 }
195
196 if (number < 0) {
197 HDF_LOGE("%s: info read failed", __func__);
198 return HDF_ERR_INVALID_PARAM;
199 }
200
201 if (TimerCntrlOpen(number) == NULL) {
202 HDF_LOGE("%s: TimerCntrlOpen %d failed", __func__, number);
203 return HDF_FAILURE;
204 }
205
206 handle = (uint32_t)(number + TIMER_HANDLE_SHIFT);
207 if (!HdfSbufWriteUint32(reply, handle)) {
208 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
209 return HDF_ERR_IO;
210 }
211 return HDF_SUCCESS;
212 }
213
TimerIoClose(struct HdfSBuf * data,struct HdfSBuf * reply)214 static int32_t TimerIoClose(struct HdfSBuf *data, struct HdfSBuf *reply)
215 {
216 uint32_t handle;
217 int16_t number;
218
219 (void)reply;
220 if (data == NULL) {
221 HDF_LOGE("%s: param invalid", __func__);
222 return HDF_ERR_INVALID_PARAM;
223 }
224
225 if (!HdfSbufReadUint32(data, &handle)) {
226 HDF_LOGE("%s: HdfSbufReadUint32 failed", __func__);
227 return HDF_ERR_IO;
228 }
229
230 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
231 if (number < 0) {
232 HDF_LOGE("%s: number[%d] invalid", __func__, number);
233 return HDF_ERR_INVALID_PARAM;
234 }
235 return TimerCntrlClose(TimerCntrlOpen(number));
236 }
237
TimerIoStart(struct HdfSBuf * data,struct HdfSBuf * reply)238 static int32_t TimerIoStart(struct HdfSBuf *data, struct HdfSBuf *reply)
239 {
240 uint32_t handle;
241 int16_t number;
242
243 (void)reply;
244 if (data == NULL) {
245 HDF_LOGE("%s: param invalid", __func__);
246 return HDF_ERR_INVALID_PARAM;
247 }
248 if (!HdfSbufReadUint32(data, &handle)) {
249 HDF_LOGE("%s: HdfSbufReadUint32 failed", __func__);
250 return HDF_ERR_IO;
251 }
252
253 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
254 if (number < 0) {
255 HDF_LOGE("%s: number[%d] invalid", __func__, number);
256 return HDF_ERR_INVALID_PARAM;
257 }
258 return TimerCntrlStart(TimerCntrlOpen(number));
259 }
260
TimerIoStop(struct HdfSBuf * data,struct HdfSBuf * reply)261 static int32_t TimerIoStop(struct HdfSBuf *data, struct HdfSBuf *reply)
262 {
263 uint32_t handle;
264 int16_t number;
265
266 (void)reply;
267 if (data == NULL) {
268 HDF_LOGE("%s: param invalid", __func__);
269 return HDF_ERR_INVALID_PARAM;
270 }
271 if (!HdfSbufReadUint32(data, &handle)) {
272 HDF_LOGE("%s: HdfSbufReadUint32 failed", __func__);
273 return HDF_ERR_IO;
274 }
275
276 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
277 if (number < 0) {
278 HDF_LOGE("%s: number[%d] invalid", __func__, number);
279 return HDF_ERR_INVALID_PARAM;
280 }
281 return TimerCntrlStop(TimerCntrlOpen(number));
282 }
283
TimerIoCb(uint32_t number)284 static int32_t TimerIoCb(uint32_t number)
285 {
286 uint32_t handle = number + TIMER_HANDLE_SHIFT;
287 int32_t ret;
288 struct HdfSBuf *data = NULL;
289
290 data = HdfSbufObtainDefaultSize();
291 if (data == NULL) {
292 HDF_LOGE("%s: HdfSbufObtainDefaultSize failed", __func__);
293 return HDF_ERR_IO;
294 }
295 if (!HdfSbufWriteUint32(data, handle)) {
296 HDF_LOGE("%s: write handle fail!", __func__);
297 HdfSbufRecycle(data);
298 return HDF_ERR_IO;
299 }
300 ret = HdfDeviceSendEvent(g_timerManager->device, PLATFORM_LISTENER_EVENT_TIMER_NOTIFY, data);
301 HdfSbufRecycle(data);
302 HDF_LOGD("%s:set servce info done, ret = %d %d", __func__, ret, handle);
303 return HDF_SUCCESS;
304 }
305
TimerIoSet(struct HdfSBuf * data,struct HdfSBuf * reply)306 static int32_t TimerIoSet(struct HdfSBuf *data, struct HdfSBuf *reply)
307 {
308 uint32_t len;
309 uint32_t handle;
310 int16_t number;
311 struct TimerConfig *cfg = NULL;
312
313 (void)reply;
314 if (data == NULL) {
315 HDF_LOGE("%s: param invalid", __func__);
316 return HDF_ERR_INVALID_PARAM;
317 }
318 if (!HdfSbufReadUint32(data, &handle)) {
319 HDF_LOGE("%s: read handle failed!", __func__);
320 return HDF_ERR_IO;
321 }
322
323 if (!HdfSbufReadBuffer(data, (const void **)&cfg, &len) || cfg == NULL) {
324 HDF_LOGE("%s: read buffer failed!", __func__);
325 return HDF_ERR_IO;
326 }
327
328 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
329 if (number < 0) {
330 HDF_LOGE("%s: number[%d] invalid", __func__, number);
331 return HDF_ERR_INVALID_PARAM;
332 }
333 return TimerCntrlSet(TimerCntrlOpen(number), cfg->useconds, TimerIoCb);
334 }
335
TimerIoSetOnce(struct HdfSBuf * data,struct HdfSBuf * reply)336 static int32_t TimerIoSetOnce(struct HdfSBuf *data, struct HdfSBuf *reply)
337 {
338 uint32_t len;
339 uint32_t handle;
340 int16_t number;
341 struct TimerConfig *cfg = NULL;
342
343 (void)reply;
344 if (data == NULL) {
345 HDF_LOGE("%s: param invalid", __func__);
346 return HDF_ERR_INVALID_PARAM;
347 }
348 if (!HdfSbufReadUint32(data, &handle)) {
349 HDF_LOGE("%s: read handle failed!", __func__);
350 return HDF_ERR_IO;
351 }
352
353 if (!HdfSbufReadBuffer(data, (const void **)&cfg, &len) || cfg == NULL) {
354 HDF_LOGE("%s: read buffer failed!", __func__);
355 return HDF_ERR_IO;
356 }
357
358 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
359 if (number < 0) {
360 HDF_LOGE("%s: number[%d] invalid", __func__, number);
361 return HDF_ERR_INVALID_PARAM;
362 }
363 return TimerCntrlSetOnce(TimerCntrlOpen(number), cfg->useconds, TimerIoCb);
364 }
365
TimerIoGet(struct HdfSBuf * data,struct HdfSBuf * reply)366 static int32_t TimerIoGet(struct HdfSBuf *data, struct HdfSBuf *reply)
367 {
368 int32_t ret = HDF_SUCCESS;
369 struct TimerConfig cfg;
370 uint32_t handle;
371 int16_t number;
372 if ((data == NULL) || (reply == NULL)) {
373 HDF_LOGE("%s: param null", __func__);
374 return HDF_ERR_INVALID_PARAM;
375 }
376
377 if (!HdfSbufReadUint32(data, &handle)) {
378 HDF_LOGE("%s: HdfSbufReadUint32 failed", __func__);
379 return HDF_ERR_IO;
380 }
381
382 number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
383 if (number < 0) {
384 HDF_LOGE("%s: number[%d] invalid", __func__, number);
385 return HDF_ERR_INVALID_PARAM;
386 }
387 cfg.number = number;
388 ret = TimerCntrlGet(TimerCntrlOpen(number), &cfg.useconds, &cfg.isPeriod);
389 if (ret != HDF_SUCCESS) {
390 HDF_LOGE("%s: TimerCntrlGet failed!", __func__);
391 return ret;
392 }
393
394 if (!HdfSbufWriteBuffer(reply, &cfg, sizeof(cfg))) {
395 HDF_LOGE("%s: write buffer failed!", __func__);
396 return HDF_FAILURE;
397 }
398
399 return HDF_SUCCESS;
400 }
401
TimerIoDispatch(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)402 static int32_t TimerIoDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
403 {
404 int32_t ret;
405
406 (void)client;
407 switch (cmd) {
408 case TIMER_IO_OPEN:
409 ret = TimerIoOpen(data, reply);
410 break;
411 case TIMER_IO_CLOSE:
412 ret = TimerIoClose(data, reply);
413 break;
414 case TIMER_IO_START:
415 ret = TimerIoStart(data, reply);
416 break;
417 case TIMER_IO_STOP:
418 ret = TimerIoStop(data, reply);
419 break;
420 case TIMER_IO_SET:
421 ret = TimerIoSet(data, reply);
422 break;
423 case TIMER_IO_SETONCE:
424 ret = TimerIoSetOnce(data, reply);
425 break;
426 case TIMER_IO_GET:
427 ret = TimerIoGet(data, reply);
428 break;
429 default:
430 ret = HDF_ERR_NOT_SUPPORT;
431 HDF_LOGE("%s: cmd[%d] not support!", __func__, cmd);
432 break;
433 }
434 return ret;
435 }
436
TimerListRemoveAll(void)437 int32_t TimerListRemoveAll(void)
438 {
439 struct TimerCntrl *pos = NULL;
440 struct TimerCntrl *tmp = NULL;
441 struct TimerManager *manager = g_timerManager;
442
443 if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) {
444 HDF_LOGE("%s: lock regulator manager fail", __func__);
445 return HDF_ERR_DEVICE_BUSY;
446 }
447
448 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->timerListHead, struct TimerCntrl, node) {
449 if ((pos->ops->Remove != NULL) && (pos->ops->Remove(pos) != HDF_SUCCESS)) {
450 HDF_LOGE("%s: remove %u failed", __func__, pos->info.number);
451 }
452 DListRemove(&pos->node);
453 (void)OsalMutexDestroy(&pos->lock);
454 OsalMemFree(pos);
455 }
456
457 (void)OsalMutexUnlock(&manager->lock);
458 HDF_LOGI("%s: remove all regulator success", __func__);
459 return HDF_SUCCESS;
460 }
461
TimerCntrlAdd(struct TimerCntrl * cntrl)462 int32_t TimerCntrlAdd(struct TimerCntrl *cntrl)
463 {
464 CHECK_NULL_PTR_RETURN_VALUE(cntrl, HDF_ERR_INVALID_PARAM);
465 CHECK_NULL_PTR_RETURN_VALUE(cntrl->ops, HDF_ERR_INVALID_PARAM);
466 struct TimerCntrl *pos = NULL;
467 struct TimerCntrl *tmp = NULL;
468 struct TimerManager *manager = g_timerManager;
469 CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE);
470
471 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->timerListHead, struct TimerCntrl, node) {
472 if (cntrl->info.number == pos->info.number) {
473 HDF_LOGE("%s: timer[%u] existed", __func__, cntrl->info.number);
474 return HDF_FAILURE;
475 }
476 }
477
478 // init info
479 if (OsalMutexInit(&cntrl->lock) != HDF_SUCCESS) {
480 HDF_LOGE("%s: OsalMutexInit %u failed", __func__, cntrl->info.number);
481 return HDF_FAILURE;
482 }
483
484 if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) {
485 HDF_LOGE("%s: OsalMutexLock %u failed", __func__, cntrl->info.number);
486 return HDF_ERR_DEVICE_BUSY;
487 }
488 DListInsertTail(&cntrl->node, &manager->timerListHead);
489 (void)OsalMutexUnlock(&manager->lock);
490 HDF_LOGI("%s: add timer number[%u] success", __func__, cntrl->info.number);
491
492 return HDF_SUCCESS;
493 }
494
TimerCntrlRemoveByNumber(const uint32_t number)495 int32_t TimerCntrlRemoveByNumber(const uint32_t number)
496 {
497 struct TimerCntrl *pos = NULL;
498 struct TimerCntrl *tmp = NULL;
499 struct TimerManager *manager = g_timerManager;
500 CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE);
501
502 if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) {
503 HDF_LOGE("%s: OsalMutexLock failed", __func__);
504 return HDF_ERR_DEVICE_BUSY;
505 }
506
507 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->timerListHead, struct TimerCntrl, node) {
508 if (number == pos->info.number) {
509 if ((pos->ops->Remove != NULL) && (pos->ops->Remove(pos) != HDF_SUCCESS)) {
510 HDF_LOGE("%s: remove %u failed", __func__, pos->info.number);
511 }
512 (void)OsalMutexDestroy(&pos->lock);
513 DListRemove(&pos->node);
514 OsalMemFree(pos);
515 break;
516 }
517 }
518
519 (void)OsalMutexUnlock(&manager->lock);
520 HDF_LOGI("%s: remove timer %u success", __func__, number);
521 return HDF_SUCCESS;
522 }
523
TimerManagerBind(struct HdfDeviceObject * device)524 static int32_t TimerManagerBind(struct HdfDeviceObject *device)
525 {
526 int32_t ret;
527 struct TimerManager *manager = NULL;
528
529 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_OBJECT);
530
531 manager = (struct TimerManager *)OsalMemCalloc(sizeof(*manager));
532 if (manager == NULL) {
533 HDF_LOGE("%s: malloc manager fail!", __func__);
534 return HDF_ERR_MALLOC_FAIL;
535 }
536
537 ret = OsalMutexInit(&manager->lock);
538 if (ret != HDF_SUCCESS) {
539 HDF_LOGE("%s: mutex init fail:%d", __func__, ret);
540 OsalMemFree(manager);
541 manager = NULL;
542 return HDF_FAILURE;
543 }
544
545 manager->device = device;
546 device->service = &manager->service;
547 device->service->Dispatch = TimerIoDispatch;
548 DListHeadInit(&manager->timerListHead);
549 g_timerManager = manager;
550
551 HDF_LOGI("%s: success", __func__);
552 return HDF_SUCCESS;
553 }
554
TimerManagerInit(struct HdfDeviceObject * device)555 static int32_t TimerManagerInit(struct HdfDeviceObject *device)
556 {
557 HdfDeviceSetClass(device, DEVICE_CLASS_PLAT);
558 HDF_LOGI("%s: success", __func__);
559 return HDF_SUCCESS;
560 }
561
TimerManagerRelease(struct HdfDeviceObject * device)562 static void TimerManagerRelease(struct HdfDeviceObject *device)
563 {
564 HDF_LOGI("%s: Enter!", __func__);
565 CHECK_NULL_PTR_RETURN(device);
566
567 if (TimerListRemoveAll() != HDF_SUCCESS) {
568 HDF_LOGE("%s: failed", __func__);
569 }
570
571 struct TimerManager *manager = (struct TimerManager *)device->service;
572 CHECK_NULL_PTR_RETURN(manager);
573 OsalMutexDestroy(&manager->lock);
574 OsalMemFree(manager);
575 g_timerManager = NULL;
576 }
577
578 struct HdfDriverEntry g_timerManagerEntry = {
579 .moduleVersion = 1,
580 .Bind = TimerManagerBind,
581 .Init = TimerManagerInit,
582 .Release = TimerManagerRelease,
583 .moduleName = "HDF_PLATFORM_TIMER_MANAGER",
584 };
585
586 HDF_INIT(g_timerManagerEntry);
587