[linux-block.git] / drivers / ptp / ptp_kvm_common.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Virtual PTP 1588 clock for use with KVM guests
 *
 * Copyright (C) 2017 Red Hat Inc.
 */
#include <linux/device.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/ptp_kvm.h>
#include <uapi/linux/kvm_para.h>
#include <asm/kvm_para.h>
#include <uapi/asm/kvm_para.h>

#include <linux/ptp_clock_kernel.h>

struct kvm_ptp_clock {
	struct ptp_clock *ptp_clock;
	struct ptp_clock_info caps;
};

static DEFINE_SPINLOCK(kvm_ptp_lock);

static int ptp_kvm_get_time_fn(ktime_t *device_time,
			       struct system_counterval_t *system_counter,
			       void *ctx)
{
	long ret;
	u64 cycle;
	struct timespec64 tspec;
	struct clocksource *cs;

	spin_lock(&kvm_ptp_lock);

	preempt_disable_notrace();
	ret = kvm_arch_ptp_get_crosststamp(&cycle, &tspec, &cs);
	if (ret) {
		spin_unlock(&kvm_ptp_lock);
		preempt_enable_notrace();
		return ret;
	}

	preempt_enable_notrace();

	system_counter->cycles = cycle;
	system_counter->cs = cs;

	*device_time = timespec64_to_ktime(tspec);

	spin_unlock(&kvm_ptp_lock);

	return 0;
}

static int ptp_kvm_getcrosststamp(struct ptp_clock_info *ptp,
				  struct system_device_crosststamp *xtstamp)
{
	return get_device_system_crosststamp(ptp_kvm_get_time_fn, NULL,
					     NULL, xtstamp);
}

/*
 * PTP clock operations
 */

static int ptp_kvm_adjfine(struct ptp_clock_info *ptp, long delta)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_settime(struct ptp_clock_info *ptp,
			   const struct timespec64 *ts)
{
	return -EOPNOTSUPP;
}

static int ptp_kvm_gettime(struct ptp_clock_info *ptp, struct timespec64 *ts)
{
	long ret;
	struct timespec64 tspec;

	spin_lock(&kvm_ptp_lock);

	ret = kvm_arch_ptp_get_clock(&tspec);
	if (ret) {
		spin_unlock(&kvm_ptp_lock);
		return ret;
	}

	spin_unlock(&kvm_ptp_lock);

	memcpy(ts, &tspec, sizeof(struct timespec64));

	return 0;
}

static int ptp_kvm_enable(struct ptp_clock_info *ptp,
			  struct ptp_clock_request *rq, int on)
{
	return -EOPNOTSUPP;
}

static const struct ptp_clock_info ptp_kvm_caps = {
	.owner		= THIS_MODULE,
	.name		= "KVM virtual PTP",
	.max_adj	= 0,
	.n_ext_ts	= 0,
	.n_pins		= 0,
	.pps		= 0,
	.adjfine	= ptp_kvm_adjfine,
	.adjtime	= ptp_kvm_adjtime,
	.gettime64	= ptp_kvm_gettime,
	.settime64	= ptp_kvm_settime,
	.enable		= ptp_kvm_enable,
	.getcrosststamp = ptp_kvm_getcrosststamp,
};

/* module operations */

static struct kvm_ptp_clock kvm_ptp_clock;

static void __exit ptp_kvm_exit(void)
{
	ptp_clock_unregister(kvm_ptp_clock.ptp_clock);
	kvm_arch_ptp_exit();
}

static int __init ptp_kvm_init(void)
{
	long ret;

	ret = kvm_arch_ptp_init();
	if (ret) {
		if (ret != -EOPNOTSUPP)
			pr_err("fail to initialize ptp_kvm");
		return ret;
	}

	kvm_ptp_clock.caps = ptp_kvm_caps;

	kvm_ptp_clock.ptp_clock = ptp_clock_register(&kvm_ptp_clock.caps, NULL);

	return PTR_ERR_OR_ZERO(kvm_ptp_clock.ptp_clock);
}

module_init(ptp_kvm_init);
module_exit(ptp_kvm_exit);

MODULE_AUTHOR("Marcelo Tosatti <mtosatti@redhat.com>");
MODULE_DESCRIPTION("PTP clock using KVMCLOCK");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
a0e136d4 MT	2	/*
	3	* Virtual PTP 1588 clock for use with KVM guests
	4	*
	5	* Copyright (C) 2017 Red Hat Inc.
a0e136d4 MT	6	*/
	7	#include <linux/device.h>
	8	#include <linux/err.h>
	9	#include <linux/init.h>
	10	#include <linux/kernel.h>
a8cf291b	11	#include <linux/slab.h>
a0e136d4	12	#include <linux/module.h>
a8cf291b	13	#include <linux/ptp_kvm.h>
a0e136d4 MT	14	#include <uapi/linux/kvm_para.h>
a0e136d4 MT	15	#include <asm/kvm_para.h>
a0e136d4 MT	16	#include <uapi/asm/kvm_para.h>
	17
	18	#include <linux/ptp_clock_kernel.h>
	19
	20	struct kvm_ptp_clock {
	21	struct ptp_clock *ptp_clock;
	22	struct ptp_clock_info caps;
	23	};
	24
