cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

hrtimer.c (3712B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * ALSA timer back-end using hrtimer
      4 * Copyright (C) 2008 Takashi Iwai
      5 */
      6
      7#include <linux/init.h>
      8#include <linux/slab.h>
      9#include <linux/module.h>
     10#include <linux/moduleparam.h>
     11#include <linux/hrtimer.h>
     12#include <sound/core.h>
     13#include <sound/timer.h>
     14
     15MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
     16MODULE_DESCRIPTION("ALSA hrtimer backend");
     17MODULE_LICENSE("GPL");
     18
     19MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_HRTIMER));
     20
     21#define NANO_SEC	1000000000UL	/* 10^9 in sec */
     22static unsigned int resolution;
     23
     24struct snd_hrtimer {
     25	struct snd_timer *timer;
     26	struct hrtimer hrt;
     27	bool in_callback;
     28};
     29
     30static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
     31{
     32	struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);
     33	struct snd_timer *t = stime->timer;
     34	ktime_t delta;
     35	unsigned long ticks;
     36	enum hrtimer_restart ret = HRTIMER_NORESTART;
     37
     38	spin_lock(&t->lock);
     39	if (!t->running)
     40		goto out; /* fast path */
     41	stime->in_callback = true;
     42	ticks = t->sticks;
     43	spin_unlock(&t->lock);
     44
     45	/* calculate the drift */
     46	delta = ktime_sub(hrt->base->get_time(), hrtimer_get_expires(hrt));
     47	if (delta > 0)
     48		ticks += ktime_divns(delta, ticks * resolution);
     49
     50	snd_timer_interrupt(stime->timer, ticks);
     51
     52	spin_lock(&t->lock);
     53	if (t->running) {
     54		hrtimer_add_expires_ns(hrt, t->sticks * resolution);
     55		ret = HRTIMER_RESTART;
     56	}
     57
     58	stime->in_callback = false;
     59 out:
     60	spin_unlock(&t->lock);
     61	return ret;
     62}
     63
     64static int snd_hrtimer_open(struct snd_timer *t)
     65{
     66	struct snd_hrtimer *stime;
     67
     68	stime = kzalloc(sizeof(*stime), GFP_KERNEL);
     69	if (!stime)
     70		return -ENOMEM;
     71	hrtimer_init(&stime->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
     72	stime->timer = t;
     73	stime->hrt.function = snd_hrtimer_callback;
     74	t->private_data = stime;
     75	return 0;
     76}
     77
     78static int snd_hrtimer_close(struct snd_timer *t)
     79{
     80	struct snd_hrtimer *stime = t->private_data;
     81
     82	if (stime) {
     83		spin_lock_irq(&t->lock);
     84		t->running = 0; /* just to be sure */
     85		stime->in_callback = 1; /* skip start/stop */
     86		spin_unlock_irq(&t->lock);
     87
     88		hrtimer_cancel(&stime->hrt);
     89		kfree(stime);
     90		t->private_data = NULL;
     91	}
     92	return 0;
     93}
     94
     95static int snd_hrtimer_start(struct snd_timer *t)
     96{
     97	struct snd_hrtimer *stime = t->private_data;
     98
     99	if (stime->in_callback)
    100		return 0;
    101	hrtimer_start(&stime->hrt, ns_to_ktime(t->sticks * resolution),
    102		      HRTIMER_MODE_REL);
    103	return 0;
    104}
    105
    106static int snd_hrtimer_stop(struct snd_timer *t)
    107{
    108	struct snd_hrtimer *stime = t->private_data;
    109
    110	if (stime->in_callback)
    111		return 0;
    112	hrtimer_try_to_cancel(&stime->hrt);
    113	return 0;
    114}
    115
    116static const struct snd_timer_hardware hrtimer_hw __initconst = {
    117	.flags =	SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_WORK,
    118	.open =		snd_hrtimer_open,
    119	.close =	snd_hrtimer_close,
    120	.start =	snd_hrtimer_start,
    121	.stop =		snd_hrtimer_stop,
    122};
    123
    124/*
    125 * entry functions
    126 */
    127
    128static struct snd_timer *mytimer;
    129
    130static int __init snd_hrtimer_init(void)
    131{
    132	struct snd_timer *timer;
    133	int err;
    134
    135	resolution = hrtimer_resolution;
    136
    137	/* Create a new timer and set up the fields */
    138	err = snd_timer_global_new("hrtimer", SNDRV_TIMER_GLOBAL_HRTIMER,
    139				   &timer);
    140	if (err < 0)
    141		return err;
    142
    143	timer->module = THIS_MODULE;
    144	strcpy(timer->name, "HR timer");
    145	timer->hw = hrtimer_hw;
    146	timer->hw.resolution = resolution;
    147	timer->hw.ticks = NANO_SEC / resolution;
    148	timer->max_instances = 100; /* lower the limit */
    149
    150	err = snd_timer_global_register(timer);
    151	if (err < 0) {
    152		snd_timer_global_free(timer);
    153		return err;
    154	}
    155	mytimer = timer; /* remember this */
    156
    157	return 0;
    158}
    159
    160static void __exit snd_hrtimer_exit(void)
    161{
    162	if (mytimer) {
    163		snd_timer_global_free(mytimer);
    164		mytimer = NULL;
    165	}
    166}
    167
    168module_init(snd_hrtimer_init);
    169module_exit(snd_hrtimer_exit);