booke_wdt.c 5.9 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

D
Dave Jiang 已提交
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
{
I
Ingo Molnar 已提交
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 190 191
	return 0;
}

static int booke_wdt_set_timeout(struct watchdog_device *wdt_dev,
				 unsigned int timeout)
{
	if (timeout > MAX_WDT_TIMEOUT)
		return -EINVAL;
	wdt_dev->timeout = timeout;
192
	booke_wdt_set(wdt_dev);
193 194 195 196

	return 0;
}

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

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

210 211 212 213 214
static struct watchdog_device booke_wdt_dev = {
	.info = &booke_wdt_info,
	.ops = &booke_wdt_ops,
	.min_timeout = 1,
	.max_timeout = 0xFFFF
215 216 217 218
};

static void __exit booke_wdt_exit(void)
{
219
	watchdog_unregister_device(&booke_wdt_dev);
220 221 222 223 224
}

static int __init booke_wdt_init(void)
{
	int ret = 0;
225
	bool nowayout = WATCHDOG_NOWAYOUT;
226

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

	ret = watchdog_register_device(&booke_wdt_dev);
236 237 238

	return ret;
}
239 240 241 242

module_init(booke_wdt_init);
module_exit(booke_wdt_exit);

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