booke_wdt.c 5.85 KB
Newer Older
1 2 3 4
/*
 * Watchdog timer for PowerPC Book-E systems
 *
 * Author: Matthew McClintock
5
 * Maintainer: Kumar Gala <galak@kernel.crashing.org>
6
 *
7
 * Copyright 2005, 2008, 2010-2011 Freescale Semiconductor Inc.
8 9 10 11 12 13 14
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

15 16
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

17
#include <linux/module.h>
18
#include <linux/smp.h>
19 20 21
#include <linux/watchdog.h>

#include <asm/reg_booke.h>
22 23
#include <asm/time.h>
#include <asm/div64.h>
24

25
/* If the kernel parameter wdt=1, the watchdog will be enabled at boot.
26 27 28 29 30 31 32 33
 * Also, the wdt_period sets the watchdog timer period timeout.
 * For E500 cpus the wdt_period sets which bit changing from 0->1 will
 * trigger a watchog timeout. This watchdog timeout will occur 3 times, the
 * first time nothing will happen, the second time a watchdog exception will
 * occur, and the final time the board will reset.
 */


34
#ifdef	CONFIG_PPC_FSL_BOOK3E
35
#define WDTP(x)		((((x)&0x3)<<30)|(((x)&0x3c)<<15))
36
#define WDTP_MASK	(WDTP(0x3f))
37 38
#else
#define WDTP(x)		(TCR_WP(x))
39
#define WDTP_MASK	(TCR_WP_MASK)
40 41
#endif

42 43 44 45
static bool booke_wdt_enabled;
module_param(booke_wdt_enabled, bool, 0);
static int  booke_wdt_period = CONFIG_BOOKE_WDT_DEFAULT_TIMEOUT;
module_param(booke_wdt_period, int, 0);
46

47
#ifdef CONFIG_PPC_FSL_BOOK3E
48

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
/* For the specified period, determine the number of seconds
 * corresponding to the reset time.  There will be a watchdog
 * exception at approximately 3/5 of this time.
 *
 * The formula to calculate this is given by:
 * 2.5 * (2^(63-period+1)) / timebase_freq
 *
 * In order to simplify things, we assume that period is
 * at least 1.  This will still result in a very long timeout.
 */
static unsigned long long period_to_sec(unsigned int period)
{
	unsigned long long tmp = 1ULL << (64 - period);
	unsigned long tmp2 = ppc_tb_freq;

	/* tmp may be a very large number and we don't want to overflow,
	 * so divide the timebase freq instead of multiplying tmp
	 */
	tmp2 = tmp2 / 5 * 2;

	do_div(tmp, tmp2);
	return tmp;
}

/*
 * This procedure will find the highest period which will give a timeout
 * greater than the one required. e.g. for a bus speed of 66666666 and
 * and a parameter of 2 secs, then this procedure will return a value of 38.
 */
static unsigned int sec_to_period(unsigned int secs)
{
	unsigned int period;
	for (period = 63; period > 0; period--) {
		if (period_to_sec(period) >= secs)
			return period;
	}
	return 0;
}

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
#define MAX_WDT_TIMEOUT		period_to_sec(1)

#else /* CONFIG_PPC_FSL_BOOK3E */

static unsigned long long period_to_sec(unsigned int period)
{
	return period;
}

static unsigned int sec_to_period(unsigned int secs)
{
	return secs;
}

#define MAX_WDT_TIMEOUT		3	/* from Kconfig */

#endif /* !CONFIG_PPC_FSL_BOOK3E */

106 107 108
static void __booke_wdt_set(void *data)
{
	u32 val;
109
	struct watchdog_device *wdog = data;
110 111 112

	val = mfspr(SPRN_TCR);
	val &= ~WDTP_MASK;
113
	val |= WDTP(sec_to_period(wdog->timeout));
114 115 116 117

	mtspr(SPRN_TCR, val);
}

118
static void booke_wdt_set(void *data)
119
{
120
	on_each_cpu(__booke_wdt_set, data, 0);
121 122
}

123
static void __booke_wdt_ping(void *data)
124 125 126 127
{
	mtspr(SPRN_TSR, TSR_ENW|TSR_WIS);
}

