MTK(6225)定时器源代分析

关注

转载最新推荐文章于 2026-03-26 11:31:59 发布 987 阅读 AI 写同款· GEO 优化 ›

mtk 中断 MTK平台有个图层的概念。每个层的数据存放在不同的buffer中，这些buffer可以从LCD对应的寄存器中读出。具体的自己去查对应平台的规格书吧。MTK的平台是你在blockwrite中通过STARTLCDTRANSFER打开这个寄存器对应的位，然后硬件把每一层图像中对应的像素点取出，然后通过硬件合成，把合成后的数据通过你在LCD_DATA_ADDR中设置的端口地址找到LCD接口，送入L 阅读详情

转载的 MTK(6225)定时器源代分析写的很好，思路很清楚，内容充实，小辈学习了！

转载注明出处，版权归作者所有

lyzaily@126.com

yanzhong.lee

http://blog.163.com/lyzaily@126/blog/static/424388372009290535834/

最近在网上看了一些MTK定时器的有关博文，但是没有结合源代分析所以一下子可能看的不是太明白，我现在结合MTK6225源代码进行简单的说明，以便于大家交流！

（一）首先我想给出几个有关定时器的重要全局变量：

1：

static TIMERTABLE g_timer_table = {0};
说明：

g_timer_table 是系统维护的一个定时器链表，每一个TIMERTABLE变量可以储存12（或者24）个定时器；

TIMERTABLE的结构是：

typedef struct timertable
{
mmi_frm_timer_type tm[SIMULTANEOUS_TIMER_NUM];
struct timertable *next;
} TIMERTABLE;
其中mmi_frm_timer_type结构是：

typedef struct {
    U16 timer_info;
    eventid event_id;
    oslTimerFuncPtr callback_func;
    void* arg;
} mmi_frm_timer_type;

SIMULTANEOUS_TIMER_NUM==12 or 24，这两个值是系统推荐的值。

mmi_frm_timer_type中的成员timer_info最高BIT位表示了是队列定时器（0）还是非队列定时器（1）；

event_id是个指针便利，由evshed_set_event（）分配并返回的；

evshed_set_event()函数是源代码 MTK没有给出，只给出了简单的接口说明如下英文所示：

这段话是什么意思：

就是说每个定时器（each timer item）中的成员变量event_id所指向的内存空间都是由函数evshed_set_event（）分配的，并且将指向给内存的指针返回给调用者（也就是将event_id保存到全局变量
TIMERTABLE.tm[xxxx].event_id中）；如果上层应用将该event id保存到了TIMERTABLE.tm[xxxx].event_id，则当事件取消函数执行后（evshed_cancel_event(event_scheduler *es, eventid *eid)）或者定时事件结束后，上层应用（caller）必须将TIMERTABLE.tm[xxxx].event_id置城NULL。

2：

static U16 g_timer_table_size = 0;

表示全局变量g_timer_table中最多能储存多少个定时器；系统刚启动时对多能存储12个或24个，究竟多少个要取决于你系统中 SIMULTANEOUS_TIMER_NUM宏的值；当系统运行一段时间以后定时器个数已经超过了SIMULTANEOUS_TIMER_NUM宏所能表示范围；则需要系统分配一个TIMERTABLE大小的变量空间并将该空间的指针赋给全局变量g_timer_table 中的成员next指针；

请参阅L4StartTimer中的部分代码：

.....

pTable = &g_timer_table;
if (g_timer_table_used >= g_timer_table_size) //表示当前已经使用的定时器数超过了一个TIMERTABLE变量所

                                                                            //能存储的定时器个数
    {

        do
        {
            if (pTable->next == NULL)
            {
                pTable->next = OslMalloc(sizeof(TIMERTABLE));
                memset(pTable->next, 0, sizeof(TIMERTABLE));
                g_timer_table_size += SIMULTANEOUS_TIMER_NUM;
                pTable = pTable->next;
                i = 0;
                break;
            }
            pTable = pTable->next;
        } while (pTable != NULL);
    }
    else