0673f976	25	static DEFINE_SPINLOCK(kvm_ptp_lock);
a0e136d4	26
a0e136d4 MT	27	static int ptp_kvm_get_time_fn(ktime_t *device_time,
	28	struct system_counterval_t *system_counter,
	29	void *ctx)
	30	{
a8cf291b JW	31	long ret;
a8cf291b JW	32	u64 cycle;
a0e136d4	33	struct timespec64 tspec;
a8cf291b	34	struct clocksource *cs;
a0e136d4 MT	35
	36	spin_lock(&kvm_ptp_lock);
	37
	38	preempt_disable_notrace();
a8cf291b JW	39	ret = kvm_arch_ptp_get_crosststamp(&cycle, &tspec, &cs);
	40	if (ret) {
	41	spin_unlock(&kvm_ptp_lock);
	42	preempt_enable_notrace();
	43	return ret;
	44	}
a0e136d4 MT	45
	46	preempt_enable_notrace();
	47
a8cf291b JW	48	system_counter->cycles = cycle;
a8cf291b JW	49	system_counter->cs = cs;
a0e136d4 MT	50
	51	*device_time = timespec64_to_ktime(tspec);
	52
	53	spin_unlock(&kvm_ptp_lock);
	54
	55	return 0;
	56	}
	57
	58	static int ptp_kvm_getcrosststamp(struct ptp_clock_info *ptp,
	59	struct system_device_crosststamp *xtstamp)
	60	{
	61	return get_device_system_crosststamp(ptp_kvm_get_time_fn, NULL,
	62	NULL, xtstamp);
	63	}
	64
	65	/*
	66	* PTP clock operations
	67	*/
	68
73aa29a2	69	static int ptp_kvm_adjfine(struct ptp_clock_info *ptp, long delta)
a0e136d4 MT	70	{
	71	return -EOPNOTSUPP;
	72	}
	73
	74	static int ptp_kvm_adjtime(struct ptp_clock_info *ptp, s64 delta)
	75	{
	76	return -EOPNOTSUPP;
	77	}
	78
	79	static int ptp_kvm_settime(struct ptp_clock_info *ptp,
	80	const struct timespec64 *ts)
	81	{
	82	return -EOPNOTSUPP;
	83	}
	84
	85	static int ptp_kvm_gettime(struct ptp_clock_info ptp, struct timespec64 ts)
	86	{
a8cf291b	87	long ret;
a0e136d4 MT	88	struct timespec64 tspec;
	89
	90	spin_lock(&kvm_ptp_lock);
	91
a8cf291b JW	92	ret = kvm_arch_ptp_get_clock(&tspec);
a8cf291b JW	93	if (ret) {
a0e136d4	94	spin_unlock(&kvm_ptp_lock);
a8cf291b	95	return ret;
a0e136d4 MT	96	}
a0e136d4 MT	97
a0e136d4 MT	98	spin_unlock(&kvm_ptp_lock);
	99
	100	memcpy(ts, &tspec, sizeof(struct timespec64));
	101
	102	return 0;
	103	}
	104
	105	static int ptp_kvm_enable(struct ptp_clock_info *ptp,
	106	struct ptp_clock_request *rq, int on)
	107	{
	108	return -EOPNOTSUPP;
	109	}
	110
7d47e9a2	111	static const struct ptp_clock_info ptp_kvm_caps = {
a0e136d4 MT	112	.owner = THIS_MODULE,
	113	.name = "KVM virtual PTP",
	114	.max_adj = 0,
	115	.n_ext_ts = 0,
	116	.n_pins = 0,
	117	.pps = 0,
73aa29a2	118	.adjfine = ptp_kvm_adjfine,
a0e136d4 MT	119	.adjtime = ptp_kvm_adjtime,
	120	.gettime64 = ptp_kvm_gettime,
	121	.settime64 = ptp_kvm_settime,
	122	.enable = ptp_kvm_enable,
	123	.getcrosststamp = ptp_kvm_getcrosststamp,
	124	};
	125
	126	/* module operations */
	127
	128	static struct kvm_ptp_clock kvm_ptp_clock;
	129
	130	static void __exit ptp_kvm_exit(void)
	131	{
	132	ptp_clock_unregister(kvm_ptp_clock.ptp_clock);
6365ba64	133	kvm_arch_ptp_exit();
a0e136d4 MT	134	}
	135
	136	static int __init ptp_kvm_init(void)
	137	{
4306f200 RK	138	long ret;
4306f200 RK	139
a8cf291b JW	140	ret = kvm_arch_ptp_init();
a8cf291b JW	141	if (ret) {
a86ed2cf JH	142	if (ret != -EOPNOTSUPP)
a86ed2cf JH	143	pr_err("fail to initialize ptp_kvm");
a8cf291b JW	144	return ret;
a8cf291b JW	145	}
4306f200	146
a0e136d4 MT	147	kvm_ptp_clock.caps = ptp_kvm_caps;
	148
	149	kvm_ptp_clock.ptp_clock = ptp_clock_register(&kvm_ptp_clock.caps, NULL);
	150
49e190ec	151	return PTR_ERR_OR_ZERO(kvm_ptp_clock.ptp_clock);
a0e136d4 MT	152	}
	153
	154	module_init(ptp_kvm_init);
	155	module_exit(ptp_kvm_exit);
	156
	157	MODULE_AUTHOR("Marcelo Tosatti <mtosatti@redhat.com>");
	158	MODULE_DESCRIPTION("PTP clock using KVMCLOCK");
	159	MODULE_LICENSE("GPL");