/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * tod driver module for OPL (implements a soft tod)
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/modctl.h>
#include <sys/autoconf.h>
#include <sys/debug.h>
#include <sys/clock.h>
#include <sys/cmn_err.h>
#include <sys/prom_plat.h>
#include <sys/cpuvar.h>
#include <sys/opl_module.h>

/*
 * Debug stuff
 */
#ifdef DEBUG
int todopl_debug = 0;
#define	TODOPL_DEBUG(args)  if (todopl_debug) cmn_err args
#else
#define	TODOPL_DEBUG(args)
#endif

#define	abs(x)	((x) < 0 ? -(x) : (x))

#define	TODOPL_SET_THRESHOLD	30

static timestruc_t	todopl_get(void);
static void		todopl_set(timestruc_t);
static uint_t		todopl_set_watchdog_timer(uint_t);
static uint_t		todopl_clear_watchdog_timer(void);
static void		todopl_set_power_alarm(timestruc_t);
static void		todopl_clear_power_alarm(void);
static uint64_t		todopl_get_cpufrequency(void);

/*
 * Module linkage information for the kernel.
 */
static struct modlmisc modlmisc = {
	&mod_miscops, "Soft tod module for OPL 1.11"
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modlmisc, NULL
};

/*
 * The TOD OPL logic description.
 *
 * The todopl driver uses promif functions prom_opl_get_tod() and
 * prom_opl_set_diff(). These functions call FJSV,get-tod and
 * FJSV,set-domain-time OBP client services.
 *
 * At the system boot or reboot:
 *
 *    FJSV,tod-get
 * OS  --------->   OBP     SCF I/F
 *                         ----------->  XSCF
 *                         <-----------
 *     <--------            time, diff
 *    time+diff, stick
 *
 * Note that on first powerup domain boot, diff is zero.
 *
 * When system updates the time via date(1):
 *
 *   FJSV,set-domain-time
 * OS   --------->   OBP                      SRAM
 *      diff_delta        diff += diff_delta ------------->  XSCF
 *
 * diff_delta = new time -  current domain time (hrestime)
 *
 *
 * In theory, FJSV,get-tod and FJSV,set-domain-time should never fails.
 * But, if call to FJSV,get-tod fails on boot, the domain will be unable
 * to calculate "diff" properly and synchronization between Domain and
 * SP will be broken. In this particular case, we notify users that
 * "there is no time synchronization" and the logic will attempt to
 * resync with the SP whenever the OS tries to do a TOD update.
 * (e.g. via date(1) or NTP).
 */

static	int enable_time_sync = 1;

