[时钟管理] arm 时间系统 2

*******************************************************************************************
cpu0 local timer clock_event_device注册过程：
start_kernel()->reset_init()->kernel_init()->smp_prepare_cpus()
   ->percpu_timer_setup()->twd_timer_setup()->clockevents_config_and_register() 
   ->twd_local_timer_common_register()->local_timer_register()
这里也是板级相关代码，不过内核提供了一些core方法。当然只有smp才会执行到这里的路径。
这个时候cpu1仍然处于wfi状态。不过随后cpu1被唤醒之后同样也会执行类似方法设置相应的local timer。
twd_timer是arm每个核内部的timer。

local timer的中断处理函数基本上就是调用了关联的clock_event_device->event_handler()方法。
clock_event_device对象是每cpu分配的对象。同上面一样，event_handler方法也是后面才初始化的。
static irqreturn_t twd_handler(int irq, void *dev_id)
{
        struct clock_event_device *evt = *(struct clock_event_device **)dev_id;

        if (twd_timer_ack()) {
                evt->event_handler(evt);
                return IRQ_HANDLED;
        }

        return IRQ_NONE;
}

可以看出来local timer同sp804 clock_event_device流程非常相似，中断处理函数都是调用了自己的
clock_event_device的event_handler方法。不过这两个clock_event_device代表了不同的硬件，他们的
set_next_event触发中断方法不同。rating优先级不一样，一般localtimer=350，sp804=300，就是说localtimer的
优先级要高。irq中断号当然也不一样。。

通过tick_check_new_device()新的clock_event_device注册到系统中的时候，rating有很大的作用。
当增加一个新的newdevice，如果系统当前没有device，则设置当前device等于newdevice。
当增加一个新的newdevice，如果newdevice的rating小于当前device的rating，则会忽略这个newdevice。
反之newdevice通过clockevents_exchange_device关闭当前的device，然后切换当前device等于newdevice。
接着通过tick_setup_device继续设置event_handler=tick_handle_periodic。
所以，这里local timer会替代之前注册的sp804 timer（只有cpu0才有）。从这里开始，sp804 timer0实际上等同
disable的,它的next_event中断时间是一个超大的值。而local timer中断不断的产生并且处理了。


*******************************************************************************************
接着看看tick_handle_periodic如何切换成hrtimer_interrupt的。

首先在init_jiffies_clocksource中注册了jiffies clocksource到kernel。
static int __init init_jiffies_clocksource(void)
{
        return clocksource_register(&clocksource_jiffies);
}
core_initcall(init_jiffies_clocksource);

clocksource_enqueue()实际上就是按照优先级rating将所有clocksource链接到clocksource_list上。
并且链表头部的clocksource是rating最高的。
clocksource_select()会选择best clocksource，等于当前最高优先级的clocksource，
或者是用户指定的clocksource（如果指定了的话）。这时，如果best clocksource不等于当前clocksource，
调用timekeeping_notify通知内核新的clocksource生效了。
int clocksource_register(struct clocksource *cs)
{
        /* calculate max adjustment for given mult/shift */
        cs->maxadj = clocksource_max_adjustment(cs);
        WARN_ONCE(cs->mult + cs->maxadj < cs->mult,
                "Clocksource %s might overflow on 11%% adjustment\n",
                cs->name);

        /* calculate max idle time permitted for this clocksource */
        cs->max_idle_ns = clocksource_max_deferment(cs);

        mutex_lock(&clocksource_mutex);
        clocksource_enqueue(cs);
        clocksource_enqueue_watchdog(cs);
        clocksource_select();
        mutex_unlock(&clocksource_mutex);
        return 0;
}

timekeeping_notify实际上会调用到change_clocksource方法来更新timekeeper的clocksource为best clocksource。
tick_clock_notify()会触发kernel去检测是否要切换到hrtimer模式。
void timekeeping_notify(struct clocksource *clock)
{
        struct timekeeper *tk = &timekeeper;

        if (tk->clock == clock)
                return;
        stop_machine(change_clocksource, clock, NULL);
        tick_clock_notify();
}

static int change_clocksource(void *data)
{
        struct timekeeper *tk = &timekeeper;
        struct clocksource *new, *old;
        unsigned long flags;

        new = (struct clocksource *) data;

        write_seqlock_irqsave(&tk->lock, flags);

        timekeeping_forward_now(tk);
        if (!new->enable || new->enable(new) == 0) {
                old = tk->clock;
                tk_setup_internals(tk, new);
                if (old->disable)
                        old->disable(old);
        }
        timekeeping_update(tk, true);

        write_sequnlock_irqrestore(&tk->lock, flags);

        return 0;
}

其实这个时候，sp804 timer1作为free run timer的clocksource早已经注册到系统中了。
所以现在注册jiffies clocksource的时候，就会触发timekeeping_notify来更新timekeeper的clocksource，
同时通知kernel去检查是否要切换hrtimer模式。


当前的时钟中断处理函数回调是tick_handle_periodic()
tick_periodic()->update_process_times->run_local_timers()激活TIMER_SOFTIRQ处理timer软中断。
hrtimer_run_queues如果kernel没有启动hrtimer模式的话，就在这里处理hrtimer事件。所以hrtimer api
仍然可以使用，但是是通过tick来触发的。
void run_local_timers(void)
{
        hrtimer_run_queues();
        raise_softirq(TIMER_SOFTIRQ);
}


timer软中断其实还在hrtimer_run_pending检测是否要切换到hrtimer模式。
open_softirq(TIMER_SOFTIRQ, run_timer_softirq);        
static void run_timer_softirq(struct softirq_action *h)
{
        struct tvec_base *base = __this_cpu_read(tvec_bases);

        hrtimer_run_pending();

        if (time_after_eq(jiffies, base->timer_jiffies))
                __run_timers(base);
}
void hrtimer_run_pending(void)
{
        if (hrtimer_hres_active())
                return;

        /*
         * This _is_ ugly: We have to check in the softirq context,
         * whether we can switch to highres and / or nohz mode. The
         * clocksource switch happens in the timer interrupt with
         * xtime_lock held. Notification from there only sets the
         * check bit in the tick_oneshot code, otherwise we might
         * deadlock vs. xtime_lock.
         */
        if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
                hrtimer_switch_to_hres();
}

int tick_check_oneshot_change(int allow_nohz)
{
        struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
        //tick_clock_notify会设置check_clocks位。所以这里就会要继续检测了。
        //然后又清0，所以系统绝大部分事件这个方法下面都不会走的。
        if (!test_and_clear_bit(0, &ts->check_clocks))
                return 0;

        if (ts->nohz_mode != NOHZ_MODE_INACTIVE)
                return 0;

        if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())
                return 0;

        if (!allow_nohz)
                return 1;

        tick_nohz_switch_to_nohz();
        return 0;
}

检查timekeeper的clocksource时候有hrtimer能力。当然我们的sp804 timer1是符合要求的。
int timekeeping_valid_for_hres(void)
{
        struct timekeeper *tk = &timekeeper;
        unsigned long seq;
        int ret;

        do {
                seq = read_seqbegin(&tk->lock);

                ret = tk->clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;

        } while (read_seqretry(&tk->lock, seq));

        return ret;
}

然后通过hrtimer_switch_to_hres切换perodioc到oneshot hrtimer模式。
tick_setup_sched_timer()是通过hrtimer模拟的tick中断，当然系统在idle的时候，
这个hrtimer中断会关闭的。
static int hrtimer_switch_to_hres(void)
{
        int i, cpu = smp_processor_id();
        struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
        unsigned long flags;

        if (base->hres_active)
                return 1;

        local_irq_save(flags);

        if (tick_init_highres()) {
                local_irq_restore(flags);
                printk(KERN_WARNING "Could not switch to high resolution "
                                    "mode on CPU %d\n", cpu);
                return 0;
        }
        base->hres_active = 1;
        for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
                base->clock_base .resolution = KTIME_HIGH_RES;

        tick_setup_sched_timer();
        /* "Retrigger" the interrupt to get things going */
        retrigger_next_event(NULL);
        local_irq_restore(flags);
        return 1;
}

切换每cpu的tick_cpu_device->clock_event_device的event_handler方法为hrtimer_interrupt。
当然在tick_check_new_device的时候每cpu的tick_cpu_device->clock_event_device已经指向了localtimer device。
int tick_init_highres(void)
{
        return tick_switch_to_oneshot(hrtimer_interrupt);
}

todo：
cpu1 唤醒流程。