128
static int booke_wdt_ping(struct watchdog_device *wdog)
129
{
130
	on_each_cpu(__booke_wdt_ping, NULL, 0);
131 132

	return 0;
133 134 135
}

static void __booke_wdt_enable(void *data)
136 137
{
	u32 val;
138
	struct watchdog_device *wdog = data;
139

140
	/* clear status before enabling watchdog */
141
	__booke_wdt_ping(NULL);
142
	val = mfspr(SPRN_TCR);
143
	val &= ~WDTP_MASK;
144
	val |= (TCR_WIE|TCR_WRC(WRC_CHIP)|WDTP(sec_to_period(wdog->timeout)));
145 146 147 148

	mtspr(SPRN_TCR, val);
}

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
/**
 * booke_wdt_disable - disable the watchdog on the given CPU
 *
 * This function is called on each CPU.  It disables the watchdog on that CPU.
 *
 * TCR[WRC] cannot be changed once it has been set to non-zero, but we can
 * effectively disable the watchdog by setting its period to the maximum value.
 */
static void __booke_wdt_disable(void *data)
{
	u32 val;

	val = mfspr(SPRN_TCR);
	val &= ~(TCR_WIE | WDTP_MASK);
	mtspr(SPRN_TCR, val);

	/* clear status to make sure nothing is pending */
	__booke_wdt_ping(NULL);

}

170
static int booke_wdt_start(struct watchdog_device *wdog)
171
{
172
	on_each_cpu(__booke_wdt_enable, wdog, 0);
173
	pr_debug("watchdog enabled (timeout = %u sec)\n", wdog->timeout);
174

175
	return 0;
176 177
}

178
static int booke_wdt_stop(struct watchdog_device *wdog)
179 180
{
	on_each_cpu(__booke_wdt_disable, NULL, 0);
181
	pr_debug("watchdog disabled\n");
182

183 184 185 186 187 188 189
	return 0;
}

static int booke_wdt_set_timeout(struct watchdog_device *wdt_dev,
				 unsigned int timeout)
{
	wdt_dev->timeout = timeout;
190
	booke_wdt_set(wdt_dev);
191 192 193 194

	return 0;
}

195
static struct watchdog_info booke_wdt_info __ro_after_init = {
196 197 198 199
	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
	.identity = "PowerPC Book-E Watchdog",
};

200
static const struct watchdog_ops booke_wdt_ops = {
201
	.owner = THIS_MODULE,
202 203 204 205
	.start = booke_wdt_start,
	.stop = booke_wdt_stop,
	.ping = booke_wdt_ping,
	.set_timeout = booke_wdt_set_timeout,
206 207
};

208 209 210 211
static struct watchdog_device booke_wdt_dev = {
	.info = &booke_wdt_info,
	.ops = &booke_wdt_ops,
	.min_timeout = 1,
212 213 214 215
};

static void __exit booke_wdt_exit(void)
{
216
	watchdog_unregister_device(&booke_wdt_dev);
217 218 219 220 221
}

static int __init booke_wdt_init(void)
{
	int ret = 0;
222
	bool nowayout = WATCHDOG_NOWAYOUT;
223

224
	pr_info("powerpc book-e watchdog driver loaded\n");
225 226
	booke_wdt_info.firmware_version = cur_cpu_spec->pvr_value;
	booke_wdt_set_timeout(&booke_wdt_dev,
227
			      period_to_sec(booke_wdt_period));
228
	watchdog_set_nowayout(&booke_wdt_dev, nowayout);
229
	booke_wdt_dev.max_timeout = MAX_WDT_TIMEOUT;
230
	if (booke_wdt_enabled)
231
		booke_wdt_start(&booke_wdt_dev);
232 233

	ret = watchdog_register_device(&booke_wdt_dev);
234 235 236

	return ret;
}
237 238 239 240

module_init(booke_wdt_init);
module_exit(booke_wdt_exit);

241
MODULE_ALIAS("booke_wdt");
242 243
MODULE_DESCRIPTION("PowerPC Book-E watchdog driver");
MODULE_LICENSE("GPL");