int
_init(void)
{
	int64_t	stick;
	time_t	obp_time = 0;
	int64_t obp_stick;

	if (strcmp(tod_module_name, "todopl") == 0) {
		/*
		 * Get TOD time from OBP and adjust it.
		 */
		prom_opl_get_tod(&obp_time, &obp_stick);

		TODOPL_DEBUG((CE_NOTE, "todopl: OBP time 0x%lx stick 0x%lx\n",
			obp_time, obp_stick));

		if (obp_time != 0) {
			/*
			 * adjust OBP time by stick counts
			 */
			stick_timestamp(&stick);
			obp_time += ((stick - obp_stick) / system_clock_freq);

			TODOPL_DEBUG((CE_NOTE,
				"todopl: cpu stick 0x%lx sys_time 0x%lx\n",
				stick, obp_time));
		} else {
			/*
			 * A date of zero causes the root filesystem driver
			 * to try to set the date from the last shutdown.
			 */
			enable_time_sync = 0;
			cmn_err(CE_WARN, "Initial date is invalid.");
			cmn_err(CE_CONT, "Attempting to set the date and time "
				"based on the last shutdown.\n");
			cmn_err(CE_CONT, "The time could not be synchronized "
				"between Domain and Service Processor.\n");
			cmn_err(CE_CONT, "Please inspect the date and time and "
				"correct if necessary.\n");
		}

		hrestime.tv_sec = obp_time;

		/*
		 * Check that the date has not overflowed a 32-bit integer.
		 */
		if (TIMESPEC_OVERFLOW(&hrestime)) {
			cmn_err(CE_WARN, "Date overflow detected.");
			cmn_err(CE_CONT, "Attempting to set the date and time "
				"based on the last shutdown.\n");
			cmn_err(CE_CONT, "Please inspect the date and time and "
				"correct if necessary.\n");

			hrestime.tv_sec = (time_t)0;
		}

		tod_ops.tod_get = todopl_get;
		tod_ops.tod_set = todopl_set;
		tod_ops.tod_set_watchdog_timer = todopl_set_watchdog_timer;
		tod_ops.tod_clear_watchdog_timer = todopl_clear_watchdog_timer;
		tod_ops.tod_set_power_alarm = todopl_set_power_alarm;
		tod_ops.tod_clear_power_alarm = todopl_clear_power_alarm;
		tod_ops.tod_get_cpufrequency = todopl_get_cpufrequency;

		/*
		 * Flag warning if user tried to use hardware watchdog
		 */
		if (watchdog_enable) {
			cmn_err(CE_WARN, "Hardware watchdog unavailable");
		}
	}

	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	if (strcmp(tod_module_name, "todopl") == 0)
		return (EBUSY);
	else
		return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


/*
 * OPL tod_get is simplified to return hrestime
 * Must be called with tod_lock held.
 */
static timestruc_t
todopl_get(void)
{
	ASSERT(MUTEX_HELD(&tod_lock));
	return (hrestime);
}

/*
 * Must be called with tod_lock held.
 *
 * When running NTP, tod_set is called at least once per second in order
 * to update the hardware clock. To minimize pressure on SP, we want only
 * to record significant time changes on the SP (when date(1) is run).
 * We have 30 seconds threshold requirement before recording the time change.
 */
/* ARGSUSED */
static void
todopl_set(timestruc_t ts)
{
	ASSERT(MUTEX_HELD(&tod_lock));

	if (abs(ts.tv_sec - hrestime.tv_sec) > TODOPL_SET_THRESHOLD) {
		/*
		 * Send time difference to SP
		 */
		if (enable_time_sync)
			prom_opl_set_diff(ts.tv_sec - hrestime.tv_sec);
		else {
			/*
			 * We did not get a successful initial time
			 * update/sync from the SP via OBP during boot.
			 * Try again here.
			 */
			time_t  obp_time = 0;
			int64_t obp_stick;
			int64_t stick;

			prom_opl_get_tod(&obp_time, &obp_stick);

			if (obp_time != 0) {
				/*
				 * adjust OBP time by stick counts
				 */
				stick_timestamp(&stick);
				obp_time += ((stick - obp_stick) /
					system_clock_freq);

				/*
				 * Sync up by computing the diff using the
				 * newly acquired SP/OBP reference time
				 */
				prom_opl_set_diff(ts.tv_sec - obp_time);

				enable_time_sync = 1;
			}
		}
		TODOPL_DEBUG((CE_NOTE, "todopl_set: new domain time 0x%lx\n",
			ts.tv_sec));
	}
}

/*
 * No watchdog function.
 */
/* ARGSUSED */
static uint_t
todopl_set_watchdog_timer(uint_t timeoutval)
{
	ASSERT(MUTEX_HELD(&tod_lock));
	return (0);
}

/*
 * No watchdog function
 */
static uint_t
todopl_clear_watchdog_timer(void)
{
	ASSERT(MUTEX_HELD(&tod_lock));
	return (0);
}

/*
 * Null function.
 */
/* ARGSUSED */
static void
todopl_set_power_alarm(timestruc_t ts)
{
	ASSERT(MUTEX_HELD(&tod_lock));
}

/*
 * Null function
 */
static void
todopl_clear_power_alarm()
{
	ASSERT(MUTEX_HELD(&tod_lock));
}

/*
 * Get clock freq from the cpunode.  This function is only called
 * when use_stick = 0, otherwise, system_clock_freq gets used instead.
 */
uint64_t
todopl_get_cpufrequency(void)
{
	return (cpunodes[CPU->cpu_id].clock_freq);
}