....

[粉红色英文是什么意思？]

如果TIMERTABLE列表没有足够的空间存储定时器时，说明MMI在某个时刻需要更多的定时器同时运行，我们可以给系统分配更多的内存空间；但是我们不需要去释放刚才分配给TIMERTABEL列表的空间。那么这个空间在哪里释放呢？是在系统启动时释放；系统刚启动时在TIMERTABLE列表中只维护一个节点，只有当系统运行之后所需的定时器超过了12或24个时才为下一个列表节点分配空间；当系统重新启动后多余的节点空间就被释放。如下代码所示, 在L4InitTimer（）中。

mmi_create()->MMI_Init()->L4InitTimer()

...

    TIMERTABLE *p;
    TIMERTABLE *pp;

    p = g_timer_table.next;
    pp = NULL;
    do
    {
        if (p != NULL)
        {
            pp = p->next;
            OslMfree(p);
        }
        p = pp;
    } while (p != NULL);

...

3：

static U16 g_timer_table_used = 0;

表示当前系统中已经使用了多少个定时器。

（二）定时器代码执行流程分析

要认识MTK定时器的工作机制，必须要分析如下几个函数的执行过程：

1：L4InitTimer()

2：StartTimer()

3:StopTimer()

4:L4CallBackTimer()

（一）L4InitTimer（）已经在上面分析过，主要的工作就是释放TIMERTABLE列表中除了g_timer_table全局变量占有的所有内存空间；初始化全局变量；初始化系统默认的队列定时器、非队列定时器（使用函数static_init_timer() 和new_evshen()) .

（二）StartTimer（）

首先在全局变量g_timer_table寻找是否有空间，如果有则找到存储定时器信息空间；否则分配一个TIMERTABLE类型变量的空间，并添加到g_timer_table中供系统使用。

有了存储定时器的空间后，主要做了以下工作：

判断是队列定时器还是非队列定时器，并添加到对应的定时器调度队列中。

    if (alignment == TIMER_IS_NO_ALIGNMENT)
    {

        pTable->tm[i].timer_info = nTimerId | NO_ALIGNMENT_TIMER_MASK;
        pTable->tm[i].event_id = evshed_set_event(
                                    event_scheduler1_ptr, //非队列定时器调度队列
                                    (kal_timer_func_ptr) L4CallBackTimer,
                                    (void*)&(pTable->tm[i]),
                                    temp);
        pTable->tm[i].arg = funcArg;
        pTable->tm[i].callback_func = TimerExpiry;
        g_timer_table_used++;
    }
    else if (alignment == TIMER_IS_ALIGNMENT)
    {

        pTable->tm[i].timer_info = nTimerId | ALIGNMENT_TIMER_MASK;
        pTable->tm[i].event_id = evshed_set_event(
                                    event_scheduler2_ptr, //队列定时器调度队列
                                    (kal_timer_func_ptr) L4CallBackTimer,
                                    (void*)&(pTable->tm[i]),
                                    temp);
        pTable->tm[i].arg = funcArg;
        pTable->tm[i].callback_func = TimerExpiry;
        g_timer_table_used++;
    }

（三）L4CallBackTimer（）

分析如下代码，当定时时间到时，会执行该函数；执行用户为定时器制订的定时器到期时要执行的任务；并且将外部消息队列中的消息取出并存储到MMI的循环消息队列中。

static void L4CallBackTimer(void *p)
{



    mmi_frm_timer_type *pTimer = (mmi_frm_timer_type *)p;
    U32 nTimerId = pTimer->timer_info & (~NO_ALIGNMENT_TIMER_MASK);
    oslTimerFuncPtr pTimerExpiry = pTimer->callback_func;
    void * arg = pTimer->arg;

    MMI_ASSERT(nTimerId < MAX_TIMERS);

    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_L4DRV_CBTIMER_HDLR, nTimerId, pTimerExpiry);
    g_timer_table_used--;
    memset( pTimer, 0, sizeof(mmi_frm_timer_type));

    if (pTimerExpiry) //用户在L4StartTimer（）函数中设置的定时器结束时的回调函数
    {
        pTimerExpiry((void *)arg);
    }

