linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Generic sched_clock() support, to extend low level hardware time

 * counters to full 64-bit ns values.

 */

#include <linux/clocksource.h>

#include <linux/init.h>

#include <linux/jiffies.h>

#include <linux/ktime.h>

#include <linux/kernel.h>

#include <linux/moduleparam.h>

#include <linux/sched.h>

#include <linux/sched/clock.h>

#include <linux/syscore_ops.h>

#include <linux/hrtimer.h>

#include <linux/sched_clock.h>

#include <linux/seqlock.h>

#include <linux/bitops.h>

​

/**

 * struct clock_read_data - data required to read from sched_clock()

 *

 * @epoch_ns:       sched_clock() value at last update

 * @epoch_cyc:      Clock cycle value at last update.

 * @sched_clock_mask:   Bitmask for two's complement subtraction of non 64bit

 *          clocks.

 * @read_sched_clock:   Current clock source (or dummy source when suspended).

 * @mult:       Multipler for scaled math conversion.

 * @shift:      Shift value for scaled math conversion.

 *

 * Care must be taken when updating this structure; it is read by

 * some very hot code paths. It occupies <=40 bytes and, when combined

 * with the seqcount used to synchronize access, comfortably fits into

 * a 64 byte cache line.

 */

struct clock_read_data {

    u64 epoch_ns;

    u64 epoch_cyc;

    u64 sched_clock_mask;

    u64 (*read_sched_clock)(void);

    u32 mult;

    u32 shift;

};

​

/**

 * struct clock_data - all data needed for sched_clock() (including

 *                     registration of a new clock source)

 *

 * @seq:        Sequence counter for protecting updates. The lowest

 *          bit is the index for @read_data.

 * @read_data:      Data required to read from sched_clock.

 * @wrap_kt:        Duration for which clock can run before wrapping.

 * @rate:       Tick rate of the registered clock.

 * @actual_read_sched_clock: Registered hardware level clock read function.

 *

 * The ordering of this structure has been chosen to optimize cache

 * performance. In particular 'seq' and 'read_data[0]' (combined) should fit

 * into a single 64-byte cache line.

 */

struct clock_data {

    seqcount_t      seq;

    struct clock_read_data  read_data[2];

    ktime_t         wrap_kt;

    unsigned long       rate;

​

    u64 (*actual_read_sched_clock)(void);

};

​

static struct hrtimer sched_clock_timer;

static int irqtime = -1;

​

core_param(irqtime, irqtime, int, 0400);

​

static u64 notrace jiffy_sched_clock_read(void)

{

    /*

     * We don't need to use get_jiffies_64 on 32-bit arches here

     * because we register with BITS_PER_LONG

     */

    return (u64)(jiffies - INITIAL_JIFFIES);

}

​

static struct clock_data cd ____cacheline_aligned = {

    .read_data[0] = { .mult = NSEC_PER_SEC / HZ,

              .read_sched_clock = jiffy_sched_clock_read, },

    .actual_read_sched_clock = jiffy_sched_clock_read,

};

​

static inline u64 notrace cyc_to_ns(u64 cyc, u32 mult, u32 shift)

{

    return (cyc * mult) >> shift;

}