linux-imx

// SPDX-License-Identifier: GPL-2.0

/* calibrate.c: default delay calibration

 *

 * Excised from init/main.c

 *  Copyright (C) 1991, 1992  Linus Torvalds

 */

​

#include <linux/jiffies.h>

#include <linux/delay.h>

#include <linux/init.h>

#include <linux/timex.h>

#include <linux/smp.h>

#include <linux/percpu.h>

​

unsigned long lpj_fine;

unsigned long preset_lpj;

static int __init lpj_setup(char *str)

{

    preset_lpj = simple_strtoul(str,NULL,0);

    return 1;

}

​

__setup("lpj=", lpj_setup);

​

#ifdef ARCH_HAS_READ_CURRENT_TIMER

​

/* This routine uses the read_current_timer() routine and gets the

 * loops per jiffy directly, instead of guessing it using delay().

 * Also, this code tries to handle non-maskable asynchronous events

 * (like SMIs)

 */

#define DELAY_CALIBRATION_TICKS         ((HZ < 100) ? 1 : (HZ/100))

#define MAX_DIRECT_CALIBRATION_RETRIES      5

​

static unsigned long calibrate_delay_direct(void)

{

    unsigned long pre_start, start, post_start;

    unsigned long pre_end, end, post_end;

    unsigned long start_jiffies;

    unsigned long timer_rate_min, timer_rate_max;

    unsigned long good_timer_sum = 0;

    unsigned long good_timer_count = 0;

    unsigned long measured_times[MAX_DIRECT_CALIBRATION_RETRIES];

    int max = -1; /* index of measured_times with max/min values or not set */

    int min = -1;

    int i;

​

    if (read_current_timer(&pre_start) < 0 )

        return 0;

​

    /*

     * A simple loop like

     *  while ( jiffies < start_jiffies+1)

     *      start = read_current_timer();

     * will not do. As we don't really know whether jiffy switch

     * happened first or timer_value was read first. And some asynchronous

     * event can happen between these two events introducing errors in lpj.

     *

     * So, we do

     * 1. pre_start <- When we are sure that jiffy switch hasn't happened

     * 2. check jiffy switch

     * 3. start <- timer value before or after jiffy switch

     * 4. post_start <- When we are sure that jiffy switch has happened

     *

     * Note, we don't know anything about order of 2 and 3.

     * Now, by looking at post_start and pre_start difference, we can

     * check whether any asynchronous event happened or not

     */

​

    for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) {

        pre_start = 0;

        read_current_timer(&start);

        start_jiffies = jiffies;

        while (time_before_eq(jiffies, start_jiffies + 1)) {

            pre_start = start;

            read_current_timer(&start);

        }

        read_current_timer(&post_start);

​

        pre_end = 0;

        end = post_start;

        while (time_before_eq(jiffies, start_jiffies + 1 +

                           DELAY_CALIBRATION_TICKS)) {

            pre_end = end;

            read_current_timer(&end);

        }

        read_current_timer(&post_end);

​

        timer_rate_max = (post_end - pre_start) /

                    DELAY_CALIBRATION_TICKS;

        timer_rate_min = (pre_end - post_start) /

                    DELAY_CALIBRATION_TICKS;