/*
 * Copyright (c) 2014 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Sepherosa Ziehau <sepherosa@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/cpuhelper.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <machine/specialreg.h>
#include <machine/cpufunc.h>
#include <machine/cputypes.h>
#include <machine/md_var.h>

#define INTEL_MSR_PERF_BIAS		0x1b0
#define INTEL_MSR_PERF_BIAS_HINTMASK	0xf

struct perfbias_softc {
	device_t		sc_dev;
	int			sc_cpuid;
	int			sc_hint;

	struct sysctl_ctx_list	sc_sysctl_ctx;
	struct sysctl_oid	*sc_sysctl_tree;
};

static void	perfbias_identify(driver_t *, device_t);
static int	perfbias_probe(device_t);
static int	perfbias_attach(device_t);
static int	perfbias_detach(device_t);

static void	perfbias_set_handler(struct cpuhelper_msg *);
static int	perfbias_set(struct perfbias_softc *, int);

static int	perfbias_sysctl(SYSCTL_HANDLER_ARGS);

static device_method_t perfbias_methods[] = {
	/* Device interface */
	DEVMETHOD(device_identify,	perfbias_identify),
	DEVMETHOD(device_probe,		perfbias_probe),
	DEVMETHOD(device_attach,	perfbias_attach),
	DEVMETHOD(device_detach,	perfbias_detach),

	DEVMETHOD_END
};

static driver_t perfbias_driver = {
	"perfbias",
	perfbias_methods,
	sizeof(struct perfbias_softc),
};

static devclass_t perfbias_devclass;
DRIVER_MODULE(perfbias, cpu, perfbias_driver, perfbias_devclass, NULL, NULL);

static void
perfbias_identify(driver_t *driver, device_t parent)
{
	device_t child;
	u_int regs[4];

	if (device_find_child(parent, "perfbias", -1) != NULL)
		return;

	if (cpu_high < 6 || cpu_vendor_id != CPU_VENDOR_INTEL)
		return;

	do_cpuid(6, regs);
	if ((regs[2] & CPUID_THERMAL2_SETBH) == 0)
		return;

	child = device_add_child(parent, "perfbias", device_get_unit(parent));
	if (child == NULL)
		device_printf(parent, "add perfbias failed\n");
}

static int
perfbias_probe(device_t dev)
{
	device_set_desc(dev, "CPU perf-energy bias");
	return 0;
}

static int
perfbias_attach(device_t dev)
{
	struct perfbias_softc *sc = device_get_softc(dev);

	sc->sc_dev = dev;
	sc->sc_cpuid = device_get_unit(dev);

	sysctl_ctx_init(&sc->sc_sysctl_ctx);
	sc->sc_sysctl_tree = SYSCTL_ADD_NODE(&sc->sc_sysctl_ctx,
	    SYSCTL_STATIC_CHILDREN(_machdep), OID_AUTO,
	    device_get_nameunit(sc->sc_dev), CTLFLAG_RD, 0, "");
	if (sc->sc_sysctl_tree == NULL) {
		device_printf(sc->sc_dev, "can't add sysctl node\n");
		return ENOMEM;
	}

	SYSCTL_ADD_PROC(&sc->sc_sysctl_ctx,
	    SYSCTL_CHILDREN(sc->sc_sysctl_tree),
	    OID_AUTO, "hint", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
	    perfbias_sysctl, "I", "0 - highest perf; 15 - max energy saving");

	return 0;
}

static int
perfbias_detach(device_t dev)
{
	struct perfbias_softc *sc = device_get_softc(dev);

	if (sc->sc_sysctl_tree != NULL)
		sysctl_ctx_free(&sc->sc_sysctl_ctx);

	/* Restore to highest performance */
	perfbias_set(sc, 0);
	return 0;
}

static int
perfbias_sysctl(SYSCTL_HANDLER_ARGS)
{
	struct perfbias_softc *sc = (void *)arg1;
	int error, hint;

	hint = sc->sc_hint;
	error = sysctl_handle_int(oidp, &hint, 0, req);
	if (error || req->newptr == NULL)
		return error;
	if (hint < 0 || hint > INTEL_MSR_PERF_BIAS_HINTMASK)
		return EINVAL;

	return perfbias_set(sc, hint);
}

static void
perfbias_set_handler(struct cpuhelper_msg *msg)
{
	struct perfbias_softc *sc = msg->ch_cbarg;
	uint64_t hint = msg->ch_cbarg1;

	wrmsr(INTEL_MSR_PERF_BIAS, hint);
	hint = rdmsr(INTEL_MSR_PERF_BIAS);

	sc->sc_hint = hint & INTEL_MSR_PERF_BIAS_HINTMASK;

	cpuhelper_replymsg(msg, 0);
}

static int
perfbias_set(struct perfbias_softc *sc, int hint)
{
	struct cpuhelper_msg msg;

	cpuhelper_initmsg(&msg, &curthread->td_msgport,
	    perfbias_set_handler, sc, MSGF_PRIORITY);
	msg.ch_cbarg1 = hint;

	return (cpuhelper_domsg(&msg, sc->sc_cpuid));
}