mmi_frm_fetch_msg_from_extQ_to_circularQ();

}

（四）L4stopTimer 就不用介绍了，很简单。

（五）我们在（三）中已经知道，当定时器到期时会通过 L4CallBackTimer（）函数调用我们APP层所制订的定时器到期回调函数；那么究竟 L4CallBackTimer（）是如何被系统调用的呢？？？？由于MTK对系统中的定时器作了封装无法看到源代码，所以我这里只是猜测，如果有错请各位看官指正，在此先谢谢各位！

在MMI_task（）中有如下代码：

switch (Message.msg_id)
{

...

                            ...
                            case MSG_ID_TIMER_EXPIRY:
                            {
                                kal_uint16 msg_len;

                                EvshedMMITimerHandler(get_local_para_ptr(Message.oslDataPtr, &msg_len));
                            }
                                break;

...

}

而函数EvshedMMITimerHandler（）代码如下：

void EvshedMMITimerHandler(void *dataPtr)
{



    stack_timer_struct *stack_timer_ptr;

stack_timer_ptr = (stack_timer_struct*) dataPtr;

    if (stack_timer_ptr == &base_timer1)
    {
        if (stack_is_time_out_valid(&base_timer1))
        {
            evshed_timer_handler(event_scheduler1_ptr);
        }
        stack_process_time_out(&base_timer1);
    }
    else if (stack_timer_ptr == &base_timer2)
    {
        if (stack_is_time_out_valid(&base_timer2))
        {
            evshed_timer_handler(event_scheduler2_ptr);
        }
        stack_process_time_out(&base_timer2);
    }
}

并且在L4CallBackTimer中调用了一个函数mmi_frm_fetch_msg_from_extQ_to_circularQ()；而该函数的功能是将外部消息队列中的消息取出来，放入MMI的循环消息队列中。我们来看看 mmi_frm_fetch_msg_from_extQ_to_circularQ()中的一个代码片断；就会发现该函数放入MMI循环消息队列中的消息就是MMI_task()接下来就要处理的消息。

mmi_frm_fetch_msg_from_extQ_to_circularQ()代码片断如下：

            if (mmi_frm_check_is_valid_msg(&checkBaseNode, &Message) == 1)
            {

                ilm_ptr.src_mod_id = Message.src_mod_id;
                ilm_ptr.dest_mod_id = Message.dest_mod_id;
                ilm_ptr.msg_id = Message.msg_id;
                ilm_ptr.sap_id = Message.sap_id;
                ilm_ptr.local_para_ptr = Message.local_para_ptr;
                ilm_ptr.peer_buff_ptr = Message.peer_buff_ptr;

                flag = OslWriteCircularQ(&ilm_ptr);
                MMI_ASSERT(flag == 1);

                if (Message.src_mod_id != MOD_TIMER)
                {
                    hold_local_para(ilm_ptr.local_para_ptr);
                    hold_peer_buff(ilm_ptr.peer_buff_ptr);
                }
            }
而在MMI_task（）中变量Message的类型是MYQUEUE，而MYQUEUE就是一个宏，定义如下：

#define MYQUEUE ilm_struct

由此可以看出，MMI_task()中处理的消息，就是由函数mmi_frm_fetch_msg_from_extQ_to_circularQ()从外部队列出去并封装成MMI循环队列的消息放入循环队列，并由MMI_task()来处理。

[总结]

app 通过StartTimer启动一个定时器；定时器到期时会发一个消息给MMI_task()，MMI_task（）调用EvshedMMITimerHandler（）通过该函数会去调用定时器到期时L4层的回调函数L4CallBackTimer（）；L4CallBackTimer（）去回调由app定制的定时器到期回调函数；同时L4CallBackTimer（）会将外部消息队列中的下一个消息取出并封装成MMI循环队列中的消息结构传入MMI循环队列，等候MMI_task()处理。